From 3a54de2d8a7b97ee1432980c41b4edb0f64566d3 Mon Sep 17 00:00:00 2001
From: initial-d <duyimin123@163.com>
Date: Sat, 31 Oct 2026 11:29:12 +0800
Subject: [PATCH 1/4] Add same-table FP16 and INT8 structural compaction
 controls

---
 tests/test_quantized_memory.py          | 167 ++++++++++++
 tests/test_structural_native.py         |  21 ++
 tools/benchmark_quantized_structural.py | 339 ++++++++++++++++++++++++
 tools/quantized_memory.py               | 154 +++++++++++
 4 files changed, 681 insertions(+)
 create mode 100644 tests/test_quantized_memory.py
 create mode 100644 tools/benchmark_quantized_structural.py
 create mode 100644 tools/quantized_memory.py

diff --git a/tests/test_quantized_memory.py b/tests/test_quantized_memory.py
new file mode 100644
index 0000000..0168b48
--- /dev/null
+++ b/tests/test_quantized_memory.py
@@ -0,0 +1,167 @@
+"""Codec/forwarding correctness fixtures; not compression/quality evidence."""
+from argparse import Namespace
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+try:
+    import torch
+except ImportError:
+    torch = None
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+@unittest.skipUnless(np is not None, "optional NumPy required")
+class CodecTest(unittest.TestCase):
+    def test_int8_code_equality_does_not_discard_different_scales(self):
+        from tools.quantized_memory import encode_rows, decode_rows
+        rows = np.array([[1., -.5], [2., -1.], [0., 0.]], dtype=np.float32)
+        encoded = encode_rows(rows, "int8")
+        np.testing.assert_array_equal(encoded[0, :2], encoded[1, :2])
+        self.assertNotEqual(encoded[0].tobytes(), encoded[1].tobytes())
+        decoded = decode_rows(encoded, 2, "int8")
+        np.testing.assert_array_equal(decoded[1], decoded[0] * 2)
+        np.testing.assert_array_equal(decoded[2], 0)
+        # Independent nearest-even oracle: scale 1, +/-0.5 ties round to zero.
+        ties = encode_rows(np.array([[127., .5, -.5, 1.5, -1.5]], dtype=np.float32), "int8")
+        np.testing.assert_array_equal(ties[0, :5].view("i1"), [127, 0, 0, 2, -2])
+
+    def test_finite_subnormal_zero_signed_zero_and_overflow(self):
+        from tools.quantized_memory import encode_rows, decode_rows
+        tiny = np.nextafter(np.float32(0), np.float32(1))
+        rows = np.array([[tiny, -tiny], [0., -0.]], dtype=np.float32)
+        for encoding in ("fp32", "fp16", "int8"):
+            result = decode_rows(encode_rows(rows, encoding), 2, encoding)
+            self.assertTrue(np.isfinite(result).all())
+        self.assertEqual(decode_rows(encode_rows(rows, "fp32"), 2, "fp32").tobytes(), rows.tobytes())
+        for rows, encoding in (([[float("nan")]], "int8"), ([[float("inf")]], "fp32"), ([[1e10]], "fp16")):
+            with self.assertRaises(ValueError):
+                encode_rows(np.array(rows, dtype=np.float32), encoding)
+
+    def test_failed_export_removes_only_new_owned_directory(self):
+        from tools.quantized_memory import pack_quantized
+        rows = np.ones((3, 2), dtype=np.float32)
+        with tempfile.TemporaryDirectory() as tmp:
+            target = Path(tmp) / "bundle"
+            with patch("tools.quantized_memory.pack_native", side_effect=OSError("injected")):
+                with self.assertRaisesRegex(OSError, "injected"):
+                    pack_quantized(rows, target, "int8")
+            self.assertFalse(target.exists())
+            target.mkdir()
+            keep = target / "keep"
+            keep.write_text("existing")
+            with self.assertRaises(FileExistsError):
+                pack_quantized(rows, target, "fp16")
+            self.assertEqual(keep.read_text(), "existing")
+
+
+@unittest.skipUnless(np is not None and shutil.which("cc"), "NumPy and native C compiler required")
+class QuantizedNativeTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = tempfile.TemporaryDirectory()
+        cls.library = Path(cls.tmp.name) / ("rows.dylib" if sys.platform == "darwin" else "rows.so")
+        subprocess.run(["cc", "-std=c11", "-O2", "-fPIC",
+                        "-dynamiclib" if sys.platform == "darwin" else "-shared",
+                        str(ROOT / "native/meft_rows.c"), "-lz", "-o", str(cls.library)],
+                       check=True, capture_output=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.tmp.cleanup()
+
+    def test_original_ids_padding_repeated_queries_and_scale_sensitive_dedup(self):
+        from tools.quantized_memory import pack_quantized, QuantizedRows, encode_rows, decode_rows
+        rows = np.array([[0., 0.], [1., -.5], [2., -1.], [1., -.5]], dtype=np.float32)
+        ids = np.array([3, 0, 2, 1, 3], dtype=np.int64)
+        with tempfile.TemporaryDirectory() as tmp:
+            for encoding in ("fp32", "fp16", "int8"):
+                encoded = encode_rows(rows, encoding)
+                rounded = decode_rows(encoded, 2, encoding)
+                for native in (False, True):
+                    target = Path(tmp) / f"{encoding}-{native}"
+                    meta = pack_quantized(rows, target, encoding, native=native,
+                                          deduplicate=native, max_block_bytes=16)
+                    if native:
+                        self.assertEqual(meta["storage"]["unique_rows"], 3)
+                    with QuantizedRows(target, self.library, cache_bytes=16) as reader:
+                        for _ in range(2):
+                            self.assertEqual(reader.encoded_rows(ids).tobytes(), encoded[ids].tobytes())
+                            self.assertEqual(reader.gather(ids).tobytes(), rounded[ids].tobytes())
+                        self.assertEqual(reader.gather([]).shape, (0, 2))
+                        for bad in ([-1], [4], [1.5], [[0]]):
+                            with self.assertRaises(ValueError):
+                                reader.gather(bad)
+                    with self.assertRaises(ValueError):
+                        reader.gather(ids)
+
+    def test_mark_compact_forwards_entire_quantized_representative(self):
+        from tools.quantized_memory import pack_quantized, QuantizedRows, encode_rows, decode_rows
+        rows = np.array([[0., 0.], [1., .3], [2., .6]], dtype=np.float32)
+        mapping = [0, 1, 1]
+        with tempfile.TemporaryDirectory() as tmp:
+            target = Path(tmp) / "shared"
+            meta = pack_quantized(rows, target, "int8", representatives=mapping,
+                                  row_order=[0, 1, 2], max_block_bytes=12)
+            self.assertEqual(meta["storage"]["marked_rows"], 2)
+            self.assertFalse(meta["source_bytes_preserved"])
+            expected = decode_rows(encode_rows(rows, "int8"), 2, "int8")[mapping]
+            with QuantizedRows(target, self.library) as reader:
+                self.assertEqual(reader.gather([2, 0, 1]).tobytes(), expected[[2, 0, 1]].tobytes())
+
+    @unittest.skipUnless(torch is not None, "optional PyTorch required")
+    def test_quantized_reader_preserves_model_reduction_logits_and_restores_on_failure(self):
+        from tools.quantized_memory import pack_quantized, encode_rows, decode_rows
+        from tools.causal_ngram_lm import CausalNgramLM, fit_registry, encode_segment, evaluate
+        from tools.benchmark_quantized_structural import score_bundle
+        registry = fit_registry("ababc " * 20, 3, 1)
+        model = CausalNgramLM(len(registry["characters"]) + 1, len(registry["grams"]), 8).eval()
+        segment = encode_segment("ababc Xababc " * 2, registry)
+        original = model.memory
+        rows = original.weight.detach().numpy().copy()
+        cfg = Namespace(native_library=self.library, cache_bytes=512, burn_in=3, eval_chunk=8)
+        with tempfile.TemporaryDirectory() as tmp:
+            for encoding in ("fp32", "fp16", "int8"):
+                rounded = decode_rows(encode_rows(rows, encoding), 8, encoding)
+                with torch.no_grad():
+                    original.weight.copy_(torch.from_numpy(rounded))
+                expected = evaluate(model, segment, cfg.burn_in, cfg.eval_chunk)
+                target = Path(tmp) / encoding
+                pack_quantized(rows, target, encoding)
+                actual = score_bundle(model, original, target, segment, cfg)
+                self.assertTrue(torch.equal(actual["logits"], expected["logits"]))
+                self.assertIs(model.memory, original)
+            with patch("tools.benchmark_quantized_structural.evaluate", side_effect=RuntimeError("injected")):
+                with self.assertRaises(RuntimeError):
+                    score_bundle(model, original, target, segment, cfg)
+            self.assertIs(model.memory, original)
+
+
+@unittest.skipUnless(np is not None and torch is not None, "optional NumPy/PyTorch required")
+class ValidationSelectionTest(unittest.TestCase):
+    def test_size_winner_requires_all_budgets_and_cannot_use_test(self):
+        from tools.benchmark_quantized_structural import choose_validation
+        cfg = Namespace(max_ppl_increase=.005, max_kl=.0001, max_top1_flip=.01)
+        def variant(name, size, ppl=0, kl=0, flip=0, encoding="int8"):
+            return {"name": name, "encoding": encoding, "backend_with_key_registry_bytes": size,
+                    "validation_delta": {"perplexity_relative_change": ppl,
+                        "mean_prediction_kl_nats": kl, "top1_changed_fraction": flip}}
+        good = variant("good", 100)
+        candidates = [good, variant("bad-kl", 1, kl=.01), variant("bad-ppl", 2, ppl=.1),
+                      variant("bad-flip", 3, flip=.1), variant("wrong-encoding", 4, encoding="fp16")]
+        good["test"] = {"perplexity_relative_change": 1}
+        self.assertIs(choose_validation(candidates, "int8", cfg), good)
+        self.assertIsNone(choose_validation(candidates[1:], "int8", cfg))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_structural_native.py b/tests/test_structural_native.py
index 2b45d34..44231f9 100644
--- a/tests/test_structural_native.py
+++ b/tests/test_structural_native.py
@@ -97,6 +97,27 @@ def test_joint_final_guard_rejects_direction_norm_and_chain_drift(self):
                 self.assertGreaterEqual(cosine, .99)
                 self.assertGreaterEqual(ratio, .99)
 
+    def test_quantization_before_datrie_plan_keeps_scales_padding_and_original_ids(self):
+        try:
+            import numpy as np
+            from tools.quantized_memory import encode_rows, decode_rows, pack_quantized, QuantizedRows
+            from tools.benchmark_quantized_structural import structural_maps
+        except ImportError:
+            self.skipTest("optional NumPy/PyTorch required")
+        from argparse import Namespace
+        rows = np.array([[0., 0.], [1., 0.], [.996, .089], [2., 0.]], dtype=np.float32)
+        keys = {1: "a", 2: "ab", 3: "abc"}
+        cfg = Namespace(planner="native", structural_library=self.library, norm_ratio=.99)
+        with tempfile.TemporaryDirectory() as tmp:
+            for encoding in ("fp32", "fp16", "int8"):
+                rounded = decode_rows(encode_rows(rows, encoding), 2, encoding)
+                mapping, order = structural_maps(rounded, keys, cfg, .99)
+                self.assertEqual(mapping.tolist(), [0, 1, 1, 3])
+                target = Path(tmp) / encoding
+                pack_quantized(rows, target, encoding, representatives=mapping.tolist(), row_order=order)
+                with QuantizedRows(target, self.rows_library) as reader:
+                    self.assertEqual(reader.gather([2, 0, 3, 1, 2]).tobytes(), rounded[mapping][[2, 0, 3, 1, 2]].tobytes())
+
     def test_engine_cli_uses_original_key_ids_after_structural_compaction(self):
         import contextlib,io,json
         from ngram_store.cli import pack_store,main
diff --git a/tools/benchmark_quantized_structural.py b/tools/benchmark_quantized_structural.py
new file mode 100644
index 0000000..1d22f94
--- /dev/null
+++ b/tools/benchmark_quantized_structural.py
@@ -0,0 +1,339 @@
+"""Same-checkpoint CPU controls for quantization followed by structural sharing.
+
+Reuse cached SGNS rows / GRU checkpoints; never retrain, download or tune on
+test. Native planner is the production DATrie path. The explicit reference
+planner is a different portable greedy prefix/suffix control, not DATrie evidence.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import platform
+import shlex
+import subprocess
+import sys
+import time
+
+import numpy as np
+import torch
+from torch import nn
+
+from tools.benchmark_cosine_merge import fidelity, structural_merge
+from tools.benchmark_causal_lm_compression import text_splits, paired_ppl_interval
+from tools.causal_ngram_lm import CausalNgramLM, encode_segment, evaluate, metric_summary, prediction_delta
+from tools.quantized_memory import encode_rows, decode_rows, pack_quantized, QuantizedRows
+from tools.structural_native import StructuralPlan
+from tools.train_ngram_similarity import prepare, ngrams
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def sha(raw):
+    return hashlib.sha256(raw).hexdigest()
+
+
+def file_sha(path):
+    return sha(Path(path).read_bytes())
+
+
+def structural_maps(rows, keys, cfg, threshold):
+    if cfg.planner == "native":
+        with StructuralPlan(rows.tobytes(), rows.shape[1], keys, cfg.structural_library,
+                            mode="layout" if threshold is None else "joint",
+                            cosine=threshold or .99, norm_ratio=cfg.norm_ratio) as plan:
+            return np.asarray(plan.representatives), plan.row_order
+    keyed = list(keys)
+    representatives = np.arange(len(rows), dtype=np.int64)
+    if threshold is not None:
+        partial = structural_merge(rows[keyed], [keys[i] for i in keyed], threshold, cfg.norm_ratio)
+        representatives[keyed] = np.asarray(keyed)[partial]
+    key_set = set(keys)
+    order = ([i for i in range(len(rows)) if i not in key_set]
+             + [i for i in sorted(keys, key=lambda i: keys[i]) if representatives[i] == i]
+             + [i for i, r in enumerate(representatives) if i != r])
+    if len(order) != len(rows) or len(set(order)) != len(rows) or not np.array_equal(representatives[representatives], representatives):
+        raise AssertionError("invalid original-ID structural map")
+    return representatives, order
+
+
+class ReaderEmbedding(nn.Module):
+    def __init__(self, reader):
+        super().__init__()
+        self.reader = reader
+
+    def forward(self, ids):
+        values = self.reader.gather(ids.detach().cpu().numpy().reshape(-1))
+        return torch.from_numpy(values).reshape(*ids.shape, self.reader.dim)
+
+
+def score_bundle(model, original_memory, directory, segment, cfg):
+    try:
+        with QuantizedRows(directory, cfg.native_library, cache_bytes=cfg.cache_bytes) as reader:
+            model.memory = ReaderEmbedding(reader)
+            return evaluate(model, segment, cfg.burn_in, cfg.eval_chunk)
+    finally:
+        model.memory = original_memory
+
+
+def choose_validation(variants, encoding, cfg):
+    feasible = [v for v in variants if v["encoding"] == encoding
+                and v["validation_delta"]["perplexity_relative_change"] <= cfg.max_ppl_increase
+                and v["validation_delta"]["mean_prediction_kl_nats"] <= cfg.max_kl
+                and v["validation_delta"]["top1_changed_fraction"] <= cfg.max_top1_flip]
+    return min(feasible, key=lambda v: (v["backend_with_key_registry_bytes"], v["name"])) if feasible else None
+
+
+def query_metrics(directory, expected, query, cfg):
+    with QuantizedRows(directory, cfg.native_library, cache_bytes=cfg.cache_bytes) as reader:
+        start = time.perf_counter_ns()
+        output = reader.gather(query)
+        first = (time.perf_counter_ns() - start) / 1e6
+        if output.tobytes() != expected[query].tobytes():
+            raise AssertionError("first gather changed encoded representative output")
+        for _ in range(3):
+            reader.gather(query)
+        samples = []
+        for _ in range(cfg.repeat):
+            start = time.perf_counter_ns()
+            reader.gather(query)
+            samples.append((time.perf_counter_ns() - start) / 1e6)
+        return {"first_empty_application_cache_ms": first,
+                "warm_p50_ms": float(np.median(samples)), "warm_p95_ms": float(np.percentile(samples, 95)),
+                "warm_p99_ms": float(np.percentile(samples, 99)), "samples_ms": samples,
+                "warm_rows_per_second": len(query) / (np.median(samples) / 1000)}
+
+
+def compare(category, order, seed, rows, keys, trace, cfg, model=None, segments=None):
+    directory = cfg.output_dir / f"{category}-order-{order}-seed-{seed}"
+    directory.mkdir()
+    registry_path = directory / "keys.json"
+    registry_path.write_text(json.dumps(keys, ensure_ascii=True, sort_keys=True, separators=(",", ":")) + "\n")
+    common = registry_path.stat().st_size
+    index_bytes = None
+    if cfg.planner == "native":
+        with StructuralPlan(rows.tobytes(), rows.shape[1], keys, cfg.structural_library, mode="layout") as plan:
+            index_path = directory / "keys.das"
+            plan.save_index(index_path)
+            index_bytes = index_path.stat().st_size
+            if plan.lookup(list(keys.values()), index="datrie") != list(keys):
+                raise AssertionError("DATrie key index changed original IDs")
+    other_bytes = 0
+    original_memory = model.memory if model is not None else None
+    baseline = ({name: evaluate(model, segment, cfg.burn_in, cfg.eval_chunk) for name, segment in segments.items()}
+                if model is not None else {})
+    if model is not None:
+        # Actual serialized unchanged model state/registry, not an estimated payload.
+        backbone = {k: v for k, v in model.state_dict().items() if k != "memory.weight"}
+        torch.save({"state": backbone, "registry": cfg.current_registry, "dim": rows.shape[1]}, directory / "backbone.pt")
+        other_bytes = (directory / "backbone.pt").stat().st_size
+    trace = np.asarray(trace, dtype=np.int64)
+    query = trace[:cfg.query_rows]
+    mass = np.bincount(trace, minlength=len(rows))
+    entry = {"category": category, "max_order": order, "seed": seed, "rows": len(rows), "dim": rows.shape[1],
+             "source_float32_sha256": sha(rows.tobytes()), "source_float32_bytes": rows.nbytes,
+             "key_registry_bytes": common, "unchanged_backbone_artifact_bytes": other_bytes,
+             "alternative_datrie_key_index_bytes": index_bytes,
+             "query_rows": len(query), "query_ids_sha256": sha(query.astype("<u8").tobytes()),
+             "frequency_trace_sha256": sha(trace.astype("<u8").tobytes()), "variants": [],
+             "baseline_quality": {name: metric_summary(score) for name, score in baseline.items()}}
+    quantized_scores = {}
+    for encoding in ("fp32", "fp16", "int8"):
+        encoded = encode_rows(rows, encoding)
+        rounded = decode_rows(encoded, rows.shape[1], encoding)
+        _, layout = structural_maps(rounded, keys, cfg, None)
+        specs = [("raw", False, False, None), ("identity", True, False, None),
+                 ("layout", True, False, None), ("dedup", True, True, None)]
+        specs += [(f"joint-{t:g}", True, False, t) for t in cfg.threshold_values]
+        for label, native, dedup, threshold in specs:
+            name = f"{encoding}-{label}"
+            mapping, order_map = np.arange(len(rows)), None
+            if label == "layout":
+                order_map = layout
+            elif threshold is not None:
+                mapping, order_map = structural_maps(rounded, keys, cfg, threshold)
+            target = directory / name
+            start = time.perf_counter()
+            metadata = pack_quantized(rows, target, encoding, native=native,
+                representatives=mapping.tolist() if threshold is not None else None,
+                row_order=order_map, deduplicate=dedup, max_block_bytes=cfg.max_block_bytes)
+            export_seconds = time.perf_counter() - start
+            expected = rounded[mapping]
+            with QuantizedRows(target, cfg.native_library) as reader:
+                for begin in range(0, len(rows), 1024):
+                    ids = np.arange(begin, min(begin + 1024, len(rows)), dtype=np.int64)
+                    if reader.encoded_rows(ids).tobytes() != encoded[mapping[ids]].tobytes():
+                        raise AssertionError("encoded original-ID forwarding mismatch")
+                    if reader.gather(ids).tobytes() != expected[ids].tobytes():
+                        raise AssertionError("decoded row mismatch")
+            serving_bytes = sum(p.stat().st_size for p in target.iterdir())
+            variant = {"name": name, "encoding": encoding, "policy": label, "minimum_cosine": threshold,
+                       "minimum_norm_ratio": cfg.norm_ratio if threshold is not None else None,
+                       "metadata": metadata, "export_seconds": export_seconds,
+                       "representatives_sha256": sha(mapping.astype("<u8").tobytes()),
+                       "structurally_merged_rows": int(np.sum(mapping != np.arange(len(rows)))),
+                       "backend_artifact_bytes": serving_bytes,
+                       "backend_with_key_registry_bytes": serving_bytes + common,
+                       "backend_with_datrie_key_index_bytes": serving_bytes + index_bytes if index_bytes is not None else None,
+                       "full_model_serving_artifact_bytes": serving_bytes + common + other_bytes if model is not None else None,
+                       "fidelity_vs_float32": fidelity(rows, expected, mass),
+                       "added_fidelity_vs_quantization_only": fidelity(rounded, expected, mass),
+                       "all_encoded_rows_and_original_ids_verified": True,
+                       "queries": query_metrics(target, expected, query, cfg)}
+            if model is not None:
+                scores = score_bundle(model, original_memory, target, segments["validation"], cfg)
+                if label == "raw":
+                    quantized_scores[encoding] = scores
+                elif threshold is None and not torch.equal(scores["logits"], quantized_scores[encoding]["logits"]):
+                    raise AssertionError("ordinary encoded storage changed model logits")
+                variant.update({"validation": metric_summary(scores),
+                                "validation_delta": prediction_delta(scores, baseline["validation"]),
+                                "added_validation_delta_vs_quantization_only": prediction_delta(scores, quantized_scores[encoding])})
+            entry["variants"].append(variant)
+        print(json.dumps({"category": category, "order": order, "seed": seed, "encoding": encoding,
+                          "completed_variants": len(entry["variants"])}), flush=True)
+    if model is not None:
+        entry["selection"] = {}
+        # All choices are locked from validation before querying test candidates.
+        selected = {encoding: choose_validation(entry["variants"], encoding, cfg) for encoding in ("fp32", "fp16", "int8")}
+        for encoding, variant in selected.items():
+            if variant is None:
+                entry["selection"][encoding] = {"feasible": False}
+                continue
+            scores = score_bundle(model, original_memory, directory / variant["name"], segments["test"], cfg)
+            delta = prediction_delta(scores, baseline["test"])
+            entry["selection"][encoding] = {"feasible": True, "name": variant["name"],
+                "backend_with_key_registry_bytes": variant["backend_with_key_registry_bytes"],
+                "test": metric_summary(scores), "test_delta": delta,
+                "test_paired_block_interval": paired_ppl_interval(scores, baseline["test"], seed=cfg.eval_seed),
+                "test_all_budgets_passed": (delta["perplexity_relative_change"] <= cfg.max_ppl_increase
+                    and delta["mean_prediction_kl_nats"] <= cfg.max_kl and delta["top1_changed_fraction"] <= cfg.max_top1_flip)}
+        entry["fixed_quantization_test_controls"] = {}
+        for encoding in ("fp16", "int8"):
+            scores = score_bundle(model, original_memory, directory / f"{encoding}-raw", segments["test"], cfg)
+            entry["fixed_quantization_test_controls"][encoding] = {"metrics": metric_summary(scores),
+                "delta": prediction_delta(scores, baseline["test"])}
+    return entry
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    for name in ("sgns-dir", "gru-dir", "corpus", "native-library", "output-dir"):
+        p.add_argument("--" + name, type=Path, required=True)
+    p.add_argument("--planner", choices=("native", "reference"), default="native")
+    p.add_argument("--structural-library", type=Path)
+    p.add_argument("--orders", default="4,8,12")
+    p.add_argument("--seeds", default="3,7,11")
+    p.add_argument("--thresholds", default="0.99,0.98,0.97,0.95,0.90")
+    p.add_argument("--norm-ratio", type=float, default=.99)
+    p.add_argument("--max-block-bytes", type=int, default=8192)
+    p.add_argument("--cache-bytes", type=int, default=4194304)
+    p.add_argument("--query-rows", type=int, default=512)
+    p.add_argument("--repeat", type=int, default=40)
+    p.add_argument("--burn-in", type=int, default=64)
+    p.add_argument("--eval-chunk", type=int, default=256)
+    p.add_argument("--eval-seed", type=int, default=42)
+    p.add_argument("--max-ppl-increase", type=float, default=.005)
+    p.add_argument("--max-kl", type=float, default=.0001)
+    p.add_argument("--max-top1-flip", type=float, default=.01)
+    cfg = p.parse_args()
+    orders, seeds = set(map(int, cfg.orders.split(","))), set(map(int, cfg.seeds.split(",")))
+    cfg.threshold_values = list(map(float, cfg.thresholds.split(",")))
+    if (not orders or not seeds or not cfg.threshold_values or min(orders) < 2 or
+            min(cfg.query_rows, cfg.repeat, cfg.eval_chunk, cfg.max_block_bytes) < 1 or cfg.cache_bytes < 0
+            or cfg.burn_in < max(orders) - 1 or not 0 < cfg.norm_ratio <= 1
+            or any(not 0 < t <= 1 for t in cfg.threshold_values)
+            or min(cfg.max_ppl_increase, cfg.max_kl, cfg.max_top1_flip) < 0
+            or cfg.planner == "native" and cfg.structural_library is None):
+        p.error("invalid dimensions, guards/budgets or missing native structural library")
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    cfg.output_dir.mkdir(parents=True, exist_ok=False)
+    corpus = cfg.corpus.read_bytes()
+    training = {kind: json.loads((path / "report.json").read_text()) for kind, path in
+                (("sgns", cfg.sgns_dir), ("gru", cfg.gru_dir))}
+    if any(t["corpus_sha256"] != sha(corpus) for t in training.values()):
+        raise ValueError("cached corpus differs from training provenance")
+    sources = ["tools/quantized_memory.py", "tools/benchmark_quantized_structural.py", "tools/benchmark_cosine_merge.py",
+               "tools/structural_native.py", "tools/native_row_store.py", "tools/causal_ngram_lm.py", "native/meft_rows.c"]
+    report = {"category": "cached public-text trained SGNS / causal GRU; CPU quantization + structural controls",
+              "commit": subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=ROOT, text=True).strip(),
+              "command": shlex.join([sys.executable, "-m", "tools.benchmark_quantized_structural", *sys.argv[1:]]),
+              "working_directory": str(ROOT), "python": sys.version, "pytorch": torch.__version__,
+              "numpy": np.__version__, "platform": platform.platform(), "cpu": platform.processor(),
+              "logical_cpus": os.cpu_count(), "device": "cpu", "gpu": "unused", "threads": 1, "interop_threads": 1,
+              "compiler": subprocess.check_output(["cc", "--version"], text=True).splitlines()[0],
+              "source_sha256": {name: file_sha(ROOT / name) for name in sources},
+              "working_tree_dirty": bool(subprocess.check_output(["git", "status", "--porcelain", "--untracked-files=no"], cwd=ROOT, text=True).strip()),
+              "native_library_sha256": file_sha(cfg.native_library),
+              "structural_library_sha256": file_sha(cfg.structural_library) if cfg.structural_library else None,
+              "corpus_sha256": sha(corpus), "corpus_source": training["gru"]["corpus_source"],
+              "training_report_sha256": {"sgns": file_sha(cfg.sgns_dir / "report.json"), "gru": file_sha(cfg.gru_dir / "report.json")},
+              "settings": {k: v for k, v in vars(cfg).items() if not isinstance(v, Path)},
+              "selection_rule": "minimum complete backend + common key registry bytes within all validation budgets, separately by encoding; freeze before test; no test reselection",
+              "cost_assumptions": "existing cached weights/text; shared/local single CPU worker; no paid data or GPU; energy/currency cost unmeasured",
+              "limitations": ["Small trained English SGNS/GRU references, not an official trained Engram checkpoint or paper-scale reproduction.",
+                  "Reference planner is portable greedy prefix/suffix selection, not production DATrie; native planner is separately labeled.",
+                  "Selection and primary storage totals use a common actual keys JSON; native runs also report a serialized DATrie alternative separately. No key lookup speed claim.",
+                  "Full GRU bundle sums encoded backend, codec JSON, common keys JSON and actual serialized unchanged backbone/registry; excludes runtime/framework, logs and training checkpoint.",
+                  "Row INT8 is symmetric nearest-even with float32 scale per row; no activation quantization or fine tuning.",
+                  "Quantization occurs before planning; final error is measured against original float32 and quantization-only rows.",
+                  "Filesystem pages are warm after row verification; first query has empty application cache, not disk-cold I/O.",
+                  "Queries include Python/NumPy dequantization and allocations; no fused INT8 kernel, RSS, concurrent traffic or full-model latency claim.",
+                  "One cached corpus, three seeds; SGNS reports vector distortion only, GRU reports character task quality.",
+                  "Corpus license not independently established; raw text, keys, weights and serving bundles stay local."],
+              "runs": [], "failures": []}
+    if sys.platform == "darwin":
+        report["cpu"] = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"], text=True).strip()
+    elif Path("/proc/cpuinfo").exists():
+        report["cpu"] = next(s.split(":", 1)[1].strip() for s in Path("/proc/cpuinfo").read_text().splitlines() if s.startswith("model name"))
+    prepared = {}
+    split = text_splits(corpus.decode(), training["gru"]["settings"]["max_characters"])
+    for kind, trained in training.items():
+        for run in trained["runs"]:
+            order, seed = run["max_order"], run["seed"]
+            if order not in orders or seed not in seeds:
+                continue
+            try:
+                kwargs = {}
+                if kind == "sgns":
+                    if order not in prepared:
+                        words, grams, *_ = prepare(corpus.decode(), order, trained["settings"]["vocab_limit"], trained["settings"]["min_count"])
+                        ids = {g: i for i, g in enumerate(grams)}
+                        prepared[order] = (dict(enumerate(grams)), [ids[g] for w in words for g in ngrams(w, order)])
+                    keys, trace = prepared[order]
+                    source = cfg.sgns_dir / f"order-{order}-seed-{seed}/trained-ngram.f32"
+                    if file_sha(source) != run["learned_row_sha256"]:
+                        raise ValueError("SGNS source hash mismatch")
+                    rows = np.frombuffer(source.read_bytes(), dtype="<f4").reshape(-1, trained["settings"]["dim"])
+                    provenance = {"training_row_sha256": run["learned_row_sha256"]}
+                else:
+                    source = cfg.gru_dir / f"order-{order}-seed-{seed}/reference.pt"
+                    if file_sha(source) != run["checkpoint_sha256"]:
+                        raise ValueError("GRU checkpoint hash mismatch")
+                    state = torch.load(source, map_location="cpu", weights_only=True)
+                    registry = state["registry"]
+                    model = CausalNgramLM(len(registry["characters"]) + 1, len(registry["grams"]), state["dim"])
+                    model.load_state_dict(state["model_state"])
+                    model.eval()
+                    rows = model.memory.weight.detach().numpy().astype("<f4")
+                    keys = {i + 1: g for i, g in enumerate(registry["grams"])}
+                    segments = {name: encode_segment(text, registry) for name, text in split.items() if name != "train"}
+                    trace = segments["validation"]["memory_ids"].numpy().reshape(-1)
+                    cfg.current_registry = registry
+                    kwargs = {"model": model, "segments": segments}
+                    provenance = {"checkpoint_sha256": run["checkpoint_sha256"], "registry_sha256": run["registry_sha256"]}
+                result = compare(kind, order, seed, rows, keys, trace, cfg, **kwargs)
+                result.update(provenance)
+                report["runs"].append(result)
+            except Exception as error:
+                report["failures"].append({"category": kind, "order": order, "seed": seed, "type": type(error).__name__, "error": str(error)})
+                print(json.dumps(report["failures"][-1]), flush=True)
+            (cfg.output_dir / "report.json").write_text(json.dumps(report, indent=2) + "\n")
+    expected = sum(1 for t in training.values() for r in t["runs"] if r["max_order"] in orders and r["seed"] in seeds)
+    if report["failures"] or len(report["runs"]) != expected or not expected:
+        raise SystemExit("incomplete study; preserved failures in report.json")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/quantized_memory.py b/tools/quantized_memory.py
new file mode 100644
index 0000000..6ea5417
--- /dev/null
+++ b/tools/quantized_memory.py
@@ -0,0 +1,154 @@
+"""Frozen CPU row codecs for measured quantization + native compaction.
+
+FP16 and symmetric per-row INT8 are approximate to the float32 source. Native
+packing is exact to their encoded bytes. INT8 stores its float32 scale inside
+each row, so forwarding/dedup never drops the scale. No trainable weight API.
+"""
+import hashlib
+import json
+from pathlib import Path
+import shutil
+
+import numpy as np
+
+from .native_row_store import NativeRows, pack_native
+
+
+def row_width(dim, encoding):
+    if type(dim) is not int or dim < 1 or encoding not in ("fp32", "fp16", "int8"):
+        raise ValueError("positive dimension and fp32/fp16/int8 encoding required")
+    return {"fp32": dim * 4, "fp16": dim * 2, "int8": dim + 4}[encoding]
+
+
+def encode_rows(rows, encoding):
+    rows = np.asarray(rows)
+    if rows.ndim != 2 or min(rows.shape) < 1 or rows.dtype.kind != "f":
+        raise ValueError("nonempty floating-point matrix required")
+    rows = np.ascontiguousarray(rows, dtype="<f4")
+    if not np.isfinite(rows).all():
+        raise ValueError("quantization requires finite float32 source rows")
+    width = row_width(rows.shape[1], encoding)
+    if encoding in ("fp32", "fp16"):
+        with np.errstate(over="ignore"):
+            values = rows.astype("<f4" if encoding == "fp32" else "<f2")
+        if not np.isfinite(values).all():
+            raise ValueError("source overflows the requested encoding")
+        return values.view("u1").reshape(len(rows), width).copy()
+    maximum = np.max(np.abs(rows.astype(np.float64)), axis=1)
+    # Positive subnormals must not produce a zero scale through float32 rounding.
+    scales = np.maximum(maximum / 127, np.finfo(np.float32).tiny).astype("<f4")
+    scales[maximum == 0] = 1
+    values = np.clip(np.rint(rows.astype(np.float64) / scales[:, None]), -127, 127).astype("i1")
+    return np.concatenate((values.view("u1"), scales.view("u1").reshape(-1, 4)), axis=1)
+
+
+def decode_rows(encoded, dim, encoding):
+    encoded = np.asarray(encoded)
+    if encoded.ndim != 2 or encoded.dtype != np.uint8 or encoded.shape[1] != row_width(dim, encoding):
+        raise ValueError("encoded byte matrix has the wrong row width")
+    encoded = np.ascontiguousarray(encoded)
+    if encoding in ("fp32", "fp16"):
+        return encoded.view("<f4" if encoding == "fp32" else "<f2").reshape(-1, dim).astype("<f4", copy=True)
+    scales = np.ascontiguousarray(encoded[:, dim:]).view("<f4").reshape(-1, 1)
+    if not np.isfinite(scales).all() or np.any(scales <= 0):
+        raise ValueError("invalid INT8 scale")
+    return encoded[:, :dim].view("i1").astype("<f4") * scales
+
+
+def pack_quantized(rows, directory, encoding, *, native=True, representatives=None,
+                   row_order=None, deduplicate=False, max_block_bytes=8192):
+    """Publish a new research bundle; include codec metadata in measured bytes."""
+    rows = np.ascontiguousarray(rows, dtype="<f4")
+    encoded = encode_rows(rows, encoding)
+    if not native and (representatives is not None or row_order is not None or deduplicate):
+        raise ValueError("raw baseline must retain original row order without compaction")
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=False)
+    try:
+        source = directory / "staging.rows"
+        source.write_bytes(encoded.tobytes())
+        table = directory / ("table.men" if native else "table.rows")
+        if native:
+            storage = pack_native(source, table, encoded.shape[1], deduplicate=deduplicate,
+                                  predictor="xor", representatives=representatives,
+                                  row_order=row_order, max_block_bytes=max_block_bytes)
+            source.unlink()
+        else:
+            source.rename(table)
+            storage = {"artifact_bytes": table.stat().st_size, "unique_rows": len(rows),
+                       "row_map_bytes": 0, "deduplicate": False}
+        mapping = np.arange(len(rows)) if representatives is None else np.asarray(representatives)
+        expected = decode_rows(encoded[mapping], rows.shape[1], encoding)
+        metadata = {"schema_version": 1, "shape": list(rows.shape), "encoding": encoding,
+                    "byteorder": "little", "backend": "native" if native else "raw_mmap",
+                    "table_file": table.name, "row_bytes": encoded.shape[1], "storage": storage,
+                    "source_float32_sha256": hashlib.sha256(rows.tobytes()).hexdigest(),
+                    "decoded_float32_sha256": hashlib.sha256(expected.tobytes()).hexdigest(),
+                    "table_sha256": hashlib.sha256(table.read_bytes()).hexdigest(),
+                    "source_bytes_preserved": expected.tobytes() == rows.tobytes(),
+                    "int8_scale_bytes_per_physical_row": 4 if encoding == "int8" else 0,
+                    "rounding": "nearest-even; symmetric [-127,127] per-row scale" if encoding == "int8" else encoding,
+                    "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"}
+        (directory / "codec.json").write_text(json.dumps(metadata, indent=2, sort_keys=True) + "\n")
+        return metadata
+    except BaseException:
+        shutil.rmtree(directory)
+        raise
+
+
+class QuantizedRows:
+    """Single-worker CPU lookup; trusted locally produced bundles only."""
+    def __init__(self, directory, library=None, *, cache_bytes=4194304):
+        directory = Path(directory)
+        self.metadata = json.loads((directory / "codec.json").read_text())
+        m = self.metadata
+        if (m["schema_version"] != 1 or m["byteorder"] != "little" or len(m["shape"]) != 2
+                or min(m["shape"]) < 1 or m["row_bytes"] != row_width(m["shape"][1], m["encoding"])
+                or m["table_file"] not in ("table.men", "table.rows")):
+            raise ValueError("invalid local quantized bundle metadata")
+        self.nrows, self.dim = m["shape"]
+        self.encoding, self.width = m["encoding"], m["row_bytes"]
+        self.table = None
+        path = directory / m["table_file"]
+        if m["backend"] == "native":
+            self.table = NativeRows(path, library, cache_bytes=cache_bytes, cache_policy="rows")
+            if self.table.header != {"n_rows": self.nrows, "row_bytes": self.width}:
+                self.close()
+                raise ValueError("native table shape disagrees with codec")
+        elif m["backend"] == "raw_mmap":
+            if path.stat().st_size != self.nrows * self.width:
+                raise ValueError("raw table length disagrees with codec")
+            self.table = np.memmap(path, mode="r", dtype="u1", shape=(self.nrows, self.width))
+        else:
+            raise ValueError("unknown quantized backend")
+
+    def encoded_rows(self, ids):
+        if self.table is None:
+            raise ValueError("quantized rows are closed")
+        ids = np.asarray(ids)
+        if ids.ndim == 1 and ids.size == 0:
+            return np.empty((0, self.width), dtype="u1")
+        if ids.ndim != 1 or ids.dtype.kind not in "iu" or np.any(ids < 0) or np.any(ids >= self.nrows):
+            raise ValueError("one-dimensional original row IDs out of range")
+        if isinstance(self.table, NativeRows):
+            ids = np.ascontiguousarray(ids, dtype="<u8")
+            output = np.empty((len(ids), self.width), dtype="u1")
+            self.table.gather_into(ids.ctypes.data, len(ids), output.ctypes.data, output.nbytes)
+            return output
+        return np.asarray(self.table[ids], dtype="u1")
+
+    def gather(self, ids):
+        return decode_rows(self.encoded_rows(ids), self.dim, self.encoding)
+
+    def close(self):
+        if isinstance(self.table, NativeRows):
+            self.table.close()
+        elif isinstance(self.table, np.memmap):
+            self.table._mmap.close()
+        self.table = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

From 17bca54d063db7307945f02537786238511d52e2 Mon Sep 17 00:00:00 2001
From: initial-d <duyimin123@163.com>
Date: Sat, 31 Oct 2026 11:34:00 +0800
Subject: [PATCH 2/4] Summarize additive storage gains and retain failed
 held-out choices

---
 tests/test_quantized_memory.py        |  20 +++
 tools/analyze_quantized_structural.py | 174 ++++++++++++++++++++++++++
 2 files changed, 194 insertions(+)
 create mode 100644 tools/analyze_quantized_structural.py

diff --git a/tests/test_quantized_memory.py b/tests/test_quantized_memory.py
index 0168b48..2feefd9 100644
--- a/tests/test_quantized_memory.py
+++ b/tests/test_quantized_memory.py
@@ -162,6 +162,26 @@ def variant(name, size, ppl=0, kl=0, flip=0, encoding="int8"):
         self.assertIs(choose_validation(candidates, "int8", cfg), good)
         self.assertIsNone(choose_validation(candidates[1:], "int8", cfg))
 
+    def test_analysis_uses_smallest_matched_baseline_and_preserves_negative_results(self):
+        from tools.analyze_quantized_structural import analyze
+        variants, selections = [], {}
+        for encoding in ("fp32", "fp16", "int8"):
+            for policy, size in (("raw", 100), ("identity", 90), ("layout", 80), ("dedup", 70), ("joint-0.99", 75)):
+                variants.append({"name": f"{encoding}-{policy}", "backend_with_key_registry_bytes": size,
+                    "full_model_serving_artifact_bytes": size + 100,
+                    "fidelity_vs_float32": {"weighted_relative_frobenius": .01, "relative_l2_max": .1},
+                    "added_fidelity_vs_quantization_only": {"weighted_relative_frobenius": .009},
+                    "queries": {"warm_p50_ms": 2 if policy != "raw" else 1}})
+            selections[encoding] = {"feasible": True, "name": f"{encoding}-joint-0.99",
+                                   "test_all_budgets_passed": False, "test_delta": {"mean_prediction_kl_nats": .01}}
+        report = {"commit": "fixture", "settings": {"planner": "native"}, "failures": [],
+                  "runs": [{"category": "gru", "max_order": 4, "seed": 3, "variants": variants, "selection": selections}]}
+        summary = analyze(report)
+        self.assertEqual(summary["models"][0]["best_encoded_baseline"], "fp32-dedup")
+        self.assertLess(summary["models"][0]["joint_099_added_saving_vs_best_encoded_baseline"], 0)
+        self.assertEqual(len(summary["test_budget_exceedances"]), 3)
+        self.assertEqual(summary["models"][0]["validation_selection"]["name"], "fp32-joint-0.99")
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tools/analyze_quantized_structural.py b/tools/analyze_quantized_structural.py
new file mode 100644
index 0000000..3576a2b
--- /dev/null
+++ b/tools/analyze_quantized_structural.py
@@ -0,0 +1,174 @@
+"""Summarize matched encoded baselines without reselecting on test outcomes."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import statistics
+
+ENCODINGS = ("fp32", "fp16", "int8")
+BASELINES = ("raw", "identity", "layout", "dedup")
+SIZE = "backend_with_key_registry_bytes"
+
+
+def distribution(values):
+    return {"n": len(values), "mean": statistics.mean(values),
+            "min": min(values), "max": max(values)}
+
+
+def analyze(report):
+    if report["failures"] or not report["runs"]:
+        raise ValueError("complete successful study required; retain failures in raw report")
+    models, grouped, ids = [], {}, set()
+    for run in report["runs"]:
+        identity = (run["category"], run["max_order"], run["seed"])
+        if identity in ids:
+            raise ValueError("duplicate trained model")
+        ids.add(identity)
+        variants = {v["name"]: v for v in run["variants"]}
+        raw32 = variants["fp32-raw"]
+        for encoding in ENCODINGS:
+            raw = variants[f"{encoding}-raw"]
+            best = min((variants[f"{encoding}-{p}"] for p in BASELINES), key=lambda v: (v[SIZE], v["name"]))
+            joint = variants[f"{encoding}-joint-0.99"]
+            item = {"category": identity[0], "max_order": identity[1], "seed": identity[2], "encoding": encoding,
+                    "raw_encoded_backend_with_keys_bytes": raw[SIZE],
+                    "best_encoded_baseline": best["name"], "best_encoded_baseline_with_keys_bytes": best[SIZE],
+                    "joint_099_backend_with_keys_bytes": joint[SIZE],
+                    "joint_099_added_saving_vs_best_encoded_baseline": 1 - joint[SIZE] / best[SIZE],
+                    "joint_099_saving_vs_raw_encoded": 1 - joint[SIZE] / raw[SIZE],
+                    "joint_099_factor_vs_raw_float32_with_keys": raw32[SIZE] / joint[SIZE],
+                    "joint_099_weighted_relative_frobenius": joint["fidelity_vs_float32"]["weighted_relative_frobenius"],
+                    "joint_099_added_weighted_relative_frobenius": joint["added_fidelity_vs_quantization_only"]["weighted_relative_frobenius"],
+                    "joint_099_max_relative_l2": joint["fidelity_vs_float32"]["relative_l2_max"],
+                    "joint_099_warm_query_ratio_vs_raw_encoded": joint["queries"]["warm_p50_ms"] / raw["queries"]["warm_p50_ms"]}
+            datrie_size = "backend_with_datrie_key_index_bytes"
+            if joint.get(datrie_size) is not None:
+                item["joint_099_added_saving_vs_best_encoded_baseline_with_datrie"] = 1 - joint[datrie_size] / best[datrie_size]
+                item["joint_099_factor_vs_raw_float32_with_datrie"] = raw32[datrie_size] / joint[datrie_size]
+            selected = run.get("selection", {}).get(encoding)
+            if selected:
+                # Preserve the validation choice, including failed test budgets.
+                item["validation_selection"] = selected
+                if selected["feasible"]:
+                    chosen = variants[selected["name"]]
+                    item["selected_added_saving_vs_best_encoded_baseline"] = 1 - chosen[SIZE] / best[SIZE]
+                    item["selected_factor_vs_raw_float32_with_keys"] = raw32[SIZE] / chosen[SIZE]
+                    item["selected_full_model_factor_vs_raw_float32"] = raw32["full_model_serving_artifact_bytes"] / chosen["full_model_serving_artifact_bytes"]
+            models.append(item)
+            grouped.setdefault((identity[0], identity[1], encoding), []).append(item)
+    groups = []
+    metrics = [k for k in models[0] if k.startswith("joint_099_") and k != "joint_099_backend_with_keys_bytes"]
+    for (category, order, encoding), rows in sorted(grouped.items()):
+        group = {"category": category, "max_order": order, "encoding": encoding,
+                 "seeds": [r["seed"] for r in rows],
+                 "joint_099": {key: distribution([r[key] for r in rows]) for key in metrics}}
+        selected = [r for r in rows if r.get("validation_selection", {}).get("feasible")]
+        if selected:
+            group["validation_selected"] = {
+                "feasible_models": len(selected),
+                "test_all_budgets_passed_models": sum(r["validation_selection"]["test_all_budgets_passed"] for r in selected),
+                "selected_names": [r["validation_selection"]["name"] for r in selected],
+                "added_saving_vs_best_encoded_baseline": distribution([r["selected_added_saving_vs_best_encoded_baseline"] for r in selected]),
+                "factor_vs_raw_float32_with_keys": distribution([r["selected_factor_vs_raw_float32_with_keys"] for r in selected]),
+                "full_model_factor_vs_raw_float32": distribution([r["selected_full_model_factor_vs_raw_float32"] for r in selected])}
+        groups.append(group)
+    failed = [{"max_order": r["max_order"], "seed": r["seed"], "encoding": r["encoding"],
+               "name": r["validation_selection"]["name"], "delta": r["validation_selection"]["test_delta"]}
+              for r in models if r.get("validation_selection", {}).get("feasible")
+              and not r["validation_selection"]["test_all_budgets_passed"]]
+    return {"source_commit": report["commit"], "planner": report["settings"]["planner"],
+            "trained_models": len(report["runs"]), "variant_count": sum(len(r["variants"]) for r in report["runs"]),
+            "storage_denominator": "actual encoded backend + codec metadata + common keys JSON; whole GRU serving artifacts also include unchanged serialized backbone/registry",
+            "baseline_rule": "best of raw mmap / native identity / native layout / exact encoded-byte dedup, matched encoding; structural candidates compared against this lower byte count",
+            "error_rule": "final decoded vectors vs original FP32; additional error separately vs quantization-only; frequency weights from actual query traces",
+            "uncertainty": "three-seed min/mean/max are descriptive ranges, not confidence intervals or cross-corpus evidence",
+            "test_selection": "retain per-encoding validation choices; no test-based replacement",
+            "test_budget_exceedances": failed, "models": models, "groups": groups}
+
+
+def plots(report, directory):
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import numpy as np
+    plt.rcParams.update({"font.size": 9, "svg.fonttype": "none"})
+    orders = sorted({r["max_order"] for r in report["runs"]})
+    categories = sorted({r["category"] for r in report["runs"]}, reverse=True)
+    names = ["fp16-raw", "int8-raw", "fp32-joint-0.99", "fp16-joint-0.99", "int8-joint-0.99"]
+    labels = ["FP16", "INT8", "FP32 + S", "FP16 + S", "INT8 + S"]
+    colors = ["#5587b6", "#ed9c42", "#599268", "#83b4d7", "#f7bf7a"]
+    fig, axes = plt.subplots(len(categories), len(orders), figsize=(12, 6), squeeze=False)
+    for row, category in enumerate(categories):
+        for col, order in enumerate(orders):
+            ax = axes[row, col]
+            runs = [r for r in report["runs"] if r["category"] == category and r["max_order"] == order]
+            points = {name: [] for name in names}
+            for run in runs:
+                v = {v["name"]: v for v in run["variants"]}
+                for name in names:
+                    points[name].append(v["fp32-raw"][SIZE] / v[name][SIZE])
+            means = [statistics.mean(points[n]) for n in names]
+            errors = [[m - min(points[n]) for m, n in zip(means, names)],
+                      [max(points[n]) - m for m, n in zip(means, names)]]
+            ax.bar(range(len(names)), means, color=colors, yerr=errors, capsize=3)
+            ax.axhline(1, color="gray", linewidth=.8)
+            ax.set_xticks(range(len(names)), labels, rotation=25, ha="right")
+            ax.set_title(f"{category.upper()}, order {order} (n={len(runs)})")
+            ax.set_ylabel("FP32 raw / stored bytes")
+            ax.grid(axis="y", alpha=.2)
+    fig.suptitle("Complete backend + common keys; S = cosine/norm >= 0.99 on decoded encoded rows\nSeed ranges; fixed threshold, no task-quality guarantee from this plot", fontsize=11)
+    fig.tight_layout(rect=(0, 0, 1, .90))
+    for ext in ("svg", "png"):
+        fig.savefig(directory / f"storage-controls.{ext}", dpi=170)
+    plt.close(fig)
+    fig, axes = plt.subplots(len(categories), len(orders), figsize=(12, 6), squeeze=False)
+    for row, category in enumerate(categories):
+        for col, order in enumerate(orders):
+            ax = axes[row, col]
+            runs = [r for r in report["runs"] if r["category"] == category and r["max_order"] == order]
+            for encoding, color in zip(ENCODINGS, ("#599268", "#5587b6", "#ed9c42")):
+                points = []
+                policies = ["raw"] + [f"joint-{t:g}" for t in report["settings"]["threshold_values"]]
+                for policy in policies:
+                    ratios, errors = [], []
+                    for run in runs:
+                        v = {v["name"]: v for v in run["variants"]}
+                        item = v[f"{encoding}-{policy}"]
+                        ratios.append(v["fp32-raw"][SIZE] / item[SIZE])
+                        errors.append(item["fidelity_vs_float32"]["weighted_relative_frobenius"] * 100)
+                    points.append((statistics.mean(errors), statistics.mean(ratios)))
+                x, y = np.array(points).T
+                ax.plot(x, y, "o-", color=color, markersize=4, label=encoding.upper())
+                for (xx, yy), policy in zip(points, policies):
+                    if policy in ("joint-0.99", "joint-0.9"):
+                        ax.annotate(policy.split("-")[1], (xx, yy), fontsize=7, xytext=(2, 4), textcoords="offset points")
+            ax.set_title(f"{category.upper()}, order {order}")
+            ax.set_xlabel("Query-weighted vector error (%)")
+            ax.set_ylabel("FP32 raw / stored bytes")
+            ax.grid(alpha=.2)
+            ax.legend(fontsize=7)
+    fig.suptitle("Final error vs original FP32; mean of trained seeds\nRaw controls + cosine sweep 0.99, 0.98, 0.97, 0.95, 0.90; norm ratio fixed at 0.99", fontsize=11)
+    fig.tight_layout(rect=(0, 0, 1, .90))
+    for ext in ("svg", "png"):
+        fig.savefig(directory / f"rate-distortion.{ext}", dpi=170)
+    plt.close(fig)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--report", type=Path, required=True)
+    p.add_argument("--output-dir", type=Path, required=True)
+    p.add_argument("--plots", action="store_true")
+    args = p.parse_args()
+    raw = args.report.read_bytes()
+    report = json.loads(raw)
+    summary = analyze(report)
+    summary["raw_report_sha256"] = hashlib.sha256(raw).hexdigest()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    (args.output_dir / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")
+    if args.plots:
+        plots(report, args.output_dir)
+
+
+if __name__ == "__main__":
+    main()

From 96fec051233c6c1c5ccb96fc31324b6f0a1ddd73 Mon Sep 17 00:00:00 2001
From: initial-d <duyimin123@163.com>
Date: Sat, 31 Oct 2026 11:37:22 +0800
Subject: [PATCH 3/4] Keep finite extreme float32 values finite after INT8
 decoding

---
 tests/test_quantized_memory.py        | 4 ++++
 tools/analyze_quantized_structural.py | 2 +-
 tools/quantized_memory.py             | 3 +++
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/test_quantized_memory.py b/tests/test_quantized_memory.py
index 2feefd9..83afea1 100644
--- a/tests/test_quantized_memory.py
+++ b/tests/test_quantized_memory.py
@@ -43,6 +43,10 @@ def test_finite_subnormal_zero_signed_zero_and_overflow(self):
             result = decode_rows(encode_rows(rows, encoding), 2, encoding)
             self.assertTrue(np.isfinite(result).all())
         self.assertEqual(decode_rows(encode_rows(rows, "fp32"), 2, "fp32").tobytes(), rows.tobytes())
+        extreme = np.array([[np.finfo(np.float32).max, -np.finfo(np.float32).max]], dtype=np.float32)
+        decoded = decode_rows(encode_rows(extreme, "int8"), 2, "int8")
+        self.assertTrue(np.isfinite(decoded).all())
+        np.testing.assert_allclose(decoded, extreme, rtol=2e-7, atol=0)
         for rows, encoding in (([[float("nan")]], "int8"), ([[float("inf")]], "fp32"), ([[1e10]], "fp16")):
             with self.assertRaises(ValueError):
                 encode_rows(np.array(rows, dtype=np.float32), encoding)
diff --git a/tools/analyze_quantized_structural.py b/tools/analyze_quantized_structural.py
index 3576a2b..eb126cf 100644
--- a/tools/analyze_quantized_structural.py
+++ b/tools/analyze_quantized_structural.py
@@ -95,7 +95,7 @@ def plots(report, directory):
     orders = sorted({r["max_order"] for r in report["runs"]})
     categories = sorted({r["category"] for r in report["runs"]}, reverse=True)
     names = ["fp16-raw", "int8-raw", "fp32-joint-0.99", "fp16-joint-0.99", "int8-joint-0.99"]
-    labels = ["FP16", "INT8", "FP32 + S", "FP16 + S", "INT8 + S"]
+    labels = ["FP16 raw", "INT8 raw", "FP32 + S", "FP16 + S", "INT8 + S"]
     colors = ["#5587b6", "#ed9c42", "#599268", "#83b4d7", "#f7bf7a"]
     fig, axes = plt.subplots(len(categories), len(orders), figsize=(12, 6), squeeze=False)
     for row, category in enumerate(categories):
diff --git a/tools/quantized_memory.py b/tools/quantized_memory.py
index 6ea5417..24635f0 100644
--- a/tools/quantized_memory.py
+++ b/tools/quantized_memory.py
@@ -37,6 +37,9 @@ def encode_rows(rows, encoding):
     maximum = np.max(np.abs(rows.astype(np.float64)), axis=1)
     # Positive subnormals must not produce a zero scale through float32 rounding.
     scales = np.maximum(maximum / 127, np.finfo(np.float32).tiny).astype("<f4")
+    # Rounding max_float32 / 127 upward makes 127 * scale overflow at decode.
+    finite_ceiling = np.nextafter(np.float32(float(np.finfo(np.float32).max) / 127), np.float32(0))
+    scales = np.minimum(scales, finite_ceiling)
     scales[maximum == 0] = 1
     values = np.clip(np.rint(rows.astype(np.float64) / scales[:, None]), -127, 127).astype("i1")
     return np.concatenate((values.view("u1"), scales.view("u1").reshape(-1, 4)), axis=1)

From 9210e8d8324e7a667c08f6714aa0dc90965eb5c5 Mon Sep 17 00:00:00 2001
From: initial-d <duyimin123@163.com>
Date: Sat, 31 Oct 2026 11:44:41 +0800
Subject: [PATCH 4/4] Publish matched quantization evidence and separate
 fixed-default quality audit

---
 README.md                                     |     1 +
 docs/index.md                                 |     1 +
 docs/ngram_memory_research_plan.md            |     1 +
 .../README.md                                 |   118 +
 .../audit_fixed099.py                         |    82 +
 .../build.txt                                 |     5 +
 .../codec-revision-check.json                 |   613 +
 .../environment-extra.json                    |    11 +
 .../exit.txt                                  |     1 +
 .../fixed099-test-audit.json                  |   994 +
 .../rate-distortion.png                       |   Bin 0 -> 229529 bytes
 .../rate-distortion.svg                       |  2103 +
 .../report.json                               | 71221 ++++++++++++++++
 .../resources-launch-failure.txt              |     1 +
 .../resources.txt                             |     0
 .../run.log                                   |    58 +
 .../run.sh                                    |    15 +
 .../storage-controls.png                      |   Bin 0 -> 151715 bytes
 .../storage-controls.svg                      |  1526 +
 .../summary.json                              |  3586 +
 .../tests.txt                                 |    29 +
 .../verify_codec_revision.py                  |    76 +
 22 files changed, 80442 insertions(+)
 create mode 100644 docs/quantized_structural_evidence_20261031/README.md
 create mode 100644 docs/quantized_structural_evidence_20261031/audit_fixed099.py
 create mode 100644 docs/quantized_structural_evidence_20261031/build.txt
 create mode 100644 docs/quantized_structural_evidence_20261031/codec-revision-check.json
 create mode 100644 docs/quantized_structural_evidence_20261031/environment-extra.json
 create mode 100644 docs/quantized_structural_evidence_20261031/exit.txt
 create mode 100644 docs/quantized_structural_evidence_20261031/fixed099-test-audit.json
 create mode 100644 docs/quantized_structural_evidence_20261031/rate-distortion.png
 create mode 100644 docs/quantized_structural_evidence_20261031/rate-distortion.svg
 create mode 100644 docs/quantized_structural_evidence_20261031/report.json
 create mode 100644 docs/quantized_structural_evidence_20261031/resources-launch-failure.txt
 create mode 100644 docs/quantized_structural_evidence_20261031/resources.txt
 create mode 100644 docs/quantized_structural_evidence_20261031/run.log
 create mode 100644 docs/quantized_structural_evidence_20261031/run.sh
 create mode 100644 docs/quantized_structural_evidence_20261031/storage-controls.png
 create mode 100644 docs/quantized_structural_evidence_20261031/storage-controls.svg
 create mode 100644 docs/quantized_structural_evidence_20261031/summary.json
 create mode 100644 docs/quantized_structural_evidence_20261031/tests.txt
 create mode 100644 docs/quantized_structural_evidence_20261031/verify_codec_revision.py

diff --git a/README.md b/README.md
index 99ea0df..086ef29 100644
--- a/README.md
+++ b/README.md
@@ -108,6 +108,7 @@ external data or GPU. It checks integration, not representative compression.
 | --- | --- |
 | [Actual FastText model](docs/fasttext_native_evidence_20261031/README.md) | 90,380 rows and word/sentence outputs byte-identical; whole bundle saves 0.46%, hot queries slower than dense; structural order has no added benefit here |
 | [Structural contribution controls](docs/structural_native_evidence_20261030/README.md) | Trained SGNS/GRU references measure DATrie and approximate joint sharing separately; exact mode finds no identical rows to merge |
+| [FP16/INT8 + structural controls](docs/quantized_structural_evidence_20261031/README.md) | Same trained tables retain additional approximate savings after quantization; 4-order GRU INT8 regresses; quality failures and fixed-default audit are separate |
 | [1.85M trained-row capacity](docs/cpu_capacity_evidence_20261030/README.md) / [sparse blocks](docs/sparse_blocks_evidence_20261030/README.md) | Smaller blocks lower native miss latency 16–27× relative to the previous native layout; raw mmap remains faster |
 | [TinyEngram/Qwen trained integration](docs/tinyengram_qwen_evidence_20261030/README.md) / [CUDA controls](docs/qwen_cuda_performance_20261030/README.md) | Preserved trained outputs and measured CPU/device costs; native lookup remains slower than dense offload on these traces |
 
diff --git a/docs/index.md b/docs/index.md
index 67b7bf0..2a475ce 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -15,6 +15,7 @@
 
 - [Actual legacy FastText model and matched layout controls](fasttext_native_evidence_20261031/README.md)
 - [Original DATrie / mark-compact contribution ablations](structural_native_evidence_20261030/README.md)
+- [Same-trained-table FP16/INT8 and structural-sharing controls](quantized_structural_evidence_20261031/README.md)
 - [1.85M trained-row CPU capacity](cpu_capacity_evidence_20261030/README.md)
 - [Sparse-block native miss latency](sparse_blocks_evidence_20261030/README.md)
 - [Native query/cache controls](native_query_evidence_20261030/README.md)
diff --git a/docs/ngram_memory_research_plan.md b/docs/ngram_memory_research_plan.md
index 5e97692..68a2a8b 100644
--- a/docs/ngram_memory_research_plan.md
+++ b/docs/ngram_memory_research_plan.md
@@ -125,6 +125,7 @@ work.
 | Original-ID/byte-preserving storage and adapters | [Actual FastText outputs](fasttext_native_evidence_20261031/README.md), [trained TinyEngram/Qwen](tinyengram_qwen_evidence_20261030/README.md), Linux/macOS wheel CI | Frozen handles; reduction contracts differ; official Engram verification uses a demo, not trained weights |
 | Sparse native queries | [1.85M trained rows](cpu_capacity_evidence_20261030/README.md) and [smaller blocks](sparse_blocks_evidence_20261030/README.md) | Misses improved 16–27× over the prior layout; raw mmap remains faster |
 | DATrie / mark-compact | [Trained SGNS/GRU ablations](structural_native_evidence_20261030/README.md) | Exact key indexing helps these traces; no identical structural rows found; extra joint row savings are approximate |
+| Quantization + structural sharing | [18 trained tables, 486 controls](quantized_structural_evidence_20261031/README.md) | Additional savings remain after FP16/INT8 on these references; low-order INT8 can regress; validation-selected test failures are retained |
 | End-to-end artifact cost | [FastText matched controls](fasttext_native_evidence_20261031/README.md) | Whole bundle saves only 0.46%; queries are slower; structural order adds no benefit on this model |
 | Construction/runtime resources | [Implementation boundaries](native_ngram_memory.md) | Structural planning copies full rows/maps offline; cache budgets do not bound RSS; FastText retains an unused 200 MB hash allocation |
 
diff --git a/docs/quantized_structural_evidence_20261031/README.md b/docs/quantized_structural_evidence_20261031/README.md
new file mode 100644
index 0000000..a2b5d05
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/README.md
@@ -0,0 +1,118 @@
+# Quantization and original structural sharing on the same trained tables
+
+The original DATrie prefix/suffix planner and mark-compact retain an additional
+storage contribution after FP16 and per-row INT8 on these trained references.
+It is workload-dependent: INT8 compaction makes the 4-order GRU backend larger.
+Quantization and joint sharing are **approximate to original FP32 weights**;
+native packing preserves their encoded representative bytes and original IDs.
+
+## Matched storage results
+
+Three-seed **means**, fixed cosine and norm ratio 0.99 on decoded encoded rows.
+The denominator is the smallest same-encoding control among raw mmap, native
+identity, native lexical layout and exact encoded-byte dedup. Actual totals
+include the row table, forwarding map, codec metadata, INT8 scales and a common
+keys JSON. Positive values are extra space saved; negative values are regressions.
+
+| Reference / max order | Additional FP16 saving | Additional INT8 saving |
+| --- | ---: | ---: |
+| SGNS / 4 | +22.94% | +20.03% |
+| SGNS / 8 | +33.22% | +28.30% |
+| SGNS / 12 | +33.11% | +28.08% |
+| GRU / 4 | +5.26% | -4.56% |
+| GRU / 8 | +21.13% | +10.95% |
+| GRU / 12 | +25.42% | +15.10% |
+
+SGNS reports vector distortion, without a downstream task claim. The causal
+GRU has held-out character prediction metrics. The DATrie alternative replaces
+common keys JSON with an actual serialized exact-key index; its matched totals
+are also in [report.json](report.json) and [summary.json](summary.json). For INT8,
+those extra savings average 20.78/29.83/29.68% on SGNS and −4.90/12.14/16.90% on
+GRU at orders 4/8/12. Index lookup speed is outside this study.
+
+![Complete storage controls](storage-controls.svg)
+
+## Quality and selection boundaries
+
+The primary study selects the smallest backend within all validation budgets,
+separately by encoding: relative perplexity increase <= 0.5%, mean prediction
+KL <= 0.0001 nats, and top-1 changes <= 1% of positions. All choices are frozen
+before testing selected candidates; fixed raw FP16/INT8 test controls remain
+separate. Paired character-block intervals are reported without reselection.
+
+**20/27 primary validation choices pass all test budgets; seven fail mean KL.**
+The selected INT8 paths pass 8/9: all 4-order runs select raw INT8; 8-order seed 3
+fails KL; all three 12-order selections pass. The latter save an additional
+15.17–15.25% backend bytes over the best INT8 control, or 12.38–12.44% of the
+measured whole serving bundle. Their test perplexity increases 0.0051–0.0208%.
+These selected looser thresholds have maximum per-row relative L2 error of
+31–44%; small task changes do not establish small weight errors.
+
+The fixed default 0.99 bundles receive a **separate post-main-run test audit**
+in [fixed099-test-audit.json](fixed099-test-audit.json): **27/27 pass** the same
+budgets, with test perplexity changes -0.0050% to +0.0172% and maximum mean KL
+1.62e-05 nats. It does not replace any
+primary choices or failures and is not preregistered confirmatory evidence.
+Fixed thresholds were present in the original storage/validation sweep. Future
+quality confirmation needs independent data/checkpoints.
+
+The fixed 0.99 sweep reaches **14.31% maximum per-row relative L2 error** against
+original FP32, including INT8 rounding. “99% cosine” is not “1% vector error.”
+The query-weighted Frobenius curve below includes quantization's own error;
+additional error versus quantization-only is recorded separately. Relaxing the
+cosine guard on GRU adds little capacity benefit while increasing error tails.
+
+![Actual rate–distortion curves](rate-distortion.svg)
+
+Warm CPU gather p50 is **1.04–1.21× raw encoded mmap** for the fixed joint paths,
+including Python/NumPy dequantization. This study supports extra storage savings,
+with a query cost; it does not show a numeric gather speedup. First query means
+empty application cache on warmed filesystem pages, not disk-cold I/O.
+
+## Reproduce and inspect
+
+The primary run used clean source commit
+[`3a54de2`](https://github.com/initial-d/ngram-store/commit/3a54de2d8a7b97ee1432980c41b4edb0f64566d3),
+Python 3.11.15, PyTorch 2.11.0+cu130, NumPy 2.2.6, Linux x86-64 and an AMD EPYC
+7742 shared host. One PyTorch/interop/BLAS worker at nice 19, **CPU only**;
+wall time 8m48s. No weights were trained, external text downloaded or GPU
+programs touched. The corpus/checkpoint/row/source/library hashes and exact
+command are in the raw report. Build flags, tests and timing are retained in
+[build.txt](build.txt), [tests.txt](tests.txt), [run.sh](run.sh), [run.log](run.log)
+and [environment-extra.json](environment-extra.json). An initial launcher failed
+because `/usr/bin/time` was unavailable; [its error](resources-launch-failure.txt)
+is retained. Bash timing was used for the successful run.
+
+This is **18 cached public-text trained models and 486 storage variants**:
+SGNS/GRU orders 4/8/12, seeds 3/7/11; FP32/FP16/INT8, four encoded controls and
+five joint cosine thresholds (0.99/0.98/0.97/0.95/0.90), norm ratio fixed at 0.99.
+The production Linux DATrie planner is used; the portable reference planner is a
+separate smoke-test path. Every encoded row and original-ID forwarding result
+was checked. Planning uses rounded/dequantized rows before physical compaction.
+INT8 is symmetric nearest-even [-127,127], with its float32 scale inside the row.
+
+With the original cached inputs available, build and run the command from
+`run.sh` inside the pinned checkout. Summarize from the current repository:
+
+```bash
+python -m tools.analyze_quantized_structural \
+  --report docs/quantized_structural_evidence_20261031/report.json \
+  --output-dir artifacts/quantized-analysis --plots
+```
+
+A later finite-range INT8 guard prevents decode overflow near max float32.
+[codec-revision-check.json](codec-revision-check.json) verifies identical encoded
+and decoded bytes for all **54 trained encoding inputs**, using
+[verify_codec_revision.py](verify_codec_revision.py). Primary timings remain
+at the pinned study source. [audit_fixed099.py](audit_fixed099.py) reproduces the
+separate default-threshold audit in the pinned remote checkout.
+
+The measured whole GRU bundle sums backend/codec, common keys JSON and an actual
+serialized unchanged backbone/registry; the separate keys JSON duplicates key
+information held inside that registry, so it is a conservative evaluation
+bundle, not a minimal facade. Runtime/framework, training checkpoint, logs and
+builder/RSS costs are excluded. CPU exclusivity and frequency were not pinned.
+These small English SGNS/GRU references are not an official trained DeepSeek
+Engram checkpoint, a paper-scale reproduction, all-language evidence or a
+comparison with every learned/vector quantizer. Raw text, keys, weights and
+serving bundles remain local.
diff --git a/docs/quantized_structural_evidence_20261031/audit_fixed099.py b/docs/quantized_structural_evidence_20261031/audit_fixed099.py
new file mode 100644
index 0000000..3bedacb
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/audit_fixed099.py
@@ -0,0 +1,82 @@
+"""Post-main-run fixed-default quality audit, separate from model selection.
+
+Uses the already declared 0.99 bundles; does not replace failed validation
+choices. This additional test audit is not preregistered confirmatory evidence.
+Run inside the pinned study checkout with the original locally cached inputs.
+"""
+from argparse import ArgumentParser, Namespace
+import hashlib
+import json
+from pathlib import Path
+import platform
+import shlex
+import subprocess
+import sys
+
+import torch
+
+from tools.benchmark_quantized_structural import score_bundle, file_sha
+from tools.benchmark_causal_lm_compression import text_splits, paired_ppl_interval
+from tools.causal_ngram_lm import CausalNgramLM, encode_segment, evaluate, metric_summary, prediction_delta
+
+
+def main():
+    p = ArgumentParser(description=__doc__)
+    p.add_argument("--study-root", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    args = p.parse_args()
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    root = args.study_root
+    report_path = root / "results/report.json"
+    report = json.loads(report_path.read_text())
+    commit = subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip()
+    if commit != report["commit"] or report["failures"] or len(report["runs"]) != 18:
+        raise ValueError("complete pinned primary study required")
+    corpus = Path("artifacts/native-ngram-20261018/corpus/tinyshakespeare.txt")
+    if file_sha(corpus) != report["corpus_sha256"]:
+        raise ValueError("corpus hash mismatch")
+    training = json.loads(Path("artifacts/causal-lm-compression-20261024/report.json").read_text())
+    text = text_splits(corpus.read_text(), training["settings"]["max_characters"])["test"]
+    cfg = Namespace(**report["settings"], native_library=Path("build/libmeft_rows.so"))
+    checks = []
+    for run in report["runs"]:
+        if run["category"] != "gru":
+            continue
+        checkpoint = Path("artifacts/causal-lm-compression-20261024") / f"order-{run['max_order']}-seed-{run['seed']}/reference.pt"
+        if file_sha(checkpoint) != run["checkpoint_sha256"]:
+            raise ValueError("checkpoint hash mismatch")
+        state = torch.load(checkpoint, map_location="cpu", weights_only=True)
+        model = CausalNgramLM(len(state["registry"]["characters"]) + 1, len(state["registry"]["grams"]), state["dim"])
+        model.load_state_dict(state["model_state"])
+        model.eval()
+        original = model.memory
+        segment = encode_segment(text, state["registry"])
+        baseline = evaluate(model, segment, cfg.burn_in, cfg.eval_chunk)
+        variants = {v["name"]: v for v in run["variants"]}
+        for encoding in ("fp32", "fp16", "int8"):
+            name = encoding + "-joint-0.99"
+            directory = root / "results" / f"gru-order-{run['max_order']}-seed-{run['seed']}" / name
+            if file_sha(directory / "table.men") != variants[name]["metadata"]["table_sha256"]:
+                raise ValueError("frozen bundle hash mismatch")
+            scores = score_bundle(model, original, directory, segment, cfg)
+            delta = prediction_delta(scores, baseline)
+            checks.append({"max_order": run["max_order"], "seed": run["seed"], "encoding": encoding,
+                "name": name, "checkpoint_sha256": run["checkpoint_sha256"],
+                "test": metric_summary(scores), "test_delta": delta,
+                "test_paired_block_interval": paired_ppl_interval(scores, baseline, seed=cfg.eval_seed),
+                "test_all_budgets_passed": delta["perplexity_relative_change"] <= cfg.max_ppl_increase
+                    and delta["mean_prediction_kl_nats"] <= cfg.max_kl and delta["top1_changed_fraction"] <= cfg.max_top1_flip})
+    result = {"category": "post-main-run fixed-default test audit; not preregistered confirmatory evidence",
+              "primary_report_sha256": file_sha(report_path), "commit": commit,
+              "script_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+              "command": shlex.join([sys.executable, *sys.argv]), "python": sys.version,
+              "pytorch": torch.__version__, "platform": platform.platform(), "device": "cpu", "gpu": "unused",
+              "threads": 1, "interop_threads": 1, "primary_validation_choices_unchanged": True,
+              "quality_budgets": {"ppl_relative": cfg.max_ppl_increase, "mean_kl_nats": cfg.max_kl, "top1_flip_fraction": cfg.max_top1_flip},
+              "checks": checks}
+    args.output.write_text(json.dumps(result, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/quantized_structural_evidence_20261031/build.txt b/docs/quantized_structural_evidence_20261031/build.txt
new file mode 100644
index 0000000..7cb4b6e
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/build.txt
@@ -0,0 +1,5 @@
+mkdir -p build
+cc -std=c11 -O2 -Wall -Wextra -Werror -fPIC -shared native/meft_rows.c -lz -o build/libmeft_rows.so
+cc -std=c11 -O2 -Wall -Wextra -Werror -Inative examples/native_gather.c native/meft_rows.c -lz -o build/native_gather
+mkdir -p build
+c++ -std=c++11 -O2 -Wall -Wextra -Werror -fPIC -shared -Isrc -Imylib/include native/meft_structural.cc -L./mylib/lib -ltrie -lpub -o build/libmeft_structural.so
diff --git a/docs/quantized_structural_evidence_20261031/codec-revision-check.json b/docs/quantized_structural_evidence_20261031/codec-revision-check.json
new file mode 100644
index 0000000..fd47559
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/codec-revision-check.json
@@ -0,0 +1,613 @@
+{
+  "study_commit": "3a54de2d8a7b97ee1432980c41b4edb0f64566d3",
+  "report_sha256": "eb73b44ef9ccd359160b38a371c2629f9c1f7ea8d0990450dc67ec125cfa08d0",
+  "revision_commit": "96fec051233c6c1c5ccb96fc31324b6f0a1ddd73",
+  "revision_codec_sha256": "83a4c206b171cc69788efa56023fd7df3138ee609e91ecbd084526d43e7e58c6",
+  "verification_script_sha256": "0dda2beaf2016aeb478d21c26799d285e3f951ff538def057c12948fe535a950",
+  "command": "/tmp/projects-push-20261028-venv/bin/python docs/quantized_structural_evidence_20261031/verify_codec_revision.py --report docs/quantized_structural_evidence_20261031/report.json --sgns-dir artifacts/native-ngram-20261018/trained-reference --gru-dir artifacts/causal-lm-compression-20261024 --output docs/quantized_structural_evidence_20261031/codec-revision-check.json",
+  "working_directory": "/Users/duyimin/Documents/Codex/2026-09-12/github/work/me_fasttext",
+  "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]",
+  "pytorch": "2.14.1",
+  "numpy": "2.5.4",
+  "platform": "macOS-26.6.2-arm64-arm-64bit",
+  "device": "cpu",
+  "gpu": "unused",
+  "all_trained_encodings_unchanged": true,
+  "checks": [
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "encoded_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "decoded_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "encoded_sha256": "52145b2df4fa23885150f1e519fa52a4ec2a87a67d7d95a528f5872c4325106a",
+      "decoded_sha256": "296818b431b3b39a43a36929a876a94efefae21f382f9e84d4ec3286e3b60d62",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "encoded_sha256": "3b63b97be01c401d71fc1bf035e8bf67562f67ea700ec0b3e088fb0cf12870ee",
+      "decoded_sha256": "ff95d9bd81bb9e89be385208a5831f5c37605223682f339f292564a62faacc42",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "encoded_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "decoded_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "encoded_sha256": "4d5e89355e425d36118ebf293bc515da98012d2b8cfb74d7abef5c01f93e5d8b",
+      "decoded_sha256": "590fdfdcc048589926d117e6f06ff1ebd64a0fd2815cc57b8de70080aab734da",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "encoded_sha256": "1695a383af41a932d3e663426935548621422726475092855d2e0fca6971008f",
+      "decoded_sha256": "5208f73b4895fa6286c9b958779d6930895d8e6968f9ee970b34284151bd9200",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "encoded_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "decoded_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "encoded_sha256": "0ed0935ce9f5e17b24267182eca235c452de95389f0197f3762fa1b231326bce",
+      "decoded_sha256": "31d7dd18c6916ca11b7d50daa0b11adb6c6761085215b2407cd691841766649b",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "encoded_sha256": "39a5bfb46dcda9abae79229e8fb09380005212fafa61770793c05a633311fbe3",
+      "decoded_sha256": "49c40289aa5709af39591af7618b4d2796626664399a25a1da1c9f1231474746",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "encoded_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "decoded_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "encoded_sha256": "6246b2b9b270b1f329de11d92199f3fb5bb751123b26cb5a9f7b789465490a8b",
+      "decoded_sha256": "df8b79955d7468b7b2f0161394c5f6357e57ff0ab38d908a1ce9d750765b1361",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "encoded_sha256": "7c01f03bbb40873f368ce12e55598733cbd8271f035cb510761f8f5794d8d841",
+      "decoded_sha256": "9f777ab7bd00dedb4404ea8845e359fbaf82aaa095e98cfef4783fbcfeb33df4",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "encoded_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "decoded_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "encoded_sha256": "2b80ff97b7f3a0bdc95ac7eead482fad4fb6e9e7e25c67eb90f9c67d3d9aefef",
+      "decoded_sha256": "96287e438559898544cb2b53c3e3e1b1fc356fa0de75846da54b3e109092a525",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "encoded_sha256": "2f4c5b511ef141ff93c2e65b8dfe703922f9a8ceb888373c3404c3637462433c",
+      "decoded_sha256": "936ada1dd32ce053f2eae8e789655b9755eedb813052ae37096c04d212ea1676",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "encoded_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "decoded_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "encoded_sha256": "7181664941ce04822304ee6afc0b67f281d64784883f2bd11a965520e8851501",
+      "decoded_sha256": "745262c69f54fbc70dbe6d692411472e46846937961b94d94883afac06df3fa3",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "encoded_sha256": "145179f5873a93b683607b1475e5ff91182ff4d09cf914774cef2ef32c002ed1",
+      "decoded_sha256": "ed5fe2646195c36093dae73b4e27ecb710aaf4493c4643375246e406ec0f1dfd",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "encoded_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "decoded_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "encoded_sha256": "f398ae975042657c209fa7ae6041b7bf9b9ad537f36366d974ec5992fba17f9b",
+      "decoded_sha256": "965e67427fd2f63b0379f2c343356af421d0b17cd7971cffda2236625ac6d2b2",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "encoded_sha256": "4bdc5394076e8f3096248d2b1217897e6d6f7716cf114cd367d91f7100a27c2d",
+      "decoded_sha256": "d37754bf9356e1c82806b733d2f09d6fcd41d5b2725b70c407328b1a5c7fe149",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "encoded_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "decoded_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "encoded_sha256": "c09228c734adcadf26af9e437aa54e9dbbc0d275c3c2a829e871216873acebd6",
+      "decoded_sha256": "a6f992eab989830921c022ff3d6f88caceeb1eeebe107b7ccc88caeb09e9ca68",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "encoded_sha256": "0e2bdbfbc8dca09e94a85dd1f3349a0af8a377df57076f698fe6ceb081197dee",
+      "decoded_sha256": "f74165bb32ed3307f423ea4917e648ddb56eef15fa4521f69fd6f16fc3599f66",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "encoded_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "decoded_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "encoded_sha256": "891a04cf80ccfbc91b7e235af0b0a5c951005e27e177a089c05291a8bae10358",
+      "decoded_sha256": "58a8afde490d0e308f8add0008e5239d0de80c72e72d6d5ff0e13f47acc810a9",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "encoded_sha256": "c32e129ca5dd95b920e1532b4fa43658b2d93d5a6a71a0c7ba8b53ed4163e1c5",
+      "decoded_sha256": "1c37947f29f3da25c424fdd730690d3a4a1f55296f4034cf343a6892d5710e81",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "encoded_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "decoded_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "encoded_sha256": "080d6efb61408847148fbcc3c917499b8c29966c124b53c22e9aeca49ffbf968",
+      "decoded_sha256": "d87571fa9337131f33612c6b040cbda96d6836e255a7c1cac1b5b07b4f12bd42",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "encoded_sha256": "49e03d9e3f51e955fe94dc7e04708d1b097f5f5abbc78925511998693be3084e",
+      "decoded_sha256": "11d317c88faf40d248e5062c81409488c5bb22cad5013acb677fd2fa7b6038a7",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "encoded_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "decoded_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "encoded_sha256": "be3e6cb3faabcf8e7951e8696b5142f010d1678db8d4b7364a8077e60007e139",
+      "decoded_sha256": "811798cfb33aa60ba8fe68fa7bdc76afdb78f8ca17a89d0774d37291da0f6e18",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "encoded_sha256": "286e59cb1634e5510ae31256135a585ad96dc5281b739140ec86c3f850c402a8",
+      "decoded_sha256": "f6ffab41a644dd67e026935d7b50595b09e149dee71f6d058748771dac0f90df",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "encoded_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "decoded_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "encoded_sha256": "ae77e374b3687298bc905011989dd5cea95a297efdc59cae484cf38c92f8e8d1",
+      "decoded_sha256": "8f131fcc83bb844ad4e9d610693f55687d566532851a2724e31525d9369c4017",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "encoded_sha256": "33f22b0adf51608d72dafdd55c404069b6392555fde3ce9cbe2da3193605ee03",
+      "decoded_sha256": "c24044479e6740e64c7477e0129737cf3fc9833330c87891041560fc8979c289",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "encoded_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "decoded_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "encoded_sha256": "633749180e09d591673ccc3cf1af107d9c7a628d9e13375f718a588d76d8dfc8",
+      "decoded_sha256": "bac7d3501f88195092d63ba68dffadd151fe5e79cbc8b496139da8f07b095ef3",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "encoded_sha256": "23ed365ab52b2ccf14770d2c13290520d0466caddd4128ccac1db828a6843ff3",
+      "decoded_sha256": "7a21ec1590d5c8c461d39c7936eefcd8c2a50245cde875af4712b68897f74de2",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "encoded_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "decoded_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "encoded_sha256": "b9d730c7176cf58fede8bab1219fb42cb9ca785bdab964772b80efc4d4c0dcab",
+      "decoded_sha256": "5e1e9eb12dad3c914b817161ca8ba461f69a9a80c798a2f75f2a1c88f00a27a2",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "encoded_sha256": "7971ce6013cd10940ea0859b9f441072b9e4740e2e29e5921eacca0a1b7e229b",
+      "decoded_sha256": "825e9083d4fb773e7477d19b942e81d71aa7941df0d31375fb16b12950b6837f",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "encoded_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "decoded_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "encoded_sha256": "dc1bc47aaa923557f0743007570dfa78218b7b4f83c5f736f5d9ba4446f6a6c1",
+      "decoded_sha256": "add9a6b9c5875f02dc14dc3783c9953d7edb14426c4012649076815ddb6e1c71",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "encoded_sha256": "80c1610db9ec1aeaad5f260db8066dd9509b9548ce61e66c9563ff1efe6127ca",
+      "decoded_sha256": "fbf67b027d9c0471b313f44fdd647110f6a4ee32fdb01f42ab8203b4476c24a3",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp32",
+      "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "encoded_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "decoded_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp16",
+      "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "encoded_sha256": "90c4d98b998a5e102a57ac4c4bbec828fa37973f1ce190c7e5052edf80b98b29",
+      "decoded_sha256": "212e57b5fa9fcef9bbaf640d7bbb586eb6dec1a60e9e380099be530a0d30a4a2",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "int8",
+      "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "encoded_sha256": "c6b56112cce3e1b0060ebf715a19f2aa46b58a9555a1fddb0277cd94bbec29c3",
+      "decoded_sha256": "2ac1cbfa580f67daaec9296dbc36834c852d35f0c2ac598a3062f05020c54a6d",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp32",
+      "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "encoded_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "decoded_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp16",
+      "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "encoded_sha256": "be124675b47f909e61b0388745ad00b3ed3a74bff02b3b5a333d38787d391165",
+      "decoded_sha256": "b9e46c364634283ab41e551138f1ada23921e31ee48a04dd3989a3da162f7b1f",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "int8",
+      "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "encoded_sha256": "61f44b3bbe97af40b409ed69d9a05639fccb6f8c969bbfc0894eb7d256edc14c",
+      "decoded_sha256": "bb7617c7380056f8d86ab747df137ba8166ea9c736901a80e4911c8d837e3aa2",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "encoded_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "decoded_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "encoded_sha256": "0676720f8d94a19e6237b1d04171a8f31c1f922cb1452938976a65b4f39f5ef7",
+      "decoded_sha256": "bdea909d0738ce1a9112cfdf55e058286ffdf48616c95623b85c5865be33ab4e",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "int8",
+      "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "encoded_sha256": "f84441c1beaa17ea1a7fb7964f5ef9138678520636b2201e52c2ff5a42fa6216",
+      "decoded_sha256": "126915e8d6c63c5a39ba052c391baeecb89382e4804054d3eecec1f79d5ff7a1",
+      "encoded_bytes_identical": true,
+      "decoded_bytes_identical": true
+    }
+  ],
+  "scope": "byte compatibility of a finite-range guard; benchmark timings remain tied to the original study commit"
+}
diff --git a/docs/quantized_structural_evidence_20261031/environment-extra.json b/docs/quantized_structural_evidence_20261031/environment-extra.json
new file mode 100644
index 0000000..7d6eb91
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/environment-extra.json
@@ -0,0 +1,11 @@
+{
+  "platform": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35",
+  "cpu": "AMD EPYC 7742 64-Core Processor",
+  "logical_cpus": 255,
+  "host_MemTotal": "2113631756 kB",
+  "CUDA_VISIBLE_DEVICES": "",
+  "experiment_device": "cpu",
+  "experiment_GPU": "unused",
+  "worker_policy": "one PyTorch/interop/BLAS worker at nice 19",
+  "shared_host": "no exclusivity or CPU frequency pinning; no full-model latency/RSS claim"
+}
diff --git a/docs/quantized_structural_evidence_20261031/exit.txt b/docs/quantized_structural_evidence_20261031/exit.txt
new file mode 100644
index 0000000..573541a
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/exit.txt
@@ -0,0 +1 @@
+0
diff --git a/docs/quantized_structural_evidence_20261031/fixed099-test-audit.json b/docs/quantized_structural_evidence_20261031/fixed099-test-audit.json
new file mode 100644
index 0000000..7b7efd3
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/fixed099-test-audit.json
@@ -0,0 +1,994 @@
+{
+  "category": "post-main-run fixed-default test audit; not preregistered confirmatory evidence",
+  "primary_report_sha256": "eb73b44ef9ccd359160b38a371c2629f9c1f7ea8d0990450dc67ec125cfa08d0",
+  "commit": "3a54de2d8a7b97ee1432980c41b4edb0f64566d3",
+  "script_sha256": "dffa700970f77de375a1ee85b2ef8b9ee1e2b325400e5bf00fa75899da79fc3f",
+  "command": "/llm-align/duyimin/meft-cuda-20261030/compat/bin/python /llm-align/duyimin/ngram-quantized-20261031/audit_fixed099.py --study-root /llm-align/duyimin/ngram-quantized-20261031 --output /llm-align/duyimin/ngram-quantized-20261031/fixed099-test-audit.json",
+  "python": "3.11.15 (main, Mar 11 2026, 17:20:07) [GCC 14.3.0]",
+  "pytorch": "2.11.0+cu130",
+  "platform": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35",
+  "device": "cpu",
+  "gpu": "unused",
+  "threads": 1,
+  "interop_threads": 1,
+  "primary_validation_choices_unchanged": true,
+  "quality_budgets": {
+    "ppl_relative": 0.005,
+    "mean_kl_nats": 0.0001,
+    "top1_flip_fraction": 0.01
+  },
+  "checks": [
+    {
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "3576a59df8b4c48fb5cac466445e0472fd53af1450d4c7ffe30d612cf90a6214",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6103373426612577,
+        "character_perplexity": 5.004499174179104,
+        "next_character_accuracy": 0.5304761174576401,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -1.529360408315738e-05,
+        "mean_prediction_kl_nats": 1.7120831127003061e-06,
+        "prediction_kl_p99_nats": 2.61046410822912e-05,
+        "maximum_prediction_kl_nats": 0.006801602568104317,
+        "top1_changed_fraction": 0.00030667791152342254,
+        "accuracy_change": 0.00015333895576175038,
+        "maximum_absolute_logit_change": 0.23801040649414062,
+        "maximum_per_target_cross_entropy_increase": 0.04171037673950195
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -4.49829433719927e-05,
+          1.578541096372571e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "3576a59df8b4c48fb5cac466445e0472fd53af1450d4c7ffe30d612cf90a6214",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6103393421233734,
+        "character_perplexity": 5.004509180495614,
+        "next_character_accuracy": 0.5304761174576401,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -1.3294170547612814e-05,
+        "mean_prediction_kl_nats": 1.7180402708530163e-06,
+        "prediction_kl_p99_nats": 2.6131037333991233e-05,
+        "maximum_prediction_kl_nats": 0.006808221062134263,
+        "top1_changed_fraction": 0.00030667791152342254,
+        "accuracy_change": 0.00015333895576175038,
+        "maximum_absolute_logit_change": 0.2380363941192627,
+        "maximum_per_target_cross_entropy_increase": 0.0414736270904541
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -4.4146196455216834e-05,
+          1.7773715874158032e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "3576a59df8b4c48fb5cac466445e0472fd53af1450d4c7ffe30d612cf90a6214",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6103923585218516,
+        "character_perplexity": 5.004774508581822,
+        "next_character_accuracy": 0.5307827953691635,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 3.972292849695186e-05,
+        "mean_prediction_kl_nats": 4.650944368526283e-06,
+        "prediction_kl_p99_nats": 3.989562640500141e-05,
+        "maximum_prediction_kl_nats": 0.00023002610755576934,
+        "top1_changed_fraction": 0.001456720079736257,
+        "accuracy_change": 0.00046001686728514013,
+        "maximum_absolute_logit_change": 0.23500752449035645,
+        "maximum_per_target_cross_entropy_increase": 0.0469362735748291
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -1.9605531140350766e-05,
+          9.964713218480278e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "2a6ed05f8dd35bbd2851b5fa21fc34024df681e447fa8e426f5a8888bd13a567",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6155380906501848,
+        "character_perplexity": 5.030594110972346,
+        "next_character_accuracy": 0.5292494058115464,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 1.926555862198874e-05,
+        "mean_prediction_kl_nats": 1.8032067723003644e-06,
+        "prediction_kl_p99_nats": 3.1012494730281556e-05,
+        "maximum_prediction_kl_nats": 0.007373327653580067,
+        "top1_changed_fraction": 7.666947788085564e-05,
+        "accuracy_change": 0.0,
+        "maximum_absolute_logit_change": 0.27645206451416016,
+        "maximum_per_target_cross_entropy_increase": 0.05068206787109375
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -1.4909351380242913e-05,
+          5.253368237548624e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "2a6ed05f8dd35bbd2851b5fa21fc34024df681e447fa8e426f5a8888bd13a567",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6155369363808263,
+        "character_perplexity": 5.030588304315059,
+        "next_character_accuracy": 0.5292494058115464,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 1.8111267692118655e-05,
+        "mean_prediction_kl_nats": 1.806716082822584e-06,
+        "prediction_kl_p99_nats": 3.0720688622257e-05,
+        "maximum_prediction_kl_nats": 0.007369757393799058,
+        "top1_changed_fraction": 7.666947788085564e-05,
+        "accuracy_change": 0.0,
+        "maximum_absolute_logit_change": 0.2763652801513672,
+        "maximum_per_target_cross_entropy_increase": 0.050493717193603516
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -1.6793097959892104e-05,
+          5.1660681147827815e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "2a6ed05f8dd35bbd2851b5fa21fc34024df681e447fa8e426f5a8888bd13a567",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6155529379265168,
+        "character_perplexity": 5.030668802147704,
+        "next_character_accuracy": 0.5290960668557847,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 3.4113231218572145e-05,
+        "mean_prediction_kl_nats": 5.387190218382436e-06,
+        "prediction_kl_p99_nats": 4.374685590493577e-05,
+        "maximum_prediction_kl_nats": 0.007245252561058059,
+        "top1_changed_fraction": 0.0011500421682128345,
+        "accuracy_change": -0.00015333895576175038,
+        "maximum_absolute_logit_change": 0.2737741470336914,
+        "maximum_per_target_cross_entropy_increase": 0.04021501541137695
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -3.19065058511605e-05,
+          9.508497865481893e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "6f98acbd06c462d38cca0009605daa5986430f75993f62e281fc35ba0be9f1eb",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6054732126006208,
+        "character_perplexity": 4.98021574606221,
+        "next_character_accuracy": 0.5310128038028061,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -2.673351857648717e-05,
+        "mean_prediction_kl_nats": 4.141369138910643e-06,
+        "prediction_kl_p99_nats": 4.696098081167984e-05,
+        "maximum_prediction_kl_nats": 0.00394455171979604,
+        "top1_changed_fraction": 0.0002300084336425669,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.23698687553405762,
+        "maximum_per_target_cross_entropy_increase": 0.11077344417572021
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -8.15899644717028e-05,
+          2.695571292072103e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "6f98acbd06c462d38cca0009605daa5986430f75993f62e281fc35ba0be9f1eb",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6054735438230436,
+        "character_perplexity": 4.980217395621609,
+        "next_character_accuracy": 0.5310128038028061,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -2.6402304953656114e-05,
+        "mean_prediction_kl_nats": 4.123843285603775e-06,
+        "prediction_kl_p99_nats": 4.622206702970199e-05,
+        "maximum_prediction_kl_nats": 0.003955611389927352,
+        "top1_changed_fraction": 0.0002300084336425669,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.23705077171325684,
+        "maximum_per_target_cross_entropy_increase": 0.1109311580657959
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -8.179042015307988e-05,
+          2.682603927912067e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "6f98acbd06c462d38cca0009605daa5986430f75993f62e281fc35ba0be9f1eb",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.6055010224164472,
+        "character_perplexity": 4.980354246870715,
+        "next_character_accuracy": 0.5312428122364486,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 1.0759404819319943e-06,
+        "mean_prediction_kl_nats": 7.821151145785465e-06,
+        "prediction_kl_p99_nats": 5.6903488780835576e-05,
+        "maximum_prediction_kl_nats": 0.003953598947138336,
+        "top1_changed_fraction": 0.0011500421682128345,
+        "accuracy_change": 0.00015333895576163936,
+        "maximum_absolute_logit_change": 0.24121397733688354,
+        "maximum_per_target_cross_entropy_increase": 0.11120235919952393
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -7.882844742669443e-05,
+          7.906194596836203e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "0e8078af3c09f2b3fc9f9326eeadf80476c38c986ac134e9d92181c35b724578",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7330032812638991,
+        "character_perplexity": 5.6576198426114725,
+        "next_character_accuracy": 0.5240358813156483,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 2.1604294667527183e-05,
+        "mean_prediction_kl_nats": 7.78168988858872e-06,
+        "prediction_kl_p99_nats": 0.00011058258695271181,
+        "maximum_prediction_kl_nats": 0.0022485554921807044,
+        "top1_changed_fraction": 0.0005366863451659894,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.24792087078094482,
+        "maximum_per_target_cross_entropy_increase": 0.08095335960388184
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -6.024743447126731e-05,
+          0.00011064608135001141
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "0e8078af3c09f2b3fc9f9326eeadf80476c38c986ac134e9d92181c35b724578",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7330043281755663,
+        "character_perplexity": 5.657625765642795,
+        "next_character_accuracy": 0.5240358813156483,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 2.2651229500529794e-05,
+        "mean_prediction_kl_nats": 7.79975451634245e-06,
+        "prediction_kl_p99_nats": 0.00010988026680244667,
+        "maximum_prediction_kl_nats": 0.002261641787947211,
+        "top1_changed_fraction": 0.0005366863451659894,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.24807631969451904,
+        "maximum_per_target_cross_entropy_increase": 0.08090543746948242
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -5.991744542410419e-05,
+          0.00011220568407468823
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "0e8078af3c09f2b3fc9f9326eeadf80476c38c986ac134e9d92181c35b724578",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.733011266983305,
+        "character_perplexity": 5.65766502295644,
+        "next_character_accuracy": 0.5241125507935291,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 2.959021848603195e-05,
+        "mean_prediction_kl_nats": 1.1626656487954728e-05,
+        "prediction_kl_p99_nats": 0.00013220916162419904,
+        "maximum_prediction_kl_nats": 0.002340190267592224,
+        "top1_changed_fraction": 0.0013033811239745456,
+        "accuracy_change": 0.0,
+        "maximum_absolute_logit_change": 0.2520638704299927,
+        "maximum_per_target_cross_entropy_increase": 0.0828244686126709
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -5.804055918160391e-05,
+          0.00012844987515457383
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "f773d277a5444631a7ca1865880469f92d01fd664f4da9363621026ccd307845",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7264698748348142,
+        "character_perplexity": 5.6207767991020114,
+        "next_character_accuracy": 0.5249559150502185,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -2.1575416673470984e-05,
+        "mean_prediction_kl_nats": 5.807643260194993e-06,
+        "prediction_kl_p99_nats": 0.00010141657576575024,
+        "maximum_prediction_kl_nats": 0.0007125883040050816,
+        "top1_changed_fraction": 0.0009967032124511231,
+        "accuracy_change": -0.00015333895576163936,
+        "maximum_absolute_logit_change": 0.25301599502563477,
+        "maximum_per_target_cross_entropy_increase": 0.05091524124145508
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -8.06561119497958e-05,
+          4.467055448057322e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "f773d277a5444631a7ca1865880469f92d01fd664f4da9363621026ccd307845",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.726467159977237,
+        "character_perplexity": 5.620761539514243,
+        "next_character_accuracy": 0.5249559150502185,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -2.42902119913508e-05,
+        "mean_prediction_kl_nats": 5.815575679108724e-06,
+        "prediction_kl_p99_nats": 0.00010166998443153778,
+        "maximum_prediction_kl_nats": 0.0007118815655093643,
+        "top1_changed_fraction": 0.0009967032124511231,
+        "accuracy_change": -0.00015333895576163936,
+        "maximum_absolute_logit_change": 0.2531658411026001,
+        "maximum_per_target_cross_entropy_increase": 0.0510706901550293
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -8.436666262374752e-05,
+          4.227199612387919e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "f773d277a5444631a7ca1865880469f92d01fd664f4da9363621026ccd307845",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7264412324560523,
+        "character_perplexity": 5.620615808989577,
+        "next_character_accuracy": 0.5250325845280993,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -5.021676728397291e-05,
+        "mean_prediction_kl_nats": 9.692142442536032e-06,
+        "prediction_kl_p99_nats": 0.000108525150499449,
+        "maximum_prediction_kl_nats": 0.0008209585404893964,
+        "top1_changed_fraction": 0.001456720079736257,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.25075554847717285,
+        "maximum_per_target_cross_entropy_increase": 0.050766944885253906
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -0.00013128774527874365,
+          3.87866733347212e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "b8b0017a1ced25157ff108b6d38a5aaf5dfe56e59ce071a16755aa916bd279f5",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.72803269792906,
+        "character_perplexity": 5.629567946606118,
+        "next_character_accuracy": 0.5291727363336656,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -3.121919297631779e-05,
+        "mean_prediction_kl_nats": 1.0537167107346687e-05,
+        "prediction_kl_p99_nats": 0.00010991141652174422,
+        "maximum_prediction_kl_nats": 0.005400081972263237,
+        "top1_changed_fraction": 0.0005366863451659894,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.3041081428527832,
+        "maximum_per_target_cross_entropy_increase": 0.12840533256530762
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -0.00011841685450632379,
+          5.2997370424164765e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "b8b0017a1ced25157ff108b6d38a5aaf5dfe56e59ce071a16755aa916bd279f5",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7280324823027406,
+        "character_perplexity": 5.629566732723234,
+        "next_character_accuracy": 0.5291727363336656,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -3.143481254055395e-05,
+        "mean_prediction_kl_nats": 1.0534875189048734e-05,
+        "prediction_kl_p99_nats": 0.00011052448372342929,
+        "maximum_prediction_kl_nats": 0.0053958865398814355,
+        "top1_changed_fraction": 0.0005366863451659894,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.30393123626708984,
+        "maximum_per_target_cross_entropy_increase": 0.12823724746704102
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -0.00011842676496203541,
+          5.1676833144090865e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "b8b0017a1ced25157ff108b6d38a5aaf5dfe56e59ce071a16755aa916bd279f5",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7280487235241493,
+        "character_perplexity": 5.629658164505454,
+        "next_character_accuracy": 0.5293260752894273,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -1.5193969786458584e-05,
+        "mean_prediction_kl_nats": 1.4494837743019004e-05,
+        "prediction_kl_p99_nats": 0.00012026770353101802,
+        "maximum_prediction_kl_nats": 0.005769573978476713,
+        "top1_changed_fraction": 0.002070075902783102,
+        "accuracy_change": 7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.308438777923584,
+        "maximum_per_target_cross_entropy_increase": 0.1331770420074463
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -0.0001269264060790776,
+          8.718167565233331e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "b1dc4a4b7a8ae2ed1ef9688aa0cccf047c766581b08fe1608fc5625cfc93d0d6",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.746792423275222,
+        "character_perplexity": 5.736173918029833,
+        "next_character_accuracy": 0.522579161235912,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 0.00013713155786803245,
+        "mean_prediction_kl_nats": 8.387160403224065e-06,
+        "prediction_kl_p99_nats": 0.00010513767379755445,
+        "maximum_prediction_kl_nats": 0.016954457411952714,
+        "top1_changed_fraction": 0.0013800506018554013,
+        "accuracy_change": -0.00023000843364262558,
+        "maximum_absolute_logit_change": 0.37196114659309387,
+        "maximum_per_target_cross_entropy_increase": 0.25717687606811523
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          4.1956194323943976e-05,
+          0.0002322068940903893
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "b1dc4a4b7a8ae2ed1ef9688aa0cccf047c766581b08fe1608fc5625cfc93d0d6",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7467906956675798,
+        "character_perplexity": 5.736164008180495,
+        "next_character_accuracy": 0.522579161235912,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 0.0001354037148087213,
+        "mean_prediction_kl_nats": 8.39024307721582e-06,
+        "prediction_kl_p99_nats": 0.00010461888524421549,
+        "maximum_prediction_kl_nats": 0.0169355323084063,
+        "top1_changed_fraction": 0.0013800506018554013,
+        "accuracy_change": -0.00023000843364262558,
+        "maximum_absolute_logit_change": 0.3721938729286194,
+        "maximum_per_target_cross_entropy_increase": 0.2576470375061035
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          4.106371111382881e-05,
+          0.00023184921531607292
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "b1dc4a4b7a8ae2ed1ef9688aa0cccf047c766581b08fe1608fc5625cfc93d0d6",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7467712194244922,
+        "character_perplexity": 5.736052290343807,
+        "next_character_accuracy": 0.5227325001916737,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 0.00011592502425189617,
+        "mean_prediction_kl_nats": 1.230479487328579e-05,
+        "prediction_kl_p99_nats": 0.00012420683382845062,
+        "maximum_prediction_kl_nats": 0.017946778591312353,
+        "top1_changed_fraction": 0.0019167369470213908,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.36850810050964355,
+        "maximum_per_target_cross_entropy_increase": 0.25458717346191406
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          1.0180332353287482e-05,
+          0.00022089795485964647
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "464242bc5b4367053b82ea7fa20f47536b2311fd0a3f4c4aaf6c0d4ed4a9e0c7",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7467790163747046,
+        "character_perplexity": 5.736097014232285,
+        "next_character_accuracy": 0.5232691865368397,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -3.2684143610367924e-06,
+        "mean_prediction_kl_nats": 8.262291321689492e-06,
+        "prediction_kl_p99_nats": 0.00011778528468316299,
+        "maximum_prediction_kl_nats": 0.0065499537993800126,
+        "top1_changed_fraction": 0.0015333895576171127,
+        "accuracy_change": -0.00023000843364251455,
+        "maximum_absolute_logit_change": 0.3585476875305176,
+        "maximum_per_target_cross_entropy_increase": 0.06969976425170898
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -6.586554962312211e-05,
+          5.9801644730695365e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "464242bc5b4367053b82ea7fa20f47536b2311fd0a3f4c4aaf6c0d4ed4a9e0c7",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7467771339496792,
+        "character_perplexity": 5.73608621646988,
+        "next_character_accuracy": 0.5232691865368397,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -5.150831462224922e-06,
+        "mean_prediction_kl_nats": 8.264931976770698e-06,
+        "prediction_kl_p99_nats": 0.00011714195461653951,
+        "maximum_prediction_kl_nats": 0.006543255282379136,
+        "top1_changed_fraction": 0.0015333895576171127,
+        "accuracy_change": -0.00023000843364251455,
+        "maximum_absolute_logit_change": 0.35859787464141846,
+        "maximum_per_target_cross_entropy_increase": 0.06992912292480469
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -6.79350738509818e-05,
+          5.794176369511996e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "464242bc5b4367053b82ea7fa20f47536b2311fd0a3f4c4aaf6c0d4ed4a9e0c7",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.746776289076794,
+        "character_perplexity": 5.736081370208216,
+        "next_character_accuracy": 0.5231925170589589,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": -5.995699638609195e-06,
+        "mean_prediction_kl_nats": 1.1917872167478483e-05,
+        "prediction_kl_p99_nats": 0.00013011856410837118,
+        "maximum_prediction_kl_nats": 0.0066352149169198555,
+        "top1_changed_fraction": 0.0022234148585448133,
+        "accuracy_change": -0.00030667791152338975,
+        "maximum_absolute_logit_change": 0.3574690818786621,
+        "maximum_per_target_cross_entropy_increase": 0.06202554702758789
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -9.433998286496988e-05,
+          9.024583100613763e-05
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.99",
+      "checkpoint_sha256": "d2b8acfabccdc0f727220d8529bbe5b60c75d87bdefe10184232ad1310d868aa",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7495112993082373,
+        "character_perplexity": 5.7517910847663964,
+        "next_character_accuracy": 0.5253392624396228,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 7.424971586491312e-05,
+        "mean_prediction_kl_nats": 1.2781461306450973e-05,
+        "prediction_kl_p99_nats": 0.00013476159745037163,
+        "maximum_prediction_kl_nats": 0.004709698039633851,
+        "top1_changed_fraction": 0.0013033811239745456,
+        "accuracy_change": -0.00023000843364251455,
+        "maximum_absolute_logit_change": 0.38813066482543945,
+        "maximum_per_target_cross_entropy_increase": 0.19906091690063477
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -3.0042624596327334e-05,
+          0.00018320990325721725
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.99",
+      "checkpoint_sha256": "d2b8acfabccdc0f727220d8529bbe5b60c75d87bdefe10184232ad1310d868aa",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7495114649184045,
+        "character_perplexity": 5.751792037321558,
+        "next_character_accuracy": 0.5253392624396228,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 7.441533834221121e-05,
+        "mean_prediction_kl_nats": 1.2761184812997986e-05,
+        "prediction_kl_p99_nats": 0.000135257071796772,
+        "maximum_prediction_kl_nats": 0.004700372572971191,
+        "top1_changed_fraction": 0.0013800506018554013,
+        "accuracy_change": -0.00023000843364251455,
+        "maximum_absolute_logit_change": 0.38828110694885254,
+        "maximum_per_target_cross_entropy_increase": 0.19883155822753906
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          -2.8572421869474518e-05,
+          0.00018264452205758513
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    },
+    {
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "int8",
+      "name": "int8-joint-0.99",
+      "checkpoint_sha256": "d2b8acfabccdc0f727220d8529bbe5b60c75d87bdefe10184232ad1310d868aa",
+      "test": {
+        "targets": 13043,
+        "cross_entropy_nats": 1.7496088171948707,
+        "character_perplexity": 5.752352014627242,
+        "next_character_accuracy": 0.5254926013953845,
+        "unknown_targets": 0
+      },
+      "test_delta": {
+        "perplexity_relative_change": 0.00017177959855028355,
+        "mean_prediction_kl_nats": 1.6229808150624952e-05,
+        "prediction_kl_p99_nats": 0.0001448249874305474,
+        "maximum_prediction_kl_nats": 0.004485428819249324,
+        "top1_changed_fraction": 0.0023767538143065247,
+        "accuracy_change": -7.666947788087519e-05,
+        "maximum_absolute_logit_change": 0.3875594139099121,
+        "maximum_per_target_cross_entropy_increase": 0.2045726776123047
+      },
+      "test_paired_block_interval": {
+        "perplexity_relative_change_95_percent_interval": [
+          4.521165080624516e-05,
+          0.00029340706023153957
+        ],
+        "block_characters": 256,
+        "observed_blocks": 52,
+        "repeats": 1000,
+        "seed": 42,
+        "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+      },
+      "test_all_budgets_passed": true
+    }
+  ]
+}
diff --git a/docs/quantized_structural_evidence_20261031/rate-distortion.png b/docs/quantized_structural_evidence_20261031/rate-distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..1e67b4f6c0466019621210cc6a5f52a802162695
GIT binary patch
literal 229529
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

literal 0
HcmV?d00001

diff --git a/docs/quantized_structural_evidence_20261031/rate-distortion.svg b/docs/quantized_structural_evidence_20261031/rate-distortion.svg
new file mode 100644
index 0000000..0db38e0
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/rate-distortion.svg
@@ -0,0 +1,2103 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="864pt" height="432pt" viewBox="0 0 864 432" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2026-10-31T11:40:12.391278</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 432 
+L 864 432 
+L 864 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 45.202109 220.720039 
+L 280.911872 220.720039 
+L 280.911872 103.249766 
+L 45.202109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 55.916189 220.720039 
+L 55.916189 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2">
+      <defs>
+       <path id="m07a3eaa03f" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="55.916189" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="55.916189" y="234.55793" transform="rotate(-0 55.916189 234.55793)">0.00</text>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 92.523401 220.720039 
+L 92.523401 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="92.523401" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="92.523401" y="234.55793" transform="rotate(-0 92.523401 234.55793)">0.25</text>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 129.130612 220.720039 
+L 129.130612 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="129.130612" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="129.130612" y="234.55793" transform="rotate(-0 129.130612 234.55793)">0.50</text>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 165.737823 220.720039 
+L 165.737823 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="165.737823" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="165.737823" y="234.55793" transform="rotate(-0 165.737823 234.55793)">0.75</text>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 202.345035 220.720039 
+L 202.345035 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="202.345035" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="202.345035" y="234.55793" transform="rotate(-0 202.345035 234.55793)">1.00</text>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 238.952246 220.720039 
+L 238.952246 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="238.952246" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="238.952246" y="234.55793" transform="rotate(-0 238.952246 234.55793)">1.25</text>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 275.559457 220.720039 
+L 275.559457 103.249766 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="275.559457" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="275.559457" y="234.55793" transform="rotate(-0 275.559457 234.55793)">1.50</text>
+     </g>
+    </g>
+    <g id="text_8">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="163.056991" y="247.558633" transform="rotate(-0 163.056991 247.558633)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_15">
+      <path d="M 45.202109 215.380481 
+L 280.911872 215.380481 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_16">
+      <defs>
+       <path id="me49566fb24" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="215.380481" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="218.799426" transform="rotate(-0 38.202109 218.799426)">1</text>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_17">
+      <path d="M 45.202109 186.064956 
+L 280.911872 186.064956 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_18">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="186.064956" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="189.483902" transform="rotate(-0 38.202109 189.483902)">2</text>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_19">
+      <path d="M 45.202109 156.749432 
+L 280.911872 156.749432 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_20">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="156.749432" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_11">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="160.168377" transform="rotate(-0 38.202109 160.168377)">3</text>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_21">
+      <path d="M 45.202109 127.433907 
+L 280.911872 127.433907 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_22">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="127.433907" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_12">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="130.852852" transform="rotate(-0 38.202109 130.852852)">4</text>
+     </g>
+    </g>
+    <g id="text_13">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="26.31375" y="161.984902" transform="rotate(-90 26.31375 161.984902)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_23">
+    <path d="M 55.916189 215.380481 
+L 155.390626 204.354613 
+L 178.818594 203.36297 
+L 185.540527 203.212081 
+L 196.044358 203.141197 
+L 246.90027 203.063758 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <defs>
+     <path id="mff235f3940" d="M 0 2 
+C 0.530406 2 1.03916 1.789267 1.414214 1.414214 
+C 1.789267 1.03916 2 0.530406 2 0 
+C 2 -0.530406 1.789267 -1.03916 1.414214 -1.414214 
+C 1.03916 -1.789267 0.530406 -2 0 -2 
+C -0.530406 -2 -1.03916 -1.789267 -1.414214 -1.414214 
+C -1.789267 -1.03916 -2 -0.530406 -2 0 
+C -2 0.530406 -1.789267 1.03916 -1.414214 1.414214 
+C -1.03916 1.789267 -0.530406 2 0 2 
+z
+" style="stroke: #599268"/>
+    </defs>
+    <g clip-path="url(#pba293368a2)">
+     <use xlink:href="#mff235f3940" x="55.916189" y="215.380481" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="155.390626" y="204.354613" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="178.818594" y="203.36297" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="185.540527" y="203.212081" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="196.044358" y="203.141197" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="246.90027" y="203.063758" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_24">
+    <path d="M 58.966744 187.528482 
+L 155.450277 168.620263 
+L 178.859809 166.846586 
+L 185.580615 166.580714 
+L 196.079502 166.448662 
+L 246.924382 166.311565 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <defs>
+     <path id="ma5f43dbdb6" d="M 0 2 
+C 0.530406 2 1.03916 1.789267 1.414214 1.414214 
+C 1.789267 1.03916 2 0.530406 2 0 
+C 2 -0.530406 1.789267 -1.03916 1.414214 -1.414214 
+C 1.03916 -1.789267 0.530406 -2 0 -2 
+C -0.530406 -2 -1.03916 -1.789267 -1.414214 -1.414214 
+C -1.789267 -1.03916 -2 -0.530406 -2 0 
+C -2 0.530406 -1.789267 1.03916 -1.414214 1.414214 
+C -1.03916 1.789267 -0.530406 2 0 2 
+z
+" style="stroke: #5587b6"/>
+    </defs>
+    <g clip-path="url(#pba293368a2)">
+     <use xlink:href="#ma5f43dbdb6" x="58.966744" y="187.528482" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="155.450277" y="168.620263" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="178.859809" y="166.846586" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="185.580615" y="166.580714" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="196.079502" y="166.448662" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="246.924382" y="166.311565" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_25">
+    <path d="M 151.392062 138.798091 
+L 193.748642 112.268136 
+L 211.556914 109.457315 
+L 217.209468 109.028427 
+L 225.263204 108.814444 
+L 270.197792 108.589324 
+" clip-path="url(#pba293368a2)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <defs>
+     <path id="me5e70b3745" d="M 0 2 
+C 0.530406 2 1.03916 1.789267 1.414214 1.414214 
+C 1.789267 1.03916 2 0.530406 2 0 
+C 2 -0.530406 1.789267 -1.03916 1.414214 -1.414214 
+C 1.03916 -1.789267 0.530406 -2 0 -2 
+C -0.530406 -2 -1.03916 -1.789267 -1.414214 -1.414214 
+C -1.789267 -1.03916 -2 -0.530406 -2 0 
+C -2 0.530406 -1.789267 1.03916 -1.414214 1.414214 
+C -1.03916 1.789267 -0.530406 2 0 2 
+z
+" style="stroke: #ed9c42"/>
+    </defs>
+    <g clip-path="url(#pba293368a2)">
+     <use xlink:href="#me5e70b3745" x="151.392062" y="138.798091" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="193.748642" y="112.268136" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="211.556914" y="109.457315" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="217.209468" y="109.028427" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="225.263204" y="108.814444" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="270.197792" y="108.589324" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 45.202109 220.720039 
+L 45.202109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 280.911872 220.720039 
+L 280.911872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 45.202109 220.720039 
+L 280.911872 220.720039 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 45.202109 103.249766 
+L 280.911872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_14">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="157.390626" y="200.354613" transform="rotate(-0 157.390626 200.354613)">0.99</text>
+   </g>
+   <g id="text_15">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="248.90027" y="199.063758" transform="rotate(-0 248.90027 199.063758)">0.9</text>
+   </g>
+   <g id="text_16">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="157.450277" y="164.620263" transform="rotate(-0 157.450277 164.620263)">0.99</text>
+   </g>
+   <g id="text_17">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="248.924382" y="162.311565" transform="rotate(-0 248.924382 162.311565)">0.9</text>
+   </g>
+   <g id="text_18">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="195.748642" y="108.268136" transform="rotate(-0 195.748642 108.268136)">0.99</text>
+   </g>
+   <g id="text_19">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="272.197792" y="104.589324" transform="rotate(-0 272.197792 104.589324)">0.9</text>
+   </g>
+   <g id="text_20">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="163.056991" y="97.249766" transform="rotate(-0 163.056991 97.249766)">SGNS, order 4</text>
+   </g>
+   <g id="legend_1">
+    <g id="patch_7">
+     <path d="M 50.102109 140.351406 
+L 89.656484 140.351406 
+Q 91.056484 140.351406 91.056484 138.951406 
+L 91.056484 108.149766 
+Q 91.056484 106.749766 89.656484 106.749766 
+L 50.102109 106.749766 
+Q 48.702109 106.749766 48.702109 108.149766 
+L 48.702109 138.951406 
+Q 48.702109 140.351406 50.102109 140.351406 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_26">
+     <path d="M 51.502109 112.418672 
+L 58.502109 112.418672 
+L 65.502109 112.418672 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="58.502109" y="112.418672" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_21">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="114.868672" transform="rotate(-0 71.102109 114.868672)">FP32</text>
+    </g>
+    <g id="line2d_27">
+     <path d="M 51.502109 122.919219 
+L 58.502109 122.919219 
+L 65.502109 122.919219 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="58.502109" y="122.919219" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_22">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="125.369219" transform="rotate(-0 71.102109 125.369219)">FP16</text>
+    </g>
+    <g id="line2d_28">
+     <path d="M 51.502109 133.419766 
+L 58.502109 133.419766 
+L 65.502109 133.419766 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="58.502109" y="133.419766" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_23">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="135.869766" transform="rotate(-0 71.102109 135.869766)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="axes_2">
+   <g id="patch_8">
+    <path d="M 329.962109 220.720039 
+L 565.671872 220.720039 
+L 565.671872 103.249766 
+L 329.962109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_3">
+    <g id="xtick_8">
+     <g id="line2d_29">
+      <path d="M 340.676189 220.720039 
+L 340.676189 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_30">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="340.676189" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_24">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="340.676189" y="234.55793" transform="rotate(-0 340.676189 234.55793)">0.00</text>
+     </g>
+    </g>
+    <g id="xtick_9">
+     <g id="line2d_31">
+      <path d="M 375.706485 220.720039 
+L 375.706485 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_32">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="375.706485" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_25">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="375.706485" y="234.55793" transform="rotate(-0 375.706485 234.55793)">0.25</text>
+     </g>
+    </g>
+    <g id="xtick_10">
+     <g id="line2d_33">
+      <path d="M 410.736781 220.720039 
+L 410.736781 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_34">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="410.736781" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_26">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="410.736781" y="234.55793" transform="rotate(-0 410.736781 234.55793)">0.50</text>
+     </g>
+    </g>
+    <g id="xtick_11">
+     <g id="line2d_35">
+      <path d="M 445.767076 220.720039 
+L 445.767076 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_36">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="445.767076" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_27">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="445.767076" y="234.55793" transform="rotate(-0 445.767076 234.55793)">0.75</text>
+     </g>
+    </g>
+    <g id="xtick_12">
+     <g id="line2d_37">
+      <path d="M 480.797372 220.720039 
+L 480.797372 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_38">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="480.797372" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_28">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="480.797372" y="234.55793" transform="rotate(-0 480.797372 234.55793)">1.00</text>
+     </g>
+    </g>
+    <g id="xtick_13">
+     <g id="line2d_39">
+      <path d="M 515.827667 220.720039 
+L 515.827667 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_40">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="515.827667" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_29">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="515.827667" y="234.55793" transform="rotate(-0 515.827667 234.55793)">1.25</text>
+     </g>
+    </g>
+    <g id="xtick_14">
+     <g id="line2d_41">
+      <path d="M 550.857963 220.720039 
+L 550.857963 103.249766 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_42">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="550.857963" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_30">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="550.857963" y="234.55793" transform="rotate(-0 550.857963 234.55793)">1.50</text>
+     </g>
+    </g>
+    <g id="text_31">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="447.816991" y="247.558633" transform="rotate(-0 447.816991 247.558633)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_4">
+    <g id="ytick_5">
+     <g id="line2d_43">
+      <path d="M 329.962109 215.380481 
+L 565.671872 215.380481 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_44">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="215.380481" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_32">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="218.799426" transform="rotate(-0 322.962109 218.799426)">1</text>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_45">
+      <path d="M 329.962109 192.150639 
+L 565.671872 192.150639 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_46">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="192.150639" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_33">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="195.569584" transform="rotate(-0 322.962109 195.569584)">2</text>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_47">
+      <path d="M 329.962109 168.920797 
+L 565.671872 168.920797 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_48">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="168.920797" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_34">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="172.339742" transform="rotate(-0 322.962109 172.339742)">3</text>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_49">
+      <path d="M 329.962109 145.690955 
+L 565.671872 145.690955 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_50">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="145.690955" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_35">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="149.1099" transform="rotate(-0 322.962109 149.1099)">4</text>
+     </g>
+    </g>
+    <g id="ytick_9">
+     <g id="line2d_51">
+      <path d="M 329.962109 122.461112 
+L 565.671872 122.461112 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_52">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="122.461112" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_36">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="125.880058" transform="rotate(-0 322.962109 125.880058)">5</text>
+     </g>
+    </g>
+    <g id="text_37">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="311.07375" y="161.984902" transform="rotate(-90 311.07375 161.984902)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_53">
+    <path d="M 340.676189 215.380481 
+L 473.955158 200.351476 
+L 486.502737 198.166015 
+L 487.24264 197.837393 
+L 503.104197 197.765731 
+L 532.930885 197.718171 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p511bbc1eb0)">
+     <use xlink:href="#mff235f3940" x="340.676189" y="215.380481" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="473.955158" y="200.351476" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="486.502737" y="198.166015" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="487.24264" y="197.837393" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="503.104197" y="197.765731" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="532.930885" y="197.718171" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_54">
+    <path d="M 343.555978 193.456884 
+L 473.983338 167.32552 
+L 486.517895 163.622935 
+L 487.261109 163.059219 
+L 503.121606 162.939614 
+L 532.631412 162.853337 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p511bbc1eb0)">
+     <use xlink:href="#ma5f43dbdb6" x="343.555978" y="193.456884" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="473.983338" y="167.32552" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="486.517895" y="163.622935" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="487.261109" y="163.059219" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="503.121606" y="162.939614" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="532.631412" y="162.853337" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_55">
+    <path d="M 435.38172 155.435517 
+L 504.236999 115.018783 
+L 514.766327 109.698313 
+L 515.351483 108.861745 
+L 528.754763 108.703496 
+L 554.957792 108.589324 
+" clip-path="url(#p511bbc1eb0)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p511bbc1eb0)">
+     <use xlink:href="#me5e70b3745" x="435.38172" y="155.435517" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="504.236999" y="115.018783" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="514.766327" y="109.698313" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="515.351483" y="108.861745" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="528.754763" y="108.703496" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="554.957792" y="108.589324" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_9">
+    <path d="M 329.962109 220.720039 
+L 329.962109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 565.671872 220.720039 
+L 565.671872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 329.962109 220.720039 
+L 565.671872 220.720039 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 329.962109 103.249766 
+L 565.671872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_38">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="475.955158" y="196.351476" transform="rotate(-0 475.955158 196.351476)">0.99</text>
+   </g>
+   <g id="text_39">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="534.930885" y="193.718171" transform="rotate(-0 534.930885 193.718171)">0.9</text>
+   </g>
+   <g id="text_40">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="475.983338" y="163.32552" transform="rotate(-0 475.983338 163.32552)">0.99</text>
+   </g>
+   <g id="text_41">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="534.631412" y="158.853337" transform="rotate(-0 534.631412 158.853337)">0.9</text>
+   </g>
+   <g id="text_42">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="506.236999" y="111.018783" transform="rotate(-0 506.236999 111.018783)">0.99</text>
+   </g>
+   <g id="text_43">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="556.957792" y="104.589324" transform="rotate(-0 556.957792 104.589324)">0.9</text>
+   </g>
+   <g id="text_44">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="447.816991" y="97.249766" transform="rotate(-0 447.816991 97.249766)">SGNS, order 8</text>
+   </g>
+   <g id="legend_2">
+    <g id="patch_13">
+     <path d="M 334.862109 140.351406 
+L 374.416484 140.351406 
+Q 375.816484 140.351406 375.816484 138.951406 
+L 375.816484 108.149766 
+Q 375.816484 106.749766 374.416484 106.749766 
+L 334.862109 106.749766 
+Q 333.462109 106.749766 333.462109 108.149766 
+L 333.462109 138.951406 
+Q 333.462109 140.351406 334.862109 140.351406 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_56">
+     <path d="M 336.262109 112.418672 
+L 343.262109 112.418672 
+L 350.262109 112.418672 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="343.262109" y="112.418672" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_45">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="114.868672" transform="rotate(-0 355.862109 114.868672)">FP32</text>
+    </g>
+    <g id="line2d_57">
+     <path d="M 336.262109 122.919219 
+L 343.262109 122.919219 
+L 350.262109 122.919219 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="343.262109" y="122.919219" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_46">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="125.369219" transform="rotate(-0 355.862109 125.369219)">FP16</text>
+    </g>
+    <g id="line2d_58">
+     <path d="M 336.262109 133.419766 
+L 343.262109 133.419766 
+L 350.262109 133.419766 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="343.262109" y="133.419766" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_47">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="135.869766" transform="rotate(-0 355.862109 135.869766)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="axes_3">
+   <g id="patch_14">
+    <path d="M 614.722109 220.720039 
+L 850.431872 220.720039 
+L 850.431872 103.249766 
+L 614.722109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_5">
+    <g id="xtick_15">
+     <g id="line2d_59">
+      <path d="M 625.436189 220.720039 
+L 625.436189 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_60">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="625.436189" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_48">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="625.436189" y="234.55793" transform="rotate(-0 625.436189 234.55793)">0.00</text>
+     </g>
+    </g>
+    <g id="xtick_16">
+     <g id="line2d_61">
+      <path d="M 661.538139 220.720039 
+L 661.538139 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_62">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="661.538139" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_49">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="661.538139" y="234.55793" transform="rotate(-0 661.538139 234.55793)">0.25</text>
+     </g>
+    </g>
+    <g id="xtick_17">
+     <g id="line2d_63">
+      <path d="M 697.640089 220.720039 
+L 697.640089 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_64">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="697.640089" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_50">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="697.640089" y="234.55793" transform="rotate(-0 697.640089 234.55793)">0.50</text>
+     </g>
+    </g>
+    <g id="xtick_18">
+     <g id="line2d_65">
+      <path d="M 733.742039 220.720039 
+L 733.742039 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_66">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="733.742039" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_51">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="733.742039" y="234.55793" transform="rotate(-0 733.742039 234.55793)">0.75</text>
+     </g>
+    </g>
+    <g id="xtick_19">
+     <g id="line2d_67">
+      <path d="M 769.843988 220.720039 
+L 769.843988 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_68">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="769.843988" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_52">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="769.843988" y="234.55793" transform="rotate(-0 769.843988 234.55793)">1.00</text>
+     </g>
+    </g>
+    <g id="xtick_20">
+     <g id="line2d_69">
+      <path d="M 805.945938 220.720039 
+L 805.945938 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_70">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="805.945938" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_53">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="805.945938" y="234.55793" transform="rotate(-0 805.945938 234.55793)">1.25</text>
+     </g>
+    </g>
+    <g id="xtick_21">
+     <g id="line2d_71">
+      <path d="M 842.047888 220.720039 
+L 842.047888 103.249766 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_72">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="842.047888" y="220.720039" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_54">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="842.047888" y="234.55793" transform="rotate(-0 842.047888 234.55793)">1.50</text>
+     </g>
+    </g>
+    <g id="text_55">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="732.576991" y="247.558633" transform="rotate(-0 732.576991 247.558633)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_6">
+    <g id="ytick_10">
+     <g id="line2d_73">
+      <path d="M 614.722109 215.380481 
+L 850.431872 215.380481 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_74">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="215.380481" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_56">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="218.799426" transform="rotate(-0 607.722109 218.799426)">1</text>
+     </g>
+    </g>
+    <g id="ytick_11">
+     <g id="line2d_75">
+      <path d="M 614.722109 192.006578 
+L 850.431872 192.006578 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_76">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="192.006578" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_57">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="195.425523" transform="rotate(-0 607.722109 195.425523)">2</text>
+     </g>
+    </g>
+    <g id="ytick_12">
+     <g id="line2d_77">
+      <path d="M 614.722109 168.632674 
+L 850.431872 168.632674 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_78">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="168.632674" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_58">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="172.051619" transform="rotate(-0 607.722109 172.051619)">3</text>
+     </g>
+    </g>
+    <g id="ytick_13">
+     <g id="line2d_79">
+      <path d="M 614.722109 145.25877 
+L 850.431872 145.25877 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_80">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="145.25877" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_59">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="148.677716" transform="rotate(-0 607.722109 148.677716)">4</text>
+     </g>
+    </g>
+    <g id="ytick_14">
+     <g id="line2d_81">
+      <path d="M 614.722109 121.884867 
+L 850.431872 121.884867 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_82">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="121.884867" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_60">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="125.303812" transform="rotate(-0 607.722109 125.303812)">5</text>
+     </g>
+    </g>
+    <g id="text_61">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="595.83375" y="161.984902" transform="rotate(-90 595.83375 161.984902)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_83">
+    <path d="M 625.436189 215.380481 
+L 763.200703 200.236253 
+L 775.752067 198.28047 
+L 783.254428 197.968769 
+L 793.249345 197.862168 
+L 819.2644 197.827194 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pa390beb15e)">
+     <use xlink:href="#mff235f3940" x="625.436189" y="215.380481" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="763.200703" y="200.236253" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="775.752067" y="198.28047" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="783.254428" y="197.968769" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="793.249345" y="197.862168" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="819.2644" y="197.827194" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_84">
+    <path d="M 628.43166 193.342372 
+L 763.255501 166.934964 
+L 775.799465 163.615534 
+L 783.300955 163.088309 
+L 793.29208 162.906087 
+L 819.303141 162.838635 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pa390beb15e)">
+     <use xlink:href="#ma5f43dbdb6" x="628.43166" y="193.342372" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="763.255501" y="166.934964" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="775.799465" y="163.615534" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="783.300955" y="163.088309" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="793.29208" y="162.906087" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="819.303141" y="162.838635" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_85">
+    <path d="M 717.998497 155.171617 
+L 791.28523 114.377812 
+L 802.011242 109.683731 
+L 807.525369 108.923462 
+L 816.541829 108.672721 
+L 839.717792 108.589324 
+" clip-path="url(#pa390beb15e)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pa390beb15e)">
+     <use xlink:href="#me5e70b3745" x="717.998497" y="155.171617" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="791.28523" y="114.377812" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="802.011242" y="109.683731" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="807.525369" y="108.923462" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="816.541829" y="108.672721" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="839.717792" y="108.589324" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_15">
+    <path d="M 614.722109 220.720039 
+L 614.722109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 850.431872 220.720039 
+L 850.431872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 614.722109 220.720039 
+L 850.431872 220.720039 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 614.722109 103.249766 
+L 850.431872 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_62">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="765.200703" y="196.236253" transform="rotate(-0 765.200703 196.236253)">0.99</text>
+   </g>
+   <g id="text_63">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="821.2644" y="193.827194" transform="rotate(-0 821.2644 193.827194)">0.9</text>
+   </g>
+   <g id="text_64">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="765.255501" y="162.934964" transform="rotate(-0 765.255501 162.934964)">0.99</text>
+   </g>
+   <g id="text_65">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="821.303141" y="158.838635" transform="rotate(-0 821.303141 158.838635)">0.9</text>
+   </g>
+   <g id="text_66">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="793.28523" y="110.377812" transform="rotate(-0 793.28523 110.377812)">0.99</text>
+   </g>
+   <g id="text_67">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="841.717792" y="104.589324" transform="rotate(-0 841.717792 104.589324)">0.9</text>
+   </g>
+   <g id="text_68">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="732.576991" y="97.249766" transform="rotate(-0 732.576991 97.249766)">SGNS, order 12</text>
+   </g>
+   <g id="legend_3">
+    <g id="patch_19">
+     <path d="M 619.622109 140.351406 
+L 659.176484 140.351406 
+Q 660.576484 140.351406 660.576484 138.951406 
+L 660.576484 108.149766 
+Q 660.576484 106.749766 659.176484 106.749766 
+L 619.622109 106.749766 
+Q 618.222109 106.749766 618.222109 108.149766 
+L 618.222109 138.951406 
+Q 618.222109 140.351406 619.622109 140.351406 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_86">
+     <path d="M 621.022109 112.418672 
+L 628.022109 112.418672 
+L 635.022109 112.418672 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="628.022109" y="112.418672" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_69">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="114.868672" transform="rotate(-0 640.622109 114.868672)">FP32</text>
+    </g>
+    <g id="line2d_87">
+     <path d="M 621.022109 122.919219 
+L 628.022109 122.919219 
+L 635.022109 122.919219 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="628.022109" y="122.919219" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_70">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="125.369219" transform="rotate(-0 640.622109 125.369219)">FP16</text>
+    </g>
+    <g id="line2d_88">
+     <path d="M 621.022109 133.419766 
+L 628.022109 133.419766 
+L 635.022109 133.419766 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="628.022109" y="133.419766" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_71">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="135.869766" transform="rotate(-0 640.622109 135.869766)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="axes_4">
+   <g id="patch_20">
+    <path d="M 45.202109 392.197891 
+L 280.911872 392.197891 
+L 280.911872 274.727617 
+L 45.202109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_7">
+    <g id="xtick_22">
+     <g id="line2d_89">
+      <path d="M 55.916189 392.197891 
+L 55.916189 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_90">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="55.916189" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_72">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="55.916189" y="406.035781" transform="rotate(-0 55.916189 406.035781)">0.0</text>
+     </g>
+    </g>
+    <g id="xtick_23">
+     <g id="line2d_91">
+      <path d="M 87.349861 392.197891 
+L 87.349861 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_92">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="87.349861" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_73">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="87.349861" y="406.035781" transform="rotate(-0 87.349861 406.035781)">0.2</text>
+     </g>
+    </g>
+    <g id="xtick_24">
+     <g id="line2d_93">
+      <path d="M 118.783532 392.197891 
+L 118.783532 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_94">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="118.783532" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_74">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="118.783532" y="406.035781" transform="rotate(-0 118.783532 406.035781)">0.4</text>
+     </g>
+    </g>
+    <g id="xtick_25">
+     <g id="line2d_95">
+      <path d="M 150.217204 392.197891 
+L 150.217204 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_96">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="150.217204" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_75">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="150.217204" y="406.035781" transform="rotate(-0 150.217204 406.035781)">0.6</text>
+     </g>
+    </g>
+    <g id="xtick_26">
+     <g id="line2d_97">
+      <path d="M 181.650875 392.197891 
+L 181.650875 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_98">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="181.650875" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_76">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="181.650875" y="406.035781" transform="rotate(-0 181.650875 406.035781)">0.8</text>
+     </g>
+    </g>
+    <g id="xtick_27">
+     <g id="line2d_99">
+      <path d="M 213.084547 392.197891 
+L 213.084547 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_100">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="213.084547" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_77">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="213.084547" y="406.035781" transform="rotate(-0 213.084547 406.035781)">1.0</text>
+     </g>
+    </g>
+    <g id="xtick_28">
+     <g id="line2d_101">
+      <path d="M 244.518218 392.197891 
+L 244.518218 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_102">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="244.518218" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_78">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="244.518218" y="406.035781" transform="rotate(-0 244.518218 406.035781)">1.2</text>
+     </g>
+    </g>
+    <g id="xtick_29">
+     <g id="line2d_103">
+      <path d="M 275.951889 392.197891 
+L 275.951889 274.727617 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_104">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="275.951889" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_79">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="275.951889" y="406.035781" transform="rotate(-0 275.951889 406.035781)">1.4</text>
+     </g>
+    </g>
+    <g id="text_80">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="163.056991" y="419.036484" transform="rotate(-0 163.056991 419.036484)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_8">
+    <g id="ytick_15">
+     <g id="line2d_105">
+      <path d="M 45.202109 386.858333 
+L 280.911872 386.858333 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_106">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="386.858333" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_81">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="390.277278" transform="rotate(-0 38.202109 390.277278)">1.0</text>
+     </g>
+    </g>
+    <g id="ytick_16">
+     <g id="line2d_107">
+      <path d="M 45.202109 363.618265 
+L 280.911872 363.618265 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_108">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="363.618265" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_82">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="367.03721" transform="rotate(-0 38.202109 367.03721)">1.5</text>
+     </g>
+    </g>
+    <g id="ytick_17">
+     <g id="line2d_109">
+      <path d="M 45.202109 340.378196 
+L 280.911872 340.378196 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_110">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="340.378196" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_83">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="343.797142" transform="rotate(-0 38.202109 343.797142)">2.0</text>
+     </g>
+    </g>
+    <g id="ytick_18">
+     <g id="line2d_111">
+      <path d="M 45.202109 317.138128 
+L 280.911872 317.138128 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_112">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="317.138128" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_84">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="320.557074" transform="rotate(-0 38.202109 320.557074)">2.5</text>
+     </g>
+    </g>
+    <g id="ytick_19">
+     <g id="line2d_113">
+      <path d="M 45.202109 293.89806 
+L 280.911872 293.89806 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_114">
+      <g>
+       <use xlink:href="#me49566fb24" x="45.202109" y="293.89806" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_85">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="297.317005" transform="rotate(-0 38.202109 297.317005)">3.0</text>
+     </g>
+    </g>
+    <g id="text_86">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="17.727188" y="333.462754" transform="rotate(-90 17.727188 333.462754)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_115">
+    <path d="M 55.916189 386.858333 
+L 141.011498 382.399361 
+L 143.331649 382.392756 
+L 154.313439 382.386318 
+L 189.939284 382.372964 
+L 250.078348 382.356549 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p4c4f436987)">
+     <use xlink:href="#mff235f3940" x="55.916189" y="386.858333" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="141.011498" y="382.399361" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="143.331649" y="382.392756" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="154.313439" y="382.386318" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="189.939284" y="382.372964" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="250.078348" y="382.356549" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_116">
+    <path d="M 59.183262 344.907767 
+L 140.866937 339.249265 
+L 143.199756 339.240141 
+L 154.234699 339.229652 
+L 189.868971 339.207144 
+L 249.997462 339.175472 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p4c4f436987)">
+     <use xlink:href="#ma5f43dbdb6" x="59.183262" y="344.907767" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="140.866937" y="339.249265" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="143.199756" y="339.240141" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="154.234699" y="339.229652" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="189.868971" y="339.207144" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="249.997462" y="339.175472" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_117">
+    <path d="M 142.712351 280.067175 
+L 177.405207 286.747356 
+L 179.197289 286.728169 
+L 187.766589 286.7134 
+L 216.368879 286.685356 
+L 270.197792 286.646747 
+" clip-path="url(#p4c4f436987)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p4c4f436987)">
+     <use xlink:href="#me5e70b3745" x="142.712351" y="280.067175" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="177.405207" y="286.747356" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="179.197289" y="286.728169" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="187.766589" y="286.7134" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="216.368879" y="286.685356" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="270.197792" y="286.646747" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_21">
+    <path d="M 45.202109 392.197891 
+L 45.202109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_22">
+    <path d="M 280.911872 392.197891 
+L 280.911872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_23">
+    <path d="M 45.202109 392.197891 
+L 280.911872 392.197891 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_24">
+    <path d="M 45.202109 274.727617 
+L 280.911872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_87">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="143.011498" y="378.399361" transform="rotate(-0 143.011498 378.399361)">0.99</text>
+   </g>
+   <g id="text_88">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="252.078348" y="378.356549" transform="rotate(-0 252.078348 378.356549)">0.9</text>
+   </g>
+   <g id="text_89">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="142.866937" y="335.249265" transform="rotate(-0 142.866937 335.249265)">0.99</text>
+   </g>
+   <g id="text_90">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="251.997462" y="335.175472" transform="rotate(-0 251.997462 335.175472)">0.9</text>
+   </g>
+   <g id="text_91">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="179.405207" y="282.747356" transform="rotate(-0 179.405207 282.747356)">0.99</text>
+   </g>
+   <g id="text_92">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="272.197792" y="282.646747" transform="rotate(-0 272.197792 282.646747)">0.9</text>
+   </g>
+   <g id="text_93">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="163.056991" y="268.727617" transform="rotate(-0 163.056991 268.727617)">GRU, order 4</text>
+   </g>
+   <g id="legend_4">
+    <g id="patch_25">
+     <path d="M 50.102109 311.829258 
+L 89.656484 311.829258 
+Q 91.056484 311.829258 91.056484 310.429258 
+L 91.056484 279.627617 
+Q 91.056484 278.227617 89.656484 278.227617 
+L 50.102109 278.227617 
+Q 48.702109 278.227617 48.702109 279.627617 
+L 48.702109 310.429258 
+Q 48.702109 311.829258 50.102109 311.829258 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_118">
+     <path d="M 51.502109 283.896523 
+L 58.502109 283.896523 
+L 65.502109 283.896523 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="58.502109" y="283.896523" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_94">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="286.346523" transform="rotate(-0 71.102109 286.346523)">FP32</text>
+    </g>
+    <g id="line2d_119">
+     <path d="M 51.502109 294.39707 
+L 58.502109 294.39707 
+L 65.502109 294.39707 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="58.502109" y="294.39707" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_95">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="296.84707" transform="rotate(-0 71.102109 296.84707)">FP16</text>
+    </g>
+    <g id="line2d_120">
+     <path d="M 51.502109 304.897617 
+L 58.502109 304.897617 
+L 65.502109 304.897617 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="58.502109" y="304.897617" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_96">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="71.102109" y="307.347617" transform="rotate(-0 71.102109 307.347617)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="axes_5">
+   <g id="patch_26">
+    <path d="M 329.962109 392.197891 
+L 565.671872 392.197891 
+L 565.671872 274.727617 
+L 329.962109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_9">
+    <g id="xtick_30">
+     <g id="line2d_121">
+      <path d="M 340.676189 392.197891 
+L 340.676189 274.727617 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_122">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="340.676189" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_97">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="340.676189" y="406.035781" transform="rotate(-0 340.676189 406.035781)">0.0</text>
+     </g>
+    </g>
+    <g id="xtick_31">
+     <g id="line2d_123">
+      <path d="M 391.993173 392.197891 
+L 391.993173 274.727617 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_124">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="391.993173" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_98">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="391.993173" y="406.035781" transform="rotate(-0 391.993173 406.035781)">0.5</text>
+     </g>
+    </g>
+    <g id="xtick_32">
+     <g id="line2d_125">
+      <path d="M 443.310156 392.197891 
+L 443.310156 274.727617 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_126">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="443.310156" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_99">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="443.310156" y="406.035781" transform="rotate(-0 443.310156 406.035781)">1.0</text>
+     </g>
+    </g>
+    <g id="xtick_33">
+     <g id="line2d_127">
+      <path d="M 494.627139 392.197891 
+L 494.627139 274.727617 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_128">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="494.627139" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_100">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="494.627139" y="406.035781" transform="rotate(-0 494.627139 406.035781)">1.5</text>
+     </g>
+    </g>
+    <g id="xtick_34">
+     <g id="line2d_129">
+      <path d="M 545.944122 392.197891 
+L 545.944122 274.727617 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_130">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="545.944122" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_101">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="545.944122" y="406.035781" transform="rotate(-0 545.944122 406.035781)">2.0</text>
+     </g>
+    </g>
+    <g id="text_102">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="447.816991" y="419.036484" transform="rotate(-0 447.816991 419.036484)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_10">
+    <g id="ytick_20">
+     <g id="line2d_131">
+      <path d="M 329.962109 386.858333 
+L 565.671872 386.858333 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_132">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="386.858333" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_103">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="390.277278" transform="rotate(-0 322.962109 390.277278)">1.0</text>
+     </g>
+    </g>
+    <g id="ytick_21">
+     <g id="line2d_133">
+      <path d="M 329.962109 366.587685 
+L 565.671872 366.587685 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_134">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="366.587685" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_104">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="370.00663" transform="rotate(-0 322.962109 370.00663)">1.5</text>
+     </g>
+    </g>
+    <g id="ytick_22">
+     <g id="line2d_135">
+      <path d="M 329.962109 346.317038 
+L 565.671872 346.317038 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_136">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="346.317038" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_105">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="349.735983" transform="rotate(-0 322.962109 349.735983)">2.0</text>
+     </g>
+    </g>
+    <g id="ytick_23">
+     <g id="line2d_137">
+      <path d="M 329.962109 326.04639 
+L 565.671872 326.04639 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_138">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="326.04639" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_106">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="329.465335" transform="rotate(-0 322.962109 329.465335)">2.5</text>
+     </g>
+    </g>
+    <g id="ytick_24">
+     <g id="line2d_139">
+      <path d="M 329.962109 305.775742 
+L 565.671872 305.775742 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_140">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="305.775742" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_107">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="309.194688" transform="rotate(-0 322.962109 309.194688)">3.0</text>
+     </g>
+    </g>
+    <g id="ytick_25">
+     <g id="line2d_141">
+      <path d="M 329.962109 285.505095 
+L 565.671872 285.505095 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_142">
+      <g>
+       <use xlink:href="#me49566fb24" x="329.962109" y="285.505095" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_108">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="288.92404" transform="rotate(-0 322.962109 288.92404)">3.5</text>
+     </g>
+    </g>
+    <g id="text_109">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="302.487188" y="333.462754" transform="rotate(-90 302.487188 333.462754)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_143">
+    <path d="M 340.676189 386.858333 
+L 457.09025 372.813344 
+L 471.302801 372.781039 
+L 480.129255 372.763513 
+L 522.212954 372.74266 
+L 554.957792 372.694948 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pab651db98d)">
+     <use xlink:href="#mff235f3940" x="340.676189" y="386.858333" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="457.09025" y="372.813344" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="471.302801" y="372.781039" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="480.129255" y="372.763513" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="522.212954" y="372.74266" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="554.957792" y="372.694948" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_144">
+    <path d="M 342.804959 350.888723 
+L 457.108147 329.339225 
+L 471.036636 329.292016 
+L 479.889522 329.262337 
+L 522.022655 329.228703 
+L 554.814931 329.153167 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pab651db98d)">
+     <use xlink:href="#ma5f43dbdb6" x="342.804959" y="350.888723" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="457.108147" y="329.339225" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="471.036636" y="329.292016" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="479.889522" y="329.262337" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="522.022655" y="329.228703" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="554.814931" y="329.153167" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_145">
+    <path d="M 395.741634 296.414079 
+L 469.470529 280.303101 
+L 482.400843 280.238578 
+L 490.636031 280.203645 
+L 519.583845 280.162074 
+L 550.608499 280.067175 
+" clip-path="url(#pab651db98d)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#pab651db98d)">
+     <use xlink:href="#me5e70b3745" x="395.741634" y="296.414079" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="469.470529" y="280.303101" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="482.400843" y="280.238578" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="490.636031" y="280.203645" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="519.583845" y="280.162074" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="550.608499" y="280.067175" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_27">
+    <path d="M 329.962109 392.197891 
+L 329.962109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_28">
+    <path d="M 565.671872 392.197891 
+L 565.671872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_29">
+    <path d="M 329.962109 392.197891 
+L 565.671872 392.197891 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_30">
+    <path d="M 329.962109 274.727617 
+L 565.671872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_110">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="459.09025" y="368.813344" transform="rotate(-0 459.09025 368.813344)">0.99</text>
+   </g>
+   <g id="text_111">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="556.957792" y="368.694948" transform="rotate(-0 556.957792 368.694948)">0.9</text>
+   </g>
+   <g id="text_112">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="459.108147" y="325.339225" transform="rotate(-0 459.108147 325.339225)">0.99</text>
+   </g>
+   <g id="text_113">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="556.814931" y="325.153167" transform="rotate(-0 556.814931 325.153167)">0.9</text>
+   </g>
+   <g id="text_114">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="471.470529" y="276.303101" transform="rotate(-0 471.470529 276.303101)">0.99</text>
+   </g>
+   <g id="text_115">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="552.608499" y="276.067175" transform="rotate(-0 552.608499 276.067175)">0.9</text>
+   </g>
+   <g id="text_116">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="447.816991" y="268.727617" transform="rotate(-0 447.816991 268.727617)">GRU, order 8</text>
+   </g>
+   <g id="legend_5">
+    <g id="patch_31">
+     <path d="M 334.862109 311.829258 
+L 374.416484 311.829258 
+Q 375.816484 311.829258 375.816484 310.429258 
+L 375.816484 279.627617 
+Q 375.816484 278.227617 374.416484 278.227617 
+L 334.862109 278.227617 
+Q 333.462109 278.227617 333.462109 279.627617 
+L 333.462109 310.429258 
+Q 333.462109 311.829258 334.862109 311.829258 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_146">
+     <path d="M 336.262109 283.896523 
+L 343.262109 283.896523 
+L 350.262109 283.896523 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="343.262109" y="283.896523" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_117">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="286.346523" transform="rotate(-0 355.862109 286.346523)">FP32</text>
+    </g>
+    <g id="line2d_147">
+     <path d="M 336.262109 294.39707 
+L 343.262109 294.39707 
+L 350.262109 294.39707 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="343.262109" y="294.39707" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_118">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="296.84707" transform="rotate(-0 355.862109 296.84707)">FP16</text>
+    </g>
+    <g id="line2d_148">
+     <path d="M 336.262109 304.897617 
+L 343.262109 304.897617 
+L 350.262109 304.897617 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="343.262109" y="304.897617" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_119">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="355.862109" y="307.347617" transform="rotate(-0 355.862109 307.347617)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="axes_6">
+   <g id="patch_32">
+    <path d="M 614.722109 392.197891 
+L 850.431872 392.197891 
+L 850.431872 274.727617 
+L 614.722109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_11">
+    <g id="xtick_35">
+     <g id="line2d_149">
+      <path d="M 625.436189 392.197891 
+L 625.436189 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_150">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="625.436189" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_120">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="625.436189" y="406.035781" transform="rotate(-0 625.436189 406.035781)">0.0</text>
+     </g>
+    </g>
+    <g id="xtick_36">
+     <g id="line2d_151">
+      <path d="M 666.367994 392.197891 
+L 666.367994 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_152">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="666.367994" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_121">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="666.367994" y="406.035781" transform="rotate(-0 666.367994 406.035781)">0.5</text>
+     </g>
+    </g>
+    <g id="xtick_37">
+     <g id="line2d_153">
+      <path d="M 707.299798 392.197891 
+L 707.299798 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_154">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="707.299798" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_122">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="707.299798" y="406.035781" transform="rotate(-0 707.299798 406.035781)">1.0</text>
+     </g>
+    </g>
+    <g id="xtick_38">
+     <g id="line2d_155">
+      <path d="M 748.231603 392.197891 
+L 748.231603 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_156">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="748.231603" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_123">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="748.231603" y="406.035781" transform="rotate(-0 748.231603 406.035781)">1.5</text>
+     </g>
+    </g>
+    <g id="xtick_39">
+     <g id="line2d_157">
+      <path d="M 789.163407 392.197891 
+L 789.163407 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_158">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="789.163407" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_124">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="789.163407" y="406.035781" transform="rotate(-0 789.163407 406.035781)">2.0</text>
+     </g>
+    </g>
+    <g id="xtick_40">
+     <g id="line2d_159">
+      <path d="M 830.095212 392.197891 
+L 830.095212 274.727617 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_160">
+      <g>
+       <use xlink:href="#m07a3eaa03f" x="830.095212" y="392.197891" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_125">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="830.095212" y="406.035781" transform="rotate(-0 830.095212 406.035781)">2.5</text>
+     </g>
+    </g>
+    <g id="text_126">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="732.576991" y="419.036484" transform="rotate(-0 732.576991 419.036484)">Query-weighted vector error (%)</text>
+    </g>
+   </g>
+   <g id="matplotlib.axis_12">
+    <g id="ytick_26">
+     <g id="line2d_161">
+      <path d="M 614.722109 386.858333 
+L 850.431872 386.858333 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_162">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="386.858333" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_127">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="390.277278" transform="rotate(-0 607.722109 390.277278)">1</text>
+     </g>
+    </g>
+    <g id="ytick_27">
+     <g id="line2d_163">
+      <path d="M 614.722109 348.543293 
+L 850.431872 348.543293 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_164">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="348.543293" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_128">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="351.962238" transform="rotate(-0 607.722109 351.962238)">2</text>
+     </g>
+    </g>
+    <g id="ytick_28">
+     <g id="line2d_165">
+      <path d="M 614.722109 310.228253 
+L 850.431872 310.228253 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_166">
+      <g>
+       <use xlink:href="#me49566fb24" x="614.722109" y="310.228253" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_129">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="313.647199" transform="rotate(-0 607.722109 313.647199)">3</text>
+     </g>
+    </g>
+    <g id="text_130">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="595.83375" y="333.462754" transform="rotate(-90 595.83375 333.462754)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="line2d_167">
+    <path d="M 625.436189 386.858333 
+L 728.533946 370.157486 
+L 735.486368 370.130991 
+L 742.757686 370.116528 
+L 763.744454 370.081993 
+L 832.022245 370.029831 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p8a5a81055e)">
+     <use xlink:href="#mff235f3940" x="625.436189" y="386.858333" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="728.533946" y="370.157486" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="735.486368" y="370.130991" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="742.757686" y="370.116528" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="763.744454" y="370.081993" style="fill: #599268; stroke: #599268"/>
+     <use xlink:href="#mff235f3940" x="832.022245" y="370.029831" style="fill: #599268; stroke: #599268"/>
+    </g>
+   </g>
+   <g id="line2d_168">
+    <path d="M 627.137485 353.053381 
+L 728.536786 327.38403 
+L 735.48859 327.341264 
+L 742.758571 327.317598 
+L 763.740448 327.265425 
+L 832.169846 327.183259 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p8a5a81055e)">
+     <use xlink:href="#ma5f43dbdb6" x="627.137485" y="353.053381" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="728.536786" y="327.38403" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="735.48859" y="327.341264" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="742.758571" y="327.317598" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="763.740448" y="327.265425" style="fill: #5587b6; stroke: #5587b6"/>
+     <use xlink:href="#ma5f43dbdb6" x="832.169846" y="327.183259" style="fill: #5587b6; stroke: #5587b6"/>
+    </g>
+   </g>
+   <g id="line2d_169">
+    <path d="M 669.092302 302.192741 
+L 737.123472 280.318928 
+L 743.736086 280.265891 
+L 750.269626 280.239765 
+L 770.070233 280.172852 
+L 839.717792 280.067175 
+" clip-path="url(#p8a5a81055e)" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+    <g clip-path="url(#p8a5a81055e)">
+     <use xlink:href="#me5e70b3745" x="669.092302" y="302.192741" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="737.123472" y="280.318928" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="743.736086" y="280.265891" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="750.269626" y="280.239765" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="770.070233" y="280.172852" style="fill: #ed9c42; stroke: #ed9c42"/>
+     <use xlink:href="#me5e70b3745" x="839.717792" y="280.067175" style="fill: #ed9c42; stroke: #ed9c42"/>
+    </g>
+   </g>
+   <g id="patch_33">
+    <path d="M 614.722109 392.197891 
+L 614.722109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_34">
+    <path d="M 850.431872 392.197891 
+L 850.431872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_35">
+    <path d="M 614.722109 392.197891 
+L 850.431872 392.197891 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_36">
+    <path d="M 614.722109 274.727617 
+L 850.431872 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_131">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="730.533946" y="366.157486" transform="rotate(-0 730.533946 366.157486)">0.99</text>
+   </g>
+   <g id="text_132">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="834.022245" y="366.029831" transform="rotate(-0 834.022245 366.029831)">0.9</text>
+   </g>
+   <g id="text_133">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="730.536786" y="323.38403" transform="rotate(-0 730.536786 323.38403)">0.99</text>
+   </g>
+   <g id="text_134">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="834.169846" y="323.183259" transform="rotate(-0 834.169846 323.183259)">0.9</text>
+   </g>
+   <g id="text_135">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="739.123472" y="276.318928" transform="rotate(-0 739.123472 276.318928)">0.99</text>
+   </g>
+   <g id="text_136">
+    <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="841.717792" y="276.067175" transform="rotate(-0 841.717792 276.067175)">0.9</text>
+   </g>
+   <g id="text_137">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="732.576991" y="268.727617" transform="rotate(-0 732.576991 268.727617)">GRU, order 12</text>
+   </g>
+   <g id="legend_6">
+    <g id="patch_37">
+     <path d="M 619.622109 311.829258 
+L 659.176484 311.829258 
+Q 660.576484 311.829258 660.576484 310.429258 
+L 660.576484 279.627617 
+Q 660.576484 278.227617 659.176484 278.227617 
+L 619.622109 278.227617 
+Q 618.222109 278.227617 618.222109 279.627617 
+L 618.222109 310.429258 
+Q 618.222109 311.829258 619.622109 311.829258 
+z
+" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
+    </g>
+    <g id="line2d_170">
+     <path d="M 621.022109 283.896523 
+L 628.022109 283.896523 
+L 635.022109 283.896523 
+" style="fill: none; stroke: #599268; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#mff235f3940" x="628.022109" y="283.896523" style="fill: #599268; stroke: #599268"/>
+     </g>
+    </g>
+    <g id="text_138">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="286.346523" transform="rotate(-0 640.622109 286.346523)">FP32</text>
+    </g>
+    <g id="line2d_171">
+     <path d="M 621.022109 294.39707 
+L 628.022109 294.39707 
+L 635.022109 294.39707 
+" style="fill: none; stroke: #5587b6; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#ma5f43dbdb6" x="628.022109" y="294.39707" style="fill: #5587b6; stroke: #5587b6"/>
+     </g>
+    </g>
+    <g id="text_139">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="296.84707" transform="rotate(-0 640.622109 296.84707)">FP16</text>
+    </g>
+    <g id="line2d_172">
+     <path d="M 621.022109 304.897617 
+L 628.022109 304.897617 
+L 635.022109 304.897617 
+" style="fill: none; stroke: #ed9c42; stroke-width: 1.5; stroke-linecap: square"/>
+     <g>
+      <use xlink:href="#me5e70b3745" x="628.022109" y="304.897617" style="fill: #ed9c42; stroke: #ed9c42"/>
+     </g>
+    </g>
+    <g id="text_140">
+     <text style="font-size: 7px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: start" x="640.622109" y="307.347617" transform="rotate(-0 640.622109 307.347617)">INT8</text>
+    </g>
+   </g>
+  </g>
+  <g id="text_141">
+   <text style="font-size: 11px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(293.449844 18.099355)">Final error vs original FP32; mean of trained seeds</text>
+   <text style="font-size: 11px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(205.817656 31.302363)">Raw controls + cosine sweep 0.99, 0.98, 0.97, 0.95, 0.90; norm ratio fixed at 0.99</text>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="pba293368a2">
+   <rect x="45.202109" y="103.249766" width="235.709762" height="117.470273"/>
+  </clipPath>
+  <clipPath id="p511bbc1eb0">
+   <rect x="329.962109" y="103.249766" width="235.709762" height="117.470273"/>
+  </clipPath>
+  <clipPath id="pa390beb15e">
+   <rect x="614.722109" y="103.249766" width="235.709762" height="117.470273"/>
+  </clipPath>
+  <clipPath id="p4c4f436987">
+   <rect x="45.202109" y="274.727617" width="235.709762" height="117.470273"/>
+  </clipPath>
+  <clipPath id="pab651db98d">
+   <rect x="329.962109" y="274.727617" width="235.709762" height="117.470273"/>
+  </clipPath>
+  <clipPath id="p8a5a81055e">
+   <rect x="614.722109" y="274.727617" width="235.709762" height="117.470273"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/quantized_structural_evidence_20261031/report.json b/docs/quantized_structural_evidence_20261031/report.json
new file mode 100644
index 0000000..161db67
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/report.json
@@ -0,0 +1,71221 @@
+{
+  "category": "cached public-text trained SGNS / causal GRU; CPU quantization + structural controls",
+  "commit": "3a54de2d8a7b97ee1432980c41b4edb0f64566d3",
+  "command": "/llm-align/duyimin/meft-cuda-20261030/compat/bin/python -m tools.benchmark_quantized_structural --sgns-dir artifacts/native-ngram-20261018/trained-reference --gru-dir artifacts/causal-lm-compression-20261024 --corpus artifacts/native-ngram-20261018/corpus/tinyshakespeare.txt --native-library build/libmeft_rows.so --structural-library build/libmeft_structural.so --planner native --output-dir /llm-align/duyimin/ngram-quantized-20261031/results --orders 4,8,12 --seeds 3,7,11 --thresholds .99,.98,.97,.95,.90 --norm-ratio .99 --repeat 40",
+  "working_directory": "/llm-align/duyimin/ngram-quantized-20261031/source",
+  "python": "3.11.15 (main, Mar 11 2026, 17:20:07) [GCC 14.3.0]",
+  "pytorch": "2.11.0+cu130",
+  "numpy": "2.2.6",
+  "platform": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35",
+  "cpu": "AMD EPYC 7742 64-Core Processor",
+  "logical_cpus": 255,
+  "device": "cpu",
+  "gpu": "unused",
+  "threads": 1,
+  "interop_threads": 1,
+  "compiler": "cc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0",
+  "source_sha256": {
+    "tools/quantized_memory.py": "393c84a8ee9d822c455ecbf077d584b9ee092a43dfce4842f5d0a9154ced779a",
+    "tools/benchmark_quantized_structural.py": "9613142ef7adbea588e97b2474a84009a37df412fac120ea7bbd27bdfd36d36a",
+    "tools/benchmark_cosine_merge.py": "0608a3312f7a7d97287b9a1f9d0d440bd4835ba9ba7437ab65116b269ca6a4c9",
+    "tools/structural_native.py": "acba60c392a5e672c903f96e2cf0427731791d82f9ce38b7334547f1dc498c3a",
+    "tools/native_row_store.py": "95d1d3b5e56c397d5e5f207702a1db018407eda62642887044003e16b2b3e8f8",
+    "tools/causal_ngram_lm.py": "16ec3fab33b5b2cddb1133ced7173fdf329e7a048def734a02c27457f4ddbd9e",
+    "native/meft_rows.c": "48c82769f3651635c091ef107254039de97b95a179520bd8e8ba874d08252258"
+  },
+  "working_tree_dirty": false,
+  "native_library_sha256": "49aa8e7e82c83e3ec0b103af62eeb3638d98a18a780a35bb5c80e435fc791c51",
+  "structural_library_sha256": "bd5a2b28a05e873426d943d01334d0beaf253944a3e9565d4514a807f21efb25",
+  "corpus_sha256": "86c4e6aa9db7c042ec79f339dcb96d42b0075e16b8fc2e86bf0ca57e2dc565ed",
+  "corpus_source": "https://raw.githubusercontent.com/karpathy/char-rnn/6f9487a6fe5b420b7ca9afb0d7c078e37c1d1b4e/data/tinyshakespeare/input.txt",
+  "training_report_sha256": {
+    "sgns": "d555aa72c2e761488e41b50b472cdfc88fd32fc29b73136e9effa522be050f02",
+    "gru": "0ab395574da8186552af5c342d8bc794dda3ef7c3c35a517397c431ea0ac3c2d"
+  },
+  "settings": {
+    "planner": "native",
+    "orders": "4,8,12",
+    "seeds": "3,7,11",
+    "thresholds": ".99,.98,.97,.95,.90",
+    "norm_ratio": 0.99,
+    "max_block_bytes": 8192,
+    "cache_bytes": 4194304,
+    "query_rows": 512,
+    "repeat": 40,
+    "burn_in": 64,
+    "eval_chunk": 256,
+    "eval_seed": 42,
+    "max_ppl_increase": 0.005,
+    "max_kl": 0.0001,
+    "max_top1_flip": 0.01,
+    "threshold_values": [
+      0.99,
+      0.98,
+      0.97,
+      0.95,
+      0.9
+    ]
+  },
+  "selection_rule": "minimum complete backend + common key registry bytes within all validation budgets, separately by encoding; freeze before test; no test reselection",
+  "cost_assumptions": "existing cached weights/text; shared/local single CPU worker; no paid data or GPU; energy/currency cost unmeasured",
+  "limitations": [
+    "Small trained English SGNS/GRU references, not an official trained Engram checkpoint or paper-scale reproduction.",
+    "Reference planner is portable greedy prefix/suffix selection, not production DATrie; native planner is separately labeled.",
+    "Selection and primary storage totals use a common actual keys JSON; native runs also report a serialized DATrie alternative separately. No key lookup speed claim.",
+    "Full GRU bundle sums encoded backend, codec JSON, common keys JSON and actual serialized unchanged backbone/registry; excludes runtime/framework, logs and training checkpoint.",
+    "Row INT8 is symmetric nearest-even with float32 scale per row; no activation quantization or fine tuning.",
+    "Quantization occurs before planning; final error is measured against original float32 and quantization-only rows.",
+    "Filesystem pages are warm after row verification; first query has empty application cache, not disk-cold I/O.",
+    "Queries include Python/NumPy dequantization and allocations; no fused INT8 kernel, RSS, concurrent traffic or full-model latency claim.",
+    "One cached corpus, three seeds; SGNS reports vector distortion only, GRU reports character task quality.",
+    "Corpus license not independently established; raw text, keys, weights and serving bundles stay local."
+  ],
+  "runs": [
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "rows": 5333,
+      "dim": 128,
+      "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+      "source_float32_bytes": 2730496,
+      "key_registry_bytes": 70934,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 43056,
+      "query_rows": 512,
+      "query_ids_sha256": "87677d489e681e6c0a39b8460231cf990090e3318abb13c912a002c527931d01",
+      "frequency_trace_sha256": "0e7a36c623f2fc5cc1e4fd51bc27b7b98d60f0c1b31a56fb66253e951084f56a",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 2730496,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "table_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.01689741713926196,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2731299,
+          "backend_with_key_registry_bytes": 2802233,
+          "backend_with_datrie_key_index_bytes": 2774355,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.398305,
+            "warm_p50_ms": 0.062508,
+            "warm_p95_ms": 0.0663244,
+            "warm_p99_ms": 0.06718761,
+            "samples_ms": [
+              0.067187,
+              0.065301,
+              0.067188,
+              0.065791,
+              0.064812,
+              0.06579,
+              0.066279,
+              0.064813,
+              0.064813,
+              0.06579,
+              0.065302,
+              0.063905,
+              0.062927,
+              0.062927,
+              0.062997,
+              0.061949,
+              0.062438,
+              0.063766,
+              0.062857,
+              0.062368,
+              0.062019,
+              0.062439,
+              0.062508,
+              0.062508,
+              0.060552,
+              0.062438,
+              0.062508,
+              0.062508,
+              0.062508,
+              0.062438,
+              0.061461,
+              0.060064,
+              0.06202,
+              0.062019,
+              0.061949,
+              0.061949,
+              0.060483,
+              0.062019,
+              0.060972,
+              0.060972
+            ],
+            "warm_rows_per_second": 8190951.558200551
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607844,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 301,
+              "xor_blocks": 33,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "table_sha256": "6f073b2460802333d25edda9ad3a7793a83c167a107f7fb2adba18242a6ac9df",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25159990903921425,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2609048,
+          "backend_with_key_registry_bytes": 2679982,
+          "backend_with_datrie_key_index_bytes": 2652104,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.514488,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.07391629999999999,
+            "warm_p99_ms": 0.07656017,
+            "samples_ms": [
+              0.077105,
+              0.075708,
+              0.073333,
+              0.073822,
+              0.071937,
+              0.071937,
+              0.069631,
+              0.070121,
+              0.070958,
+              0.069562,
+              0.071028,
+              0.070051,
+              0.070051,
+              0.07054,
+              0.069981,
+              0.069981,
+              0.069632,
+              0.07054,
+              0.070051,
+              0.069911,
+              0.070051,
+              0.07005,
+              0.069562,
+              0.069981,
+              0.068655,
+              0.073334,
+              0.069632,
+              0.069632,
+              0.069981,
+              0.069562,
+              0.069632,
+              0.069562,
+              0.07047,
+              0.069981,
+              0.069981,
+              0.07012,
+              0.072425,
+              0.071937,
+              0.071937,
+              0.070051
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607844,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 301,
+              "xor_blocks": 33,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "table_sha256": "6f073b2460802333d25edda9ad3a7793a83c167a107f7fb2adba18242a6ac9df",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.30454140016809106,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2609047,
+          "backend_with_key_registry_bytes": 2679981,
+          "backend_with_datrie_key_index_bytes": 2652103,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.504011,
+            "warm_p50_ms": 0.06994600000000001,
+            "warm_p95_ms": 0.07247485000000001,
+            "warm_p99_ms": 0.07455345999999999,
+            "samples_ms": [
+              0.075289,
+              0.071937,
+              0.071937,
+              0.071517,
+              0.071937,
+              0.071937,
+              0.072006,
+              0.071936,
+              0.071937,
+              0.071937,
+              0.072425,
+              0.072425,
+              0.072356,
+              0.072426,
+              0.071378,
+              0.069562,
+              0.069073,
+              0.069003,
+              0.069143,
+              0.073403,
+              0.071936,
+              0.069632,
+              0.070051,
+              0.069492,
+              0.069632,
+              0.069073,
+              0.069562,
+              0.069143,
+              0.069562,
+              0.069073,
+              0.069562,
+              0.069143,
+              0.069562,
+              0.069911,
+              0.069073,
+              0.069632,
+              0.069982,
+              0.069492,
+              0.068654,
+              0.069981
+            ],
+            "warm_rows_per_second": 7319932.519372086
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607844,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 301,
+              "xor_blocks": 33,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "table_sha256": "6f073b2460802333d25edda9ad3a7793a83c167a107f7fb2adba18242a6ac9df",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2597450870089233,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2609047,
+          "backend_with_key_registry_bytes": 2679981,
+          "backend_with_datrie_key_index_bytes": 2652103,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.520145,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.07524694999999999,
+            "warm_p99_ms": 0.08178527999999999,
+            "samples_ms": [
+              0.075778,
+              0.075219,
+              0.073333,
+              0.073333,
+              0.073822,
+              0.072425,
+              0.073333,
+              0.073822,
+              0.072844,
+              0.073263,
+              0.073333,
+              0.069981,
+              0.069493,
+              0.069562,
+              0.069632,
+              0.069493,
+              0.069981,
+              0.070959,
+              0.069492,
+              0.068584,
+              0.070051,
+              0.070051,
+              0.069073,
+              0.0704,
+              0.0704,
+              0.069631,
+              0.070051,
+              0.069004,
+              0.069981,
+              0.070051,
+              0.085626,
+              0.0704,
+              0.069492,
+              0.069073,
+              0.068654,
+              0.070889,
+              0.068026,
+              0.069143,
+              0.069073,
+              0.069073
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1967696,
+              "unique_rows": 3997,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 250,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 250,
+              "zlib_blocks": 250,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3997
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "eeafd58493e15990ba17872aaeb6f4c349db6fb94a51dc3e78ef1310f3cb4daf",
+            "table_sha256": "bd06f338aeef379b593f0b2e56db41e22889fdc16c0df3679bea537fc0785997",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18648262601345778,
+          "representatives_sha256": "ef4aaba8cd352e6da1938c6dd5a8b0c9b84e3d822af421eab1e84b6232912067",
+          "structurally_merged_rows": 1336,
+          "backend_artifact_bytes": 1968898,
+          "backend_with_key_registry_bytes": 2039832,
+          "backend_with_datrie_key_index_bytes": 2011954,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900040679606642,
+            "mean_cosine": 0.9991888464230989,
+            "p05_cosine": 0.9948229470039848,
+            "relative_l2_mean": 0.01884328678926973,
+            "relative_l2_p95": 0.10175910746440275,
+            "relative_l2_max": 0.14212765851757603,
+            "weighted_relative_l2_mean": 0.007670254799828044,
+            "weighted_relative_frobenius": 0.00684819310974004,
+            "weighted_mean_cosine": 0.9997023595827568,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900040679606642,
+            "mean_cosine": 0.9991888464230989,
+            "p05_cosine": 0.9948229470039848,
+            "relative_l2_mean": 0.01884328678926973,
+            "relative_l2_p95": 0.10175910746440275,
+            "relative_l2_max": 0.14212765851757603,
+            "weighted_relative_l2_mean": 0.007670254799828044,
+            "weighted_relative_frobenius": 0.00684819310974004,
+            "weighted_mean_cosine": 0.9997023595827568,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.429572,
+            "warm_p50_ms": 0.070958,
+            "warm_p95_ms": 0.07438085,
+            "warm_p99_ms": 0.08375999999999999,
+            "samples_ms": [
+              0.075708,
+              0.073823,
+              0.073823,
+              0.071517,
+              0.071029,
+              0.070959,
+              0.071447,
+              0.070959,
+              0.070889,
+              0.070958,
+              0.069073,
+              0.071029,
+              0.069073,
+              0.069492,
+              0.073333,
+              0.070958,
+              0.069073,
+              0.069073,
+              0.069982,
+              0.068095,
+              0.069073,
+              0.069073,
+              0.088908,
+              0.074311,
+              0.070959,
+              0.071448,
+              0.071378,
+              0.070959,
+              0.068654,
+              0.068584,
+              0.07047,
+              0.069073,
+              0.069632,
+              0.068584,
+              0.069493,
+              0.070959,
+              0.069143,
+              0.069562,
+              0.071378,
+              0.070959
+            ],
+            "warm_rows_per_second": 7215535.950844162
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1918572,
+              "unique_rows": 3895,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 244,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 244,
+              "zlib_blocks": 244,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3895
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "4a137b5bf285721c37e05981b0724a2710a24167455eeee315ce3daf2501efef",
+            "table_sha256": "2f0226e13568f5c5118c63140f4d44afc222f4488c2a2e045734b9bcc733053d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.17670658300630748,
+          "representatives_sha256": "bac02f935f7a7d9440de1468a50c989f3fdc61b31b8e915bbb3b0e68aad2309c",
+          "structurally_merged_rows": 1438,
+          "backend_artifact_bytes": 1919774,
+          "backend_with_key_registry_bytes": 1990708,
+          "backend_with_datrie_key_index_bytes": 1962830,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800525166930897,
+            "mean_cosine": 0.9989374160530267,
+            "p05_cosine": 0.9936510900109885,
+            "relative_l2_mean": 0.021932775249007413,
+            "relative_l2_p95": 0.11307263013339221,
+            "relative_l2_max": 0.19900629357720578,
+            "weighted_relative_l2_mean": 0.00870488587784729,
+            "weighted_relative_frobenius": 0.008087597127804755,
+            "weighted_mean_cosine": 0.999617368148953,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800525166930897,
+            "mean_cosine": 0.9989374160530267,
+            "p05_cosine": 0.9936510900109885,
+            "relative_l2_mean": 0.021932775249007413,
+            "relative_l2_p95": 0.11307263013339221,
+            "relative_l2_max": 0.19900629357720578,
+            "weighted_relative_l2_mean": 0.00870488587784729,
+            "weighted_relative_frobenius": 0.008087597127804755,
+            "weighted_mean_cosine": 0.999617368148953,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.459324,
+            "warm_p50_ms": 0.069143,
+            "warm_p95_ms": 0.073822,
+            "warm_p99_ms": 0.07527075,
+            "samples_ms": [
+              0.076197,
+              0.073263,
+              0.073822,
+              0.073333,
+              0.073333,
+              0.072844,
+              0.071448,
+              0.073822,
+              0.071378,
+              0.071378,
+              0.069073,
+              0.069143,
+              0.068095,
+              0.069074,
+              0.069143,
+              0.069003,
+              0.069074,
+              0.069073,
+              0.069003,
+              0.068165,
+              0.069562,
+              0.069003,
+              0.068165,
+              0.069562,
+              0.069492,
+              0.069143,
+              0.069143,
+              0.069004,
+              0.070121,
+              0.069073,
+              0.069073,
+              0.069143,
+              0.069003,
+              0.069003,
+              0.069631,
+              0.068165,
+              0.069003,
+              0.069562,
+              0.068096,
+              0.069003
+            ],
+            "warm_rows_per_second": 7404943.37821616
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1905402,
+              "unique_rows": 3868,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3868
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "f509e53e8e15a5029ceb28d12a424c8a0de2172555baf317b58ddcad79813d6d",
+            "table_sha256": "492c98fd156ff1255b72982a41821d49f58278aa95ab2334341bd43c58738de0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1765840109437704,
+          "representatives_sha256": "3d2722b4790e7f3828089970b17116fd5bb2830718d9d18f091dce19a7c23da6",
+          "structurally_merged_rows": 1465,
+          "backend_artifact_bytes": 1906604,
+          "backend_with_key_registry_bytes": 1977538,
+          "backend_with_datrie_key_index_bytes": 1949660,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9708564945641197,
+            "mean_cosine": 0.998818066779941,
+            "p05_cosine": 0.9932313242577301,
+            "relative_l2_mean": 0.02302971706719548,
+            "relative_l2_p95": 0.11659229645192355,
+            "relative_l2_max": 0.24115678654601577,
+            "weighted_relative_l2_mean": 0.009130428528990344,
+            "weighted_relative_frobenius": 0.009068352203125815,
+            "weighted_mean_cosine": 0.9995700085264972,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9708564945641197,
+            "mean_cosine": 0.998818066779941,
+            "p05_cosine": 0.9932313242577301,
+            "relative_l2_mean": 0.02302971706719548,
+            "relative_l2_p95": 0.11659229645192355,
+            "relative_l2_max": 0.24115678654601577,
+            "weighted_relative_l2_mean": 0.009130428528990344,
+            "weighted_relative_frobenius": 0.009068352203125815,
+            "weighted_mean_cosine": 0.9995700085264972,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.257902,
+            "warm_p50_ms": 0.069073,
+            "warm_p95_ms": 0.08381335,
+            "warm_p99_ms": 0.10016053999999999,
+            "samples_ms": [
+              0.085207,
+              0.076616,
+              0.073822,
+              0.072425,
+              0.109721,
+              0.073334,
+              0.08374,
+              0.081365,
+              0.072356,
+              0.072844,
+              0.07047,
+              0.069632,
+              0.069073,
+              0.068654,
+              0.069073,
+              0.067607,
+              0.068724,
+              0.069492,
+              0.068514,
+              0.068095,
+              0.069981,
+              0.068584,
+              0.069003,
+              0.069493,
+              0.068654,
+              0.068584,
+              0.068584,
+              0.068654,
+              0.068095,
+              0.068584,
+              0.067676,
+              0.069073,
+              0.069562,
+              0.068654,
+              0.067606,
+              0.067676,
+              0.068585,
+              0.069073,
+              0.067676,
+              0.069073
+            ],
+            "warm_rows_per_second": 7412447.700259147
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1902965,
+              "unique_rows": 3863,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3863
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ea0037236596c4044283efecdbd91c5c4ef1891882a2a3426bdd8d00cc461cc6",
+            "table_sha256": "5e9afb06f27da24c68c8af32ce619639990966c6905967e0885482dda50aac4a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.17827019095420837,
+          "representatives_sha256": "2d91381efe39349a4f7459fd91e99d9596260a0a212cd952ba52df34a1785bac",
+          "structurally_merged_rows": 1470,
+          "backend_artifact_bytes": 1904167,
+          "backend_with_key_registry_bytes": 1975101,
+          "backend_with_datrie_key_index_bytes": 1947223,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9504355998657713,
+            "mean_cosine": 0.9987848342638137,
+            "p05_cosine": 0.9930668648311156,
+            "relative_l2_mean": 0.023277964105222548,
+            "relative_l2_p95": 0.11772121655625935,
+            "relative_l2_max": 0.31347274120328616,
+            "weighted_relative_l2_mean": 0.00920108182463547,
+            "weighted_relative_frobenius": 0.0091938901341558,
+            "weighted_mean_cosine": 0.9995605502594191,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9504355998657713,
+            "mean_cosine": 0.9987848342638137,
+            "p05_cosine": 0.9930668648311156,
+            "relative_l2_mean": 0.023277964105222548,
+            "relative_l2_p95": 0.11772121655625935,
+            "relative_l2_max": 0.31347274120328616,
+            "weighted_relative_l2_mean": 0.00920108182463547,
+            "weighted_relative_frobenius": 0.0091938901341558,
+            "weighted_mean_cosine": 0.9995605502594191,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.17081,
+            "warm_p50_ms": 0.0692825,
+            "warm_p95_ms": 0.07312784999999998,
+            "warm_p99_ms": 0.0865967,
+            "samples_ms": [
+              0.078502,
+              0.091772,
+              0.072845,
+              0.070958,
+              0.069632,
+              0.070958,
+              0.072425,
+              0.070051,
+              0.069981,
+              0.069073,
+              0.069632,
+              0.069073,
+              0.068584,
+              0.069073,
+              0.068584,
+              0.069562,
+              0.068165,
+              0.070959,
+              0.069492,
+              0.069492,
+              0.067187,
+              0.067607,
+              0.069562,
+              0.069073,
+              0.068165,
+              0.068165,
+              0.069004,
+              0.069073,
+              0.068654,
+              0.067607,
+              0.067187,
+              0.069003,
+              0.069143,
+              0.069562,
+              0.069422,
+              0.069562,
+              0.067187,
+              0.069562,
+              0.068165,
+              0.069493
+            ],
+            "warm_rows_per_second": 7390033.558257857
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1898125,
+              "unique_rows": 3853,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 241,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 241,
+              "zlib_blocks": 241,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3853
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ceef06043a75f8efe99c23f3abace42679238d890bc5c8c4e58117d380ceab5f",
+            "table_sha256": "22adc45ddfc7350dcc495198ebed5054bef3d9537cc51569d93401d662de0ed3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.17404765309765935,
+          "representatives_sha256": "a560f77b4cdb526521bda23eaf1036640ed787744b9adb92198b323f829440b6",
+          "structurally_merged_rows": 1480,
+          "backend_artifact_bytes": 1899327,
+          "backend_with_key_registry_bytes": 1970261,
+          "backend_with_datrie_key_index_bytes": 1942383,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.905778580067121,
+            "mean_cosine": 0.9986470538910384,
+            "p05_cosine": 0.9928871918850045,
+            "relative_l2_mean": 0.023994103980148295,
+            "relative_l2_p95": 0.11947499907741611,
+            "relative_l2_max": 0.4327155490851253,
+            "weighted_relative_l2_mean": 0.009653463963460706,
+            "weighted_relative_frobenius": 0.01186738501987831,
+            "weighted_mean_cosine": 0.999472486628229,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.905778580067121,
+            "mean_cosine": 0.9986470538910384,
+            "p05_cosine": 0.9928871918850045,
+            "relative_l2_mean": 0.023994103980148295,
+            "relative_l2_p95": 0.11947499907741611,
+            "relative_l2_max": 0.4327155490851253,
+            "weighted_relative_l2_mean": 0.009653463963460706,
+            "weighted_relative_frobenius": 0.01186738501987831,
+            "weighted_mean_cosine": 0.999472486628229,
+            "max_relative_norm_change": 0.010098903037758608
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.169832,
+            "warm_p50_ms": 0.069492,
+            "warm_p95_ms": 0.07568785,
+            "warm_p99_ms": 0.09195322999999998,
+            "samples_ms": [
+              0.075639,
+              0.076616,
+              0.074311,
+              0.073403,
+              0.072356,
+              0.070959,
+              0.072915,
+              0.071937,
+              0.071867,
+              0.071936,
+              0.071448,
+              0.070959,
+              0.070539,
+              0.069492,
+              0.069492,
+              0.069562,
+              0.068095,
+              0.069492,
+              0.069073,
+              0.067677,
+              0.069492,
+              0.069562,
+              0.067676,
+              0.067676,
+              0.067188,
+              0.067746,
+              0.068515,
+              0.068584,
+              0.068654,
+              0.066698,
+              0.068165,
+              0.069492,
+              0.068235,
+              0.101759,
+              0.068584,
+              0.067676,
+              0.069004,
+              0.069632,
+              0.068584,
+              0.069492
+            ],
+            "warm_rows_per_second": 7367754.561676163
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 1365248,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "296818b431b3b39a43a36929a876a94efefae21f382f9e84d4ec3286e3b60d62",
+            "table_sha256": "52145b2df4fa23885150f1e519fa52a4ec2a87a67d7d95a528f5872c4325106a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.017670071916654706,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1366052,
+          "backend_with_key_registry_bytes": 1436986,
+          "backend_with_datrie_key_index_bytes": 1409108,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999597685811,
+            "mean_cosine": 0.9999999790028546,
+            "p05_cosine": 0.9999999730846733,
+            "relative_l2_mean": 0.00020681644286260717,
+            "relative_l2_p95": 0.00023407261360449034,
+            "relative_l2_max": 0.00028366458574764547,
+            "weighted_relative_l2_mean": 0.0002068006001193933,
+            "weighted_relative_frobenius": 0.00020696152811249227,
+            "weighted_mean_cosine": 0.9999999790474928,
+            "max_relative_norm_change": 0.00012388940698008832
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.471709,
+            "warm_p50_ms": 0.2202445,
+            "warm_p95_ms": 0.2232411,
+            "warm_p99_ms": 0.24625502,
+            "samples_ms": [
+              0.221398,
+              0.221397,
+              0.220489,
+              0.220489,
+              0.220001,
+              0.221886,
+              0.219511,
+              0.220489,
+              0.220908,
+              0.220001,
+              0.220001,
+              0.219581,
+              0.222864,
+              0.256388,
+              0.22049,
+              0.220489,
+              0.22007,
+              0.220559,
+              0.219581,
+              0.220489,
+              0.220489,
+              0.219093,
+              0.219931,
+              0.219512,
+              0.219022,
+              0.219512,
+              0.219093,
+              0.22,
+              0.220489,
+              0.22,
+              0.230406,
+              0.221956,
+              0.220419,
+              0.220489,
+              0.219023,
+              0.219512,
+              0.219512,
+              0.221886,
+              0.219022,
+              0.219581
+            ],
+            "warm_rows_per_second": 2324689.152283031
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329270,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "296818b431b3b39a43a36929a876a94efefae21f382f9e84d4ec3286e3b60d62",
+            "table_sha256": "f75dbfb59c763f1db9c4e95650a7059e44bb50c6bed40b09ce7fb914583d1ac9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12936148000881076,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330475,
+          "backend_with_key_registry_bytes": 1401409,
+          "backend_with_datrie_key_index_bytes": 1373531,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999597685811,
+            "mean_cosine": 0.9999999790028546,
+            "p05_cosine": 0.9999999730846733,
+            "relative_l2_mean": 0.00020681644286260717,
+            "relative_l2_p95": 0.00023407261360449034,
+            "relative_l2_max": 0.00028366458574764547,
+            "weighted_relative_l2_mean": 0.0002068006001193933,
+            "weighted_relative_frobenius": 0.00020696152811249227,
+            "weighted_mean_cosine": 0.9999999790474928,
+            "max_relative_norm_change": 0.00012388940698008832
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.122351,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.24519529999999998,
+            "warm_p99_ms": 0.26012393,
+            "samples_ms": [
+              0.229917,
+              0.229499,
+              0.263093,
+              0.232781,
+              0.22901,
+              0.22901,
+              0.229918,
+              0.229987,
+              0.229429,
+              0.229429,
+              0.228521,
+              0.22901,
+              0.229498,
+              0.227543,
+              0.229009,
+              0.227543,
+              0.228032,
+              0.22894,
+              0.229499,
+              0.244654,
+              0.230895,
+              0.228521,
+              0.229079,
+              0.229499,
+              0.229988,
+              0.22901,
+              0.228032,
+              0.228102,
+              0.228521,
+              0.228521,
+              0.228521,
+              0.227613,
+              0.22859,
+              0.227124,
+              0.22894,
+              0.228102,
+              0.25548,
+              0.231804,
+              0.231315,
+              0.229429
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329270,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "296818b431b3b39a43a36929a876a94efefae21f382f9e84d4ec3286e3b60d62",
+            "table_sha256": "f75dbfb59c763f1db9c4e95650a7059e44bb50c6bed40b09ce7fb914583d1ac9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14403626509010792,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330474,
+          "backend_with_key_registry_bytes": 1401408,
+          "backend_with_datrie_key_index_bytes": 1373530,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999597685811,
+            "mean_cosine": 0.9999999790028546,
+            "p05_cosine": 0.9999999730846733,
+            "relative_l2_mean": 0.00020681644286260717,
+            "relative_l2_p95": 0.00023407261360449034,
+            "relative_l2_max": 0.00028366458574764547,
+            "weighted_relative_l2_mean": 0.0002068006001193933,
+            "weighted_relative_frobenius": 0.00020696152811249227,
+            "weighted_mean_cosine": 0.9999999790474928,
+            "max_relative_norm_change": 0.00012388940698008832
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.118929,
+            "warm_p50_ms": 0.228102,
+            "warm_p95_ms": 0.23328039999999997,
+            "warm_p99_ms": 0.24966992999999998,
+            "samples_ms": [
+              0.232781,
+              0.22901,
+              0.22901,
+              0.229009,
+              0.228032,
+              0.229428,
+              0.228521,
+              0.228032,
+              0.22901,
+              0.229917,
+              0.227962,
+              0.228451,
+              0.227054,
+              0.227613,
+              0.228101,
+              0.242769,
+              0.22901,
+              0.229079,
+              0.227613,
+              0.22901,
+              0.228032,
+              0.227543,
+              0.227054,
+              0.228032,
+              0.227124,
+              0.227613,
+              0.22859,
+              0.228521,
+              0.228102,
+              0.227613,
+              0.229079,
+              0.228102,
+              0.227543,
+              0.254082,
+              0.230477,
+              0.227194,
+              0.228521,
+              0.227613,
+              0.227543,
+              0.227543
+            ],
+            "warm_rows_per_second": 2244609.86751541
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329270,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "296818b431b3b39a43a36929a876a94efefae21f382f9e84d4ec3286e3b60d62",
+            "table_sha256": "f75dbfb59c763f1db9c4e95650a7059e44bb50c6bed40b09ce7fb914583d1ac9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12945192400366068,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330474,
+          "backend_with_key_registry_bytes": 1401408,
+          "backend_with_datrie_key_index_bytes": 1373530,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999597685811,
+            "mean_cosine": 0.9999999790028546,
+            "p05_cosine": 0.9999999730846733,
+            "relative_l2_mean": 0.00020681644286260717,
+            "relative_l2_p95": 0.00023407261360449034,
+            "relative_l2_max": 0.00028366458574764547,
+            "weighted_relative_l2_mean": 0.0002068006001193933,
+            "weighted_relative_frobenius": 0.00020696152811249227,
+            "weighted_mean_cosine": 0.9999999790474928,
+            "max_relative_norm_change": 0.00012388940698008832
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.092878,
+            "warm_p50_ms": 0.227613,
+            "warm_p95_ms": 0.23241074999999997,
+            "warm_p99_ms": 0.25195856,
+            "samples_ms": [
+              0.230896,
+              0.229988,
+              0.227613,
+              0.228521,
+              0.228032,
+              0.227125,
+              0.228032,
+              0.228102,
+              0.227612,
+              0.227962,
+              0.227054,
+              0.227543,
+              0.227613,
+              0.257924,
+              0.231873,
+              0.227613,
+              0.227054,
+              0.226566,
+              0.227543,
+              0.228451,
+              0.227124,
+              0.226635,
+              0.227613,
+              0.227054,
+              0.228452,
+              0.226984,
+              0.228102,
+              0.227124,
+              0.227613,
+              0.227054,
+              0.227543,
+              0.242628,
+              0.228102,
+              0.228032,
+              0.228102,
+              0.226705,
+              0.228101,
+              0.227543,
+              0.226076,
+              0.226565
+            ],
+            "warm_rows_per_second": 2249432.150184743
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1009649,
+              "unique_rows": 3997,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 125,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3997
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "56577f0054e9bfe36a676c73b2a50a564a8e54def7869e4135431b1876315339",
+            "table_sha256": "3a77aa8f9a9551522beca76ca19c5a0ad41d6a6c8cbb46d51f64e3dee3a45007",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12075786292552948,
+          "representatives_sha256": "621c15475c9148850fa0f5e6b5803a1b164ef21e957b62c9921bb49c75625178",
+          "structurally_merged_rows": 1336,
+          "backend_artifact_bytes": 1010851,
+          "backend_with_key_registry_bytes": 1081785,
+          "backend_with_datrie_key_index_bytes": 1053907,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900084933818281,
+            "mean_cosine": 0.9991890700905423,
+            "p05_cosine": 0.9948229505519887,
+            "relative_l2_mean": 0.018995755979649764,
+            "relative_l2_p95": 0.1017615287758719,
+            "relative_l2_max": 0.14214298103013276,
+            "weighted_relative_l2_mean": 0.007851847095531779,
+            "weighted_relative_frobenius": 0.0068512795300496,
+            "weighted_mean_cosine": 0.999702408364441,
+            "max_relative_norm_change": 0.01001484036538288
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900086049689072,
+            "mean_cosine": 0.9991890832133987,
+            "p05_cosine": 0.9948215430114717,
+            "relative_l2_mean": 0.018840930858532067,
+            "relative_l2_p95": 0.10175836805142259,
+            "relative_l2_max": 0.14215957344489455,
+            "weighted_relative_l2_mean": 0.007669569439410469,
+            "weighted_relative_frobenius": 0.006848195096817759,
+            "weighted_mean_cosine": 0.9997024267715556,
+            "max_relative_norm_change": 0.009992405462840135
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.25981,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.24101915000000002,
+            "warm_p99_ms": 0.28488896999999996,
+            "samples_ms": [
+              0.231803,
+              0.311283,
+              0.240813,
+              0.235575,
+              0.227543,
+              0.228521,
+              0.228521,
+              0.227054,
+              0.227124,
+              0.233689,
+              0.231385,
+              0.229918,
+              0.230406,
+              0.228521,
+              0.230336,
+              0.22894,
+              0.228451,
+              0.227124,
+              0.243606,
+              0.229499,
+              0.228032,
+              0.227194,
+              0.228101,
+              0.227054,
+              0.228521,
+              0.228521,
+              0.227473,
+              0.228451,
+              0.228521,
+              0.227473,
+              0.228452,
+              0.228521,
+              0.228521,
+              0.22894,
+              0.226985,
+              0.240883,
+              0.22901,
+              0.227963,
+              0.228032,
+              0.227054
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 985005,
+              "unique_rows": 3896,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 122,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 122,
+              "zlib_blocks": 122,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3896
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "f5d33231e24c8f132f83b9c5008bb3677ec1e68973b17764be083a3cbbf8c302",
+            "table_sha256": "f9284dd9668c818554f06daf9c604550bc371fbcc5510513090a8419659f4547",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.11457613506354392,
+          "representatives_sha256": "19ec1b57421ee9ee3cd9ca87aea2ac4337628b44f7866c1d7f41de2cd9b7d0e2",
+          "structurally_merged_rows": 1437,
+          "backend_artifact_bytes": 986206,
+          "backend_with_key_registry_bytes": 1057140,
+          "backend_with_datrie_key_index_bytes": 1029262,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800489128113278,
+            "mean_cosine": 0.9989397183095924,
+            "p05_cosine": 0.993663425740816,
+            "relative_l2_mean": 0.02205349566786507,
+            "relative_l2_p95": 0.11278343686234345,
+            "relative_l2_max": 0.19902522582008436,
+            "weighted_relative_l2_mean": 0.008877263586252356,
+            "weighted_relative_frobenius": 0.00808873698855015,
+            "weighted_mean_cosine": 0.9996180084835264,
+            "max_relative_norm_change": 0.01001484036538288
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800460873989189,
+            "mean_cosine": 0.9989397316916933,
+            "p05_cosine": 0.9936630700639634,
+            "relative_l2_mean": 0.02190255174227501,
+            "relative_l2_p95": 0.11276128827773571,
+            "relative_l2_max": 0.19903711226739598,
+            "weighted_relative_l2_mean": 0.008696273342306349,
+            "weighted_relative_frobenius": 0.00808615720538015,
+            "weighted_mean_cosine": 0.999618026372571,
+            "max_relative_norm_change": 0.009992405462840135
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.993994,
+            "warm_p50_ms": 0.228486,
+            "warm_p95_ms": 0.23786174999999998,
+            "warm_p99_ms": 0.26060998999999996,
+            "samples_ms": [
+              0.231873,
+              0.233689,
+              0.233759,
+              0.230407,
+              0.228101,
+              0.228591,
+              0.271124,
+              0.23753,
+              0.230825,
+              0.229429,
+              0.229359,
+              0.228032,
+              0.227613,
+              0.228032,
+              0.227054,
+              0.228102,
+              0.22901,
+              0.227683,
+              0.227613,
+              0.227124,
+              0.228451,
+              0.228032,
+              0.232292,
+              0.244165,
+              0.232222,
+              0.230406,
+              0.228032,
+              0.228521,
+              0.226635,
+              0.227124,
+              0.228521,
+              0.229499,
+              0.230895,
+              0.228939,
+              0.227054,
+              0.227054,
+              0.226705,
+              0.227124,
+              0.228102,
+              0.226565
+            ],
+            "warm_rows_per_second": 2240837.5130204917
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 978338,
+              "unique_rows": 3869,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3869
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "8f0202a7fb5ec31e3b8888cd7c7c4fdbe10c3ddcf39c785ccac9558634f3a14e",
+            "table_sha256": "97d3e9c3d1f460ab967627667c11aa1c241988f4bb31da7f4c2dcb861932f020",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10647167498245835,
+          "representatives_sha256": "073ba4d3a1b4ac31faaa46a5ca0e2db48458c5f20b358f8c8591f17855fa1c88",
+          "structurally_merged_rows": 1464,
+          "backend_artifact_bytes": 979539,
+          "backend_with_key_registry_bytes": 1050473,
+          "backend_with_datrie_key_index_bytes": 1022595,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9708490360808352,
+            "mean_cosine": 0.9988203685915727,
+            "p05_cosine": 0.9932592470627866,
+            "relative_l2_mean": 0.02314940399431931,
+            "relative_l2_p95": 0.11618531979442444,
+            "relative_l2_max": 0.2411893391599019,
+            "weighted_relative_l2_mean": 0.009302414627571623,
+            "weighted_relative_frobenius": 0.009069396417274616,
+            "weighted_mean_cosine": 0.9995706486644645,
+            "max_relative_norm_change": 0.01001484036538288
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.970842172012824,
+            "mean_cosine": 0.9988203783840274,
+            "p05_cosine": 0.9932570907999037,
+            "relative_l2_mean": 0.022999513106467594,
+            "relative_l2_p95": 0.11618595519489394,
+            "relative_l2_max": 0.24122132562691045,
+            "weighted_relative_l2_mean": 0.009121825212211722,
+            "weighted_relative_frobenius": 0.009067214030164977,
+            "weighted_mean_cosine": 0.9995706644779443,
+            "max_relative_norm_change": 0.009992405462840135
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.23376,
+            "warm_p50_ms": 0.2301625,
+            "warm_p95_ms": 0.23755879999999996,
+            "warm_p99_ms": 0.2555154,
+            "samples_ms": [
+              0.237042,
+              0.230896,
+              0.228521,
+              0.230895,
+              0.230337,
+              0.229918,
+              0.229987,
+              0.227613,
+              0.229498,
+              0.22908,
+              0.228102,
+              0.228591,
+              0.229009,
+              0.22908,
+              0.228102,
+              0.22908,
+              0.247378,
+              0.236483,
+              0.23327,
+              0.230407,
+              0.231315,
+              0.22901,
+              0.229429,
+              0.227962,
+              0.227543,
+              0.230895,
+              0.229917,
+              0.229988,
+              0.22901,
+              0.236622,
+              0.230477,
+              0.231804,
+              0.231874,
+              0.260718,
+              0.232781,
+              0.230337,
+              0.2332,
+              0.230896,
+              0.230896,
+              0.229987
+            ],
+            "warm_rows_per_second": 2224515.28811166
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 977146,
+              "unique_rows": 3864,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3864
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "3396955427481df83fa6aa3f893710aa3a49e20860d1219929761de5f9a4e75a",
+            "table_sha256": "39362b7ec3317f68b01ca1a14ade56e072e51dd6445e5d2702775e4432571e14",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12416584091261029,
+          "representatives_sha256": "25bf0bd565e884f16ce8cbf05f9fff8a630df54e9140a7ee68b4d5f5517d239b",
+          "structurally_merged_rows": 1469,
+          "backend_artifact_bytes": 978347,
+          "backend_with_key_registry_bytes": 1049281,
+          "backend_with_datrie_key_index_bytes": 1021403,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.950434353491954,
+            "mean_cosine": 0.9987871357522384,
+            "p05_cosine": 0.9931252291914241,
+            "relative_l2_mean": 0.02339745145168532,
+            "relative_l2_p95": 0.11726686621678044,
+            "relative_l2_max": 0.3134766420480686,
+            "weighted_relative_l2_mean": 0.009373011120801047,
+            "weighted_relative_frobenius": 0.009194923000522387,
+            "weighted_mean_cosine": 0.999561190305399,
+            "max_relative_norm_change": 0.01001484036538288
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9504358435378185,
+            "mean_cosine": 0.9987871427722179,
+            "p05_cosine": 0.9931260463402736,
+            "relative_l2_mean": 0.023247770374172798,
+            "relative_l2_p95": 0.11729238713488532,
+            "relative_l2_max": 0.31347037234704306,
+            "weighted_relative_l2_mean": 0.009192481419313435,
+            "weighted_relative_frobenius": 0.009192769743581646,
+            "weighted_mean_cosine": 0.9995612053298076,
+            "max_relative_norm_change": 0.009992405462840135
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.125436,
+            "warm_p50_ms": 0.228765,
+            "warm_p95_ms": 0.23528159999999995,
+            "warm_p99_ms": 0.25599066000000004,
+            "samples_ms": [
+              0.23362,
+              0.229499,
+              0.229429,
+              0.228451,
+              0.22894,
+              0.229918,
+              0.228521,
+              0.229987,
+              0.228032,
+              0.228451,
+              0.229499,
+              0.229079,
+              0.261765,
+              0.234667,
+              0.230407,
+              0.229499,
+              0.22852,
+              0.22901,
+              0.228102,
+              0.227543,
+              0.229429,
+              0.22901,
+              0.228521,
+              0.228032,
+              0.228451,
+              0.228521,
+              0.228521,
+              0.22852,
+              0.229918,
+              0.227055,
+              0.246959,
+              0.22901,
+              0.22908,
+              0.22859,
+              0.227613,
+              0.228102,
+              0.229009,
+              0.228102,
+              0.228032,
+              0.228521
+            ],
+            "warm_rows_per_second": 2238104.605162503
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 974750,
+              "unique_rows": 3854,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3854
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "13e42c39bd70190e08245f5ac4a7783b4b009c202e190736a4525352897caabc",
+            "table_sha256": "739154e18f71b39e7ed249adea90d7312072f700f1d253c3f2e77f735021dce8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10525943897664547,
+          "representatives_sha256": "3d8c5e73c20f030e595ce9bf416febfd1467bafe0a85b0aaf71a2d9d8dba784b",
+          "structurally_merged_rows": 1479,
+          "backend_artifact_bytes": 975951,
+          "backend_with_key_registry_bytes": 1046885,
+          "backend_with_datrie_key_index_bytes": 1019007,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9057759604519998,
+            "mean_cosine": 0.9986493500187473,
+            "p05_cosine": 0.9929141331823574,
+            "relative_l2_mean": 0.024113234275497934,
+            "relative_l2_p95": 0.11913783578599228,
+            "relative_l2_max": 0.4327194967056403,
+            "weighted_relative_l2_mean": 0.009825166011066526,
+            "weighted_relative_frobenius": 0.011868171826604816,
+            "weighted_mean_cosine": 0.9994731241847539,
+            "max_relative_norm_change": 0.01001484036538288
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9057849138351362,
+            "mean_cosine": 0.998649356363167,
+            "p05_cosine": 0.9929129395400632,
+            "relative_l2_mean": 0.023963917739104442,
+            "relative_l2_p95": 0.1191314173908099,
+            "relative_l2_max": 0.4326941991008237,
+            "weighted_relative_l2_mean": 0.00964486284567928,
+            "weighted_relative_frobenius": 0.011866546570363908,
+            "weighted_mean_cosine": 0.9994731399294087,
+            "max_relative_norm_change": 0.009992405462840135
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.143944,
+            "warm_p50_ms": 0.22845149999999997,
+            "warm_p95_ms": 0.23314149999999997,
+            "warm_p99_ms": 0.24275075,
+            "samples_ms": [
+              0.231803,
+              0.229498,
+              0.22901,
+              0.229429,
+              0.227473,
+              0.228033,
+              0.243677,
+              0.229918,
+              0.228032,
+              0.228521,
+              0.22894,
+              0.227124,
+              0.227543,
+              0.227613,
+              0.228521,
+              0.228591,
+              0.22901,
+              0.227613,
+              0.228102,
+              0.226565,
+              0.227962,
+              0.227124,
+              0.226635,
+              0.228102,
+              0.241302,
+              0.228521,
+              0.22887,
+              0.228451,
+              0.227962,
+              0.232363,
+              0.230896,
+              0.232712,
+              0.22901,
+              0.227543,
+              0.228452,
+              0.22894,
+              0.227054,
+              0.228451,
+              0.227962,
+              0.228032
+            ],
+            "warm_rows_per_second": 2241175.9169889456
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 703956,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ff95d9bd81bb9e89be385208a5831f5c37605223682f339f292564a62faacc42",
+            "table_sha256": "3b63b97be01c401d71fc1bf035e8bf67562f67ea700ec0b3e088fb0cf12870ee",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.016697739949449897,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 704803,
+          "backend_with_key_registry_bytes": 775737,
+          "backend_with_datrie_key_index_bytes": 747859,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999472196271418,
+            "mean_cosine": 0.9999785442031286,
+            "p05_cosine": 0.9999672497233414,
+            "relative_l2_mean": 0.006517774800990935,
+            "relative_l2_p95": 0.008115772137778587,
+            "relative_l2_max": 0.010321824347442474,
+            "weighted_relative_l2_mean": 0.0064498560165530084,
+            "weighted_relative_frobenius": 0.006476714793365053,
+            "weighted_mean_cosine": 0.9999790489880547,
+            "max_relative_norm_change": 0.002208400347090758
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.324622,
+            "warm_p50_ms": 0.12253649999999999,
+            "warm_p95_ms": 0.12406324999999999,
+            "warm_p99_ms": 0.14719789999999996,
+            "samples_ms": [
+              0.123479,
+              0.122152,
+              0.120686,
+              0.122083,
+              0.122501,
+              0.123409,
+              0.122571,
+              0.122572,
+              0.122641,
+              0.122571,
+              0.123969,
+              0.120546,
+              0.12299,
+              0.160844,
+              0.125854,
+              0.122082,
+              0.122991,
+              0.122991,
+              0.122502,
+              0.121664,
+              0.122991,
+              0.120686,
+              0.121105,
+              0.121105,
+              0.122502,
+              0.121593,
+              0.121105,
+              0.121104,
+              0.12348,
+              0.122502,
+              0.121594,
+              0.122571,
+              0.122572,
+              0.122083,
+              0.123479,
+              0.122501,
+              0.121524,
+              0.122991,
+              0.122571,
+              0.12306
+            ],
+            "warm_rows_per_second": 4178346.859915209
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 710740,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ff95d9bd81bb9e89be385208a5831f5c37605223682f339f292564a62faacc42",
+            "table_sha256": "c912a7850306da43eeb6fc979dda6b777254023fc7c02b40c915fbcbe5f843ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.09135067299939692,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 711984,
+          "backend_with_key_registry_bytes": 782918,
+          "backend_with_datrie_key_index_bytes": 755040,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999472196271418,
+            "mean_cosine": 0.9999785442031286,
+            "p05_cosine": 0.9999672497233414,
+            "relative_l2_mean": 0.006517774800990935,
+            "relative_l2_p95": 0.008115772137778587,
+            "relative_l2_max": 0.010321824347442474,
+            "weighted_relative_l2_mean": 0.0064498560165530084,
+            "weighted_relative_frobenius": 0.006476714793365053,
+            "weighted_mean_cosine": 0.9999790489880547,
+            "max_relative_norm_change": 0.002208400347090758
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.465923,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13570454999999998,
+            "warm_p99_ms": 0.15485767999999997,
+            "samples_ms": [
+              0.135701,
+              0.132489,
+              0.133396,
+              0.133467,
+              0.132,
+              0.132489,
+              0.132489,
+              0.132,
+              0.132978,
+              0.132489,
+              0.132489,
+              0.130114,
+              0.130533,
+              0.16706,
+              0.135772,
+              0.132978,
+              0.131581,
+              0.132489,
+              0.132,
+              0.132978,
+              0.130114,
+              0.129625,
+              0.131511,
+              0.132,
+              0.131022,
+              0.133466,
+              0.132489,
+              0.132489,
+              0.132,
+              0.131512,
+              0.130115,
+              0.132489,
+              0.131092,
+              0.131022,
+              0.130114,
+              0.132489,
+              0.130044,
+              0.131092,
+              0.131092,
+              0.129626
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 710740,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ff95d9bd81bb9e89be385208a5831f5c37605223682f339f292564a62faacc42",
+            "table_sha256": "c912a7850306da43eeb6fc979dda6b777254023fc7c02b40c915fbcbe5f843ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0982857090421021,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 711983,
+          "backend_with_key_registry_bytes": 782917,
+          "backend_with_datrie_key_index_bytes": 755039,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999472196271418,
+            "mean_cosine": 0.9999785442031286,
+            "p05_cosine": 0.9999672497233414,
+            "relative_l2_mean": 0.006517774800990935,
+            "relative_l2_p95": 0.008115772137778587,
+            "relative_l2_max": 0.010321824347442474,
+            "weighted_relative_l2_mean": 0.0064498560165530084,
+            "weighted_relative_frobenius": 0.006476714793365053,
+            "weighted_mean_cosine": 0.9999790489880547,
+            "max_relative_norm_change": 0.002208400347090758
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.461244,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.1349094,
+            "warm_p99_ms": 0.14126749,
+            "samples_ms": [
+              0.134793,
+              0.134305,
+              0.132489,
+              0.132,
+              0.132489,
+              0.132419,
+              0.132489,
+              0.135772,
+              0.134864,
+              0.132419,
+              0.131512,
+              0.130604,
+              0.131511,
+              0.144781,
+              0.134235,
+              0.132978,
+              0.134305,
+              0.132001,
+              0.131023,
+              0.131581,
+              0.132,
+              0.132908,
+              0.132,
+              0.132,
+              0.132,
+              0.131023,
+              0.129626,
+              0.130603,
+              0.132001,
+              0.132001,
+              0.131022,
+              0.131022,
+              0.130114,
+              0.129625,
+              0.132908,
+              0.133466,
+              0.131511,
+              0.131022,
+              0.131092,
+              0.130114
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 710740,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "ff95d9bd81bb9e89be385208a5831f5c37605223682f339f292564a62faacc42",
+            "table_sha256": "c912a7850306da43eeb6fc979dda6b777254023fc7c02b40c915fbcbe5f843ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0779950509313494,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 711983,
+          "backend_with_key_registry_bytes": 782917,
+          "backend_with_datrie_key_index_bytes": 755039,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999472196271418,
+            "mean_cosine": 0.9999785442031286,
+            "p05_cosine": 0.9999672497233414,
+            "relative_l2_mean": 0.006517774800990935,
+            "relative_l2_p95": 0.008115772137778587,
+            "relative_l2_max": 0.010321824347442474,
+            "weighted_relative_l2_mean": 0.0064498560165530084,
+            "weighted_relative_frobenius": 0.006476714793365053,
+            "weighted_mean_cosine": 0.9999790489880547,
+            "max_relative_norm_change": 0.002208400347090758
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.493372,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.13299895,
+            "warm_p99_ms": 0.14238657,
+            "samples_ms": [
+              0.132978,
+              0.132,
+              0.131511,
+              0.132978,
+              0.131512,
+              0.130603,
+              0.130114,
+              0.130184,
+              0.129695,
+              0.132,
+              0.131022,
+              0.130534,
+              0.128648,
+              0.132,
+              0.131092,
+              0.132908,
+              0.131511,
+              0.132489,
+              0.132,
+              0.132978,
+              0.132,
+              0.131511,
+              0.132,
+              0.131023,
+              0.148134,
+              0.131093,
+              0.130534,
+              0.133397,
+              0.132,
+              0.131022,
+              0.131512,
+              0.132489,
+              0.131511,
+              0.131511,
+              0.130114,
+              0.131092,
+              0.132,
+              0.131581,
+              0.130534,
+              0.130603
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 548987,
+              "unique_rows": 4008,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 65,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 65,
+              "zlib_blocks": 65,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 4008
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "a62056b83a73807b7f61d0d279d775f45e8ddf42470fec39f10ca2260297ab7a",
+            "table_sha256": "ed8808852ba87ad1d586536fdc3595716af0f270819ebd31949162460d023d0c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08318845299072564,
+          "representatives_sha256": "c45646621d3662f6bdd6db39b96d8782a760803e9976afc20c6d1e9619e7d6dc",
+          "structurally_merged_rows": 1325,
+          "backend_artifact_bytes": 550228,
+          "backend_with_key_registry_bytes": 621162,
+          "backend_with_datrie_key_index_bytes": 593284,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9899460254280686,
+            "mean_cosine": 0.9991811235787342,
+            "p05_cosine": 0.9948715931227619,
+            "relative_l2_mean": 0.023595053063924704,
+            "relative_l2_p95": 0.10137669486868771,
+            "relative_l2_max": 0.14188875915362323,
+            "weighted_relative_l2_mean": 0.013356548138067683,
+            "weighted_relative_frobenius": 0.009423937975726222,
+            "weighted_mean_cosine": 0.999684497516677,
+            "max_relative_norm_change": 0.011193257051772623
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900452817001179,
+            "mean_cosine": 0.9991922911278868,
+            "p05_cosine": 0.9948825321900114,
+            "relative_l2_mean": 0.018784309769533047,
+            "relative_l2_p95": 0.10116678712301178,
+            "relative_l2_max": 0.14080572574517558,
+            "weighted_relative_l2_mean": 0.007722098091802112,
+            "weighted_relative_frobenius": 0.006974880559954164,
+            "weighted_mean_cosine": 0.9997005177842563,
+            "max_relative_norm_change": 0.01006708671648114
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.365434,
+            "warm_p50_ms": 0.1308125,
+            "warm_p95_ms": 0.13349129999999998,
+            "warm_p99_ms": 0.14111948,
+            "samples_ms": [
+              0.135283,
+              0.132978,
+              0.132908,
+              0.131511,
+              0.132978,
+              0.132419,
+              0.131511,
+              0.129625,
+              0.132489,
+              0.130044,
+              0.130603,
+              0.130603,
+              0.130603,
+              0.131511,
+              0.131092,
+              0.130603,
+              0.130115,
+              0.130115,
+              0.131581,
+              0.130045,
+              0.131022,
+              0.130533,
+              0.132,
+              0.130603,
+              0.130603,
+              0.144851,
+              0.130603,
+              0.131022,
+              0.130603,
+              0.131022,
+              0.131512,
+              0.133397,
+              0.131511,
+              0.130114,
+              0.130044,
+              0.130044,
+              0.132,
+              0.130603,
+              0.129206,
+              0.129206
+            ],
+            "warm_rows_per_second": 3913999.0444338275
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 535945,
+              "unique_rows": 3905,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3905
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "fe9a13a24d7badd950819bc72cd81e968580858204fc855ec74d3b0643be5042",
+            "table_sha256": "e9f5c4701824eb9c555e8e1a617353fc3d02e59e8ebd1761a89695834c1a4012",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06120644696056843,
+          "representatives_sha256": "e34ed59fb3228c3c30a0bddf1d6d5bcaf09407ee494b8ba3e8d0fe58994e2db9",
+          "structurally_merged_rows": 1428,
+          "backend_artifact_bytes": 537186,
+          "backend_with_key_registry_bytes": 608120,
+          "backend_with_datrie_key_index_bytes": 580242,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9802774097437427,
+            "mean_cosine": 0.998929785427547,
+            "p05_cosine": 0.9937296122853513,
+            "relative_l2_mean": 0.026576276458257365,
+            "relative_l2_p95": 0.11231761955071509,
+            "relative_l2_max": 0.1978354117400544,
+            "weighted_relative_l2_mean": 0.014354728414426603,
+            "weighted_relative_frobenius": 0.010362495928818662,
+            "weighted_mean_cosine": 0.9995995000114486,
+            "max_relative_norm_change": 0.011193257051772623
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800731413504202,
+            "mean_cosine": 0.998940075547549,
+            "p05_cosine": 0.9937107115725136,
+            "relative_l2_mean": 0.021892984914000747,
+            "relative_l2_p95": 0.11232107990369113,
+            "relative_l2_max": 0.19888994022366926,
+            "weighted_relative_l2_mean": 0.008762672231207715,
+            "weighted_relative_frobenius": 0.008200859341694282,
+            "weighted_mean_cosine": 0.9996152353969843,
+            "max_relative_norm_change": 0.010083280214336047
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.281764,
+            "warm_p50_ms": 0.1315465,
+            "warm_p95_ms": 0.13599199999999997,
+            "warm_p99_ms": 0.16018965,
+            "samples_ms": [
+              0.134864,
+              0.132,
+              0.131511,
+              0.130603,
+              0.148133,
+              0.132,
+              0.132,
+              0.132,
+              0.132001,
+              0.132908,
+              0.131022,
+              0.130533,
+              0.130044,
+              0.130603,
+              0.130673,
+              0.132978,
+              0.133466,
+              0.132,
+              0.132908,
+              0.132908,
+              0.130184,
+              0.131092,
+              0.130603,
+              0.135353,
+              0.132978,
+              0.130603,
+              0.132489,
+              0.131093,
+              0.130534,
+              0.131511,
+              0.132489,
+              0.131511,
+              0.130603,
+              0.131092,
+              0.167898,
+              0.131511,
+              0.131512,
+              0.131581,
+              0.131023,
+              0.132
+            ],
+            "warm_rows_per_second": 3892159.8066083095
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 532479,
+              "unique_rows": 3877,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3877
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "279d44baa6b1e24848dbbae5502d1b2a3e190389e64a41ad0f8db09f357f8b85",
+            "table_sha256": "b86ef26f935a4f709ff8c2d5ced04e0822f3631bdd5a6c9c3b17e5fb2fbdd601",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06654365290887654,
+          "representatives_sha256": "7e670f5f6be473ee772c7b5444a1f4414f57b9366d57a9d047dd783aac94e016",
+          "structurally_merged_rows": 1456,
+          "backend_artifact_bytes": 533720,
+          "backend_with_key_registry_bytes": 604654,
+          "backend_with_datrie_key_index_bytes": 576776,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9708558855923936,
+            "mean_cosine": 0.9988065929090025,
+            "p05_cosine": 0.9932626568383942,
+            "relative_l2_mean": 0.027676963177214083,
+            "relative_l2_p95": 0.11607854092455877,
+            "relative_l2_max": 0.2411916582064447,
+            "weighted_relative_l2_mean": 0.014778498075646365,
+            "weighted_relative_frobenius": 0.011146495163277887,
+            "weighted_mean_cosine": 0.9995510349733676,
+            "max_relative_norm_change": 0.011193257051772623
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9707988177143576,
+            "mean_cosine": 0.9988167892682104,
+            "p05_cosine": 0.9932631200825917,
+            "relative_l2_mean": 0.02302821874678023,
+            "relative_l2_p95": 0.11619886723268123,
+            "relative_l2_max": 0.24136072450226767,
+            "weighted_relative_l2_mean": 0.009199261212029994,
+            "weighted_relative_frobenius": 0.009171906564283882,
+            "weighted_mean_cosine": 0.9995667272156469,
+            "max_relative_norm_change": 0.010083280214336047
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.068748,
+            "warm_p50_ms": 0.131023,
+            "warm_p95_ms": 0.13754865,
+            "warm_p99_ms": 0.16122598999999999,
+            "samples_ms": [
+              0.133886,
+              0.144781,
+              0.133816,
+              0.132419,
+              0.130604,
+              0.132489,
+              0.132,
+              0.131022,
+              0.133397,
+              0.130114,
+              0.131022,
+              0.129626,
+              0.130604,
+              0.131023,
+              0.131023,
+              0.131511,
+              0.130603,
+              0.132,
+              0.132908,
+              0.131023,
+              0.131022,
+              0.131092,
+              0.130603,
+              0.130184,
+              0.130115,
+              0.131511,
+              0.131022,
+              0.132489,
+              0.135771,
+              0.137168,
+              0.13626,
+              0.17174,
+              0.133397,
+              0.132419,
+              0.130603,
+              0.131022,
+              0.129625,
+              0.130114,
+              0.131022,
+              0.131022
+            ],
+            "warm_rows_per_second": 3907710.8599253567
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 531853,
+              "unique_rows": 3872,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3872
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "63fba38a625fe4a0ddda6f97aff2446fd5aa274436d4a55d9249067c23b8dffd",
+            "table_sha256": "641fbc9933bb3432d857d5498e5d5e464fd2d90461f22178ba392b429427b7d1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07724418584257364,
+          "representatives_sha256": "06ecfc12beba03cd91a9249a99a4a38025424fd923a12c9a7f29649ce2ab4d0b",
+          "structurally_merged_rows": 1461,
+          "backend_artifact_bytes": 533094,
+          "backend_with_key_registry_bytes": 604028,
+          "backend_with_datrie_key_index_bytes": 576150,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9645468363051497,
+            "mean_cosine": 0.9987760377805035,
+            "p05_cosine": 0.9931920311536553,
+            "relative_l2_mean": 0.027910005840439022,
+            "relative_l2_p95": 0.11689623701885093,
+            "relative_l2_max": 0.26511495929110795,
+            "weighted_relative_l2_mean": 0.014844824072176337,
+            "weighted_relative_frobenius": 0.011151053798317613,
+            "weighted_mean_cosine": 0.9995423387144133,
+            "max_relative_norm_change": 0.011193257051772623
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9645029199086544,
+            "mean_cosine": 0.9987861966537901,
+            "p05_cosine": 0.9932018647006915,
+            "relative_l2_mean": 0.0232673906702478,
+            "relative_l2_p95": 0.11682543464816218,
+            "relative_l2_max": 0.26537271472670454,
+            "weighted_relative_l2_mean": 0.009267331650062473,
+            "weighted_relative_frobenius": 0.009177450374893622,
+            "weighted_mean_cosine": 0.9995580202878689,
+            "max_relative_norm_change": 0.010083280214336047
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.081598,
+            "warm_p50_ms": 0.133956,
+            "warm_p95_ms": 0.15709494999999998,
+            "warm_p99_ms": 0.16217901999999998,
+            "samples_ms": [
+              0.140521,
+              0.135771,
+              0.146667,
+              0.138635,
+              0.135771,
+              0.134444,
+              0.134864,
+              0.153721,
+              0.157493,
+              0.135353,
+              0.134305,
+              0.132489,
+              0.133397,
+              0.134445,
+              0.132419,
+              0.132489,
+              0.133816,
+              0.134445,
+              0.157074,
+              0.13633,
+              0.133956,
+              0.138146,
+              0.131023,
+              0.13249,
+              0.131511,
+              0.133956,
+              0.131023,
+              0.132489,
+              0.130044,
+              0.137587,
+              0.131511,
+              0.131092,
+              0.131581,
+              0.131022,
+              0.131092,
+              0.132001,
+              0.165175,
+              0.13633,
+              0.132489,
+              0.132978
+            ],
+            "warm_rows_per_second": 3822150.5568992808
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 530590,
+              "unique_rows": 3862,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3862
+            },
+            "source_float32_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3",
+            "decoded_float32_sha256": "1dfd1c63f4e34ea36b814ccaaebc1d91a590a9ea1cd59b1186b8c098c20a2b5b",
+            "table_sha256": "983ab5dbd887857491f325d5904539399a4e1036df5c694c132f6d5f4e6dad90",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06423777109012008,
+          "representatives_sha256": "d58b671fc633ea2423d8b8262426ceb2cd1c7cdd442e0870782cfe892ae3c292",
+          "structurally_merged_rows": 1471,
+          "backend_artifact_bytes": 531831,
+          "backend_with_key_registry_bytes": 602765,
+          "backend_with_datrie_key_index_bytes": 574887,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9056773953279651,
+            "mean_cosine": 0.9986380550398255,
+            "p05_cosine": 0.992963940004652,
+            "relative_l2_mean": 0.02861425529997481,
+            "relative_l2_p95": 0.11860347312203266,
+            "relative_l2_max": 0.43300731849080465,
+            "weighted_relative_l2_mean": 0.015290162033414687,
+            "weighted_relative_frobenius": 0.013444069472239167,
+            "weighted_mean_cosine": 0.9994541553710345,
+            "max_relative_norm_change": 0.011193257051772623
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9059670556494595,
+            "mean_cosine": 0.998648271260613,
+            "p05_cosine": 0.9929359343583033,
+            "relative_l2_mean": 0.023984002914871804,
+            "relative_l2_p95": 0.11877170468980819,
+            "relative_l2_max": 0.4324839597442224,
+            "weighted_relative_l2_mean": 0.009719963455562435,
+            "weighted_relative_frobenius": 0.011857271754713355,
+            "weighted_mean_cosine": 0.9994698880712519,
+            "max_relative_norm_change": 0.010083280214336047
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.1909,
+            "warm_p50_ms": 0.13297750000000003,
+            "warm_p95_ms": 0.15240084999999998,
+            "warm_p99_ms": 0.17796869999999998,
+            "samples_ms": [
+              0.137238,
+              0.133397,
+              0.139054,
+              0.135842,
+              0.134445,
+              0.133816,
+              0.132978,
+              0.132978,
+              0.132909,
+              0.132978,
+              0.151905,
+              0.132908,
+              0.188292,
+              0.161822,
+              0.132977,
+              0.131022,
+              0.132,
+              0.132489,
+              0.131511,
+              0.134375,
+              0.134305,
+              0.133397,
+              0.151416,
+              0.136191,
+              0.130044,
+              0.132,
+              0.131093,
+              0.131023,
+              0.131093,
+              0.130045,
+              0.131512,
+              0.130603,
+              0.133886,
+              0.134375,
+              0.133467,
+              0.132489,
+              0.130184,
+              0.130604,
+              0.130603,
+              0.132489
+            ],
+            "warm_rows_per_second": 3850275.4225338865
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "90831a04809658c42b56b37046b1ad7b6035c1d55bb5c3ab2f777c5ca66145b3"
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "rows": 5333,
+      "dim": 128,
+      "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+      "source_float32_bytes": 2730496,
+      "key_registry_bytes": 70934,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 43056,
+      "query_rows": 512,
+      "query_ids_sha256": "87677d489e681e6c0a39b8460231cf990090e3318abb13c912a002c527931d01",
+      "frequency_trace_sha256": "0e7a36c623f2fc5cc1e4fd51bc27b7b98d60f0c1b31a56fb66253e951084f56a",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 2730496,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "table_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.013780047884210944,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2731299,
+          "backend_with_key_registry_bytes": 2802233,
+          "backend_with_datrie_key_index_bytes": 2774355,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.40927,
+            "warm_p50_ms": 0.0619845,
+            "warm_p95_ms": 0.0725193,
+            "warm_p99_ms": 0.07776177,
+            "samples_ms": [
+              0.064324,
+              0.062019,
+              0.062927,
+              0.06153,
+              0.06146,
+              0.062019,
+              0.062019,
+              0.06195,
+              0.060553,
+              0.060483,
+              0.061531,
+              0.062438,
+              0.060063,
+              0.06146,
+              0.06153,
+              0.061949,
+              0.062857,
+              0.062438,
+              0.062019,
+              0.062508,
+              0.061041,
+              0.061879,
+              0.06146,
+              0.062508,
+              0.06202,
+              0.062019,
+              0.060972,
+              0.060622,
+              0.062019,
+              0.074311,
+              0.079968,
+              0.072425,
+              0.062508,
+              0.062019,
+              0.060971,
+              0.061879,
+              0.060622,
+              0.060971,
+              0.06188,
+              0.062019
+            ],
+            "warm_rows_per_second": 8260129.548516161
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607447,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 303,
+              "xor_blocks": 31,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "table_sha256": "cad6c1e0a0b642f6988be6946fa27bddec2ec19f3bd843aea6e233b9f92e51c6",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23365640896372497,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608651,
+          "backend_with_key_registry_bytes": 2679585,
+          "backend_with_datrie_key_index_bytes": 2651707,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.506316,
+            "warm_p50_ms": 0.0704,
+            "warm_p95_ms": 0.07869759999999996,
+            "warm_p99_ms": 0.09331459,
+            "samples_ms": [
+              0.075289,
+              0.078083,
+              0.075708,
+              0.072844,
+              0.090375,
+              0.074312,
+              0.073403,
+              0.073823,
+              0.095194,
+              0.07473,
+              0.072844,
+              0.073822,
+              0.068026,
+              0.07005,
+              0.068654,
+              0.073822,
+              0.070959,
+              0.07047,
+              0.0704,
+              0.0704,
+              0.068724,
+              0.069074,
+              0.07047,
+              0.070539,
+              0.07054,
+              0.069073,
+              0.069074,
+              0.069632,
+              0.070051,
+              0.069912,
+              0.069981,
+              0.070051,
+              0.069562,
+              0.068514,
+              0.069632,
+              0.069493,
+              0.069981,
+              0.07005,
+              0.068654,
+              0.07047
+            ],
+            "warm_rows_per_second": 7272727.2727272725
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607447,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 303,
+              "xor_blocks": 31,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "table_sha256": "cad6c1e0a0b642f6988be6946fa27bddec2ec19f3bd843aea6e233b9f92e51c6",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2612808980047703,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608650,
+          "backend_with_key_registry_bytes": 2679584,
+          "backend_with_datrie_key_index_bytes": 2651706,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.512043,
+            "warm_p50_ms": 0.0705395,
+            "warm_p95_ms": 0.08014344999999996,
+            "warm_p99_ms": 0.0982451,
+            "samples_ms": [
+              0.078991,
+              0.07948,
+              0.076616,
+              0.092749,
+              0.076615,
+              0.074311,
+              0.073822,
+              0.073822,
+              0.07473,
+              0.073333,
+              0.073333,
+              0.069562,
+              0.069073,
+              0.070121,
+              0.070051,
+              0.070889,
+              0.101759,
+              0.071029,
+              0.071028,
+              0.07061,
+              0.070469,
+              0.069981,
+              0.069143,
+              0.071029,
+              0.069562,
+              0.069492,
+              0.070889,
+              0.069562,
+              0.069073,
+              0.070958,
+              0.069981,
+              0.070401,
+              0.069073,
+              0.069562,
+              0.071378,
+              0.069981,
+              0.069562,
+              0.070051,
+              0.069981,
+              0.069493
+            ],
+            "warm_rows_per_second": 7258344.615428234
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607447,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 303,
+              "xor_blocks": 31,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "table_sha256": "cad6c1e0a0b642f6988be6946fa27bddec2ec19f3bd843aea6e233b9f92e51c6",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2417168691754341,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608650,
+          "backend_with_key_registry_bytes": 2679584,
+          "backend_with_datrie_key_index_bytes": 2651706,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.496957,
+            "warm_p50_ms": 0.0702605,
+            "warm_p95_ms": 0.07680025,
+            "warm_p99_ms": 0.09978062999999998,
+            "samples_ms": [
+              0.07899,
+              0.076685,
+              0.072496,
+              0.071447,
+              0.072356,
+              0.072914,
+              0.072426,
+              0.071028,
+              0.113073,
+              0.07054,
+              0.071936,
+              0.071937,
+              0.071029,
+              0.069981,
+              0.070889,
+              0.071378,
+              0.070889,
+              0.069562,
+              0.069632,
+              0.069562,
+              0.07047,
+              0.069074,
+              0.070889,
+              0.070958,
+              0.069143,
+              0.069981,
+              0.069073,
+              0.069143,
+              0.069073,
+              0.069981,
+              0.069981,
+              0.07012,
+              0.070121,
+              0.069981,
+              0.070051,
+              0.069143,
+              0.069074,
+              0.0704,
+              0.069981,
+              0.070051
+            ],
+            "warm_rows_per_second": 7287167.042648429
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1956893,
+              "unique_rows": 3975,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 249,
+              "zlib_blocks": 249,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3975
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "bcbff57cdbbcae9108a7f5ce95eacb8f52057ba4a29da04bbeaac79c1304fc66",
+            "table_sha256": "6590a2eea087ca111e3a502e1d26ea0d6b2928cfdd2bea9973afe361499d8407",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18209400493651628,
+          "representatives_sha256": "6a868016e073c8843b96d23a54b5040cd43bd7de8fd10a4ef0fd77fb6d5356f3",
+          "structurally_merged_rows": 1358,
+          "backend_artifact_bytes": 1958095,
+          "backend_with_key_registry_bytes": 2029029,
+          "backend_with_datrie_key_index_bytes": 2001151,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900498274896388,
+            "mean_cosine": 0.9991649326466401,
+            "p05_cosine": 0.9946380657924886,
+            "relative_l2_mean": 0.01921774489139315,
+            "relative_l2_p95": 0.10370633425993789,
+            "relative_l2_max": 0.14087181586808722,
+            "weighted_relative_l2_mean": 0.007669195302930095,
+            "weighted_relative_frobenius": 0.006743679010149183,
+            "weighted_mean_cosine": 0.9997009272174809,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900498274896388,
+            "mean_cosine": 0.9991649326466401,
+            "p05_cosine": 0.9946380657924886,
+            "relative_l2_mean": 0.01921774489139315,
+            "relative_l2_p95": 0.10370633425993789,
+            "relative_l2_max": 0.14087181586808722,
+            "weighted_relative_l2_mean": 0.007669195302930095,
+            "weighted_relative_frobenius": 0.006743679010149183,
+            "weighted_mean_cosine": 0.9997009272174809,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.219559,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.0744507,
+            "warm_p99_ms": 0.08089676,
+            "samples_ms": [
+              0.077105,
+              0.074242,
+              0.074311,
+              0.074311,
+              0.072845,
+              0.073334,
+              0.071867,
+              0.071867,
+              0.072355,
+              0.070051,
+              0.07005,
+              0.069562,
+              0.069492,
+              0.083321,
+              0.070958,
+              0.069981,
+              0.070958,
+              0.069911,
+              0.069562,
+              0.070121,
+              0.069981,
+              0.074311,
+              0.069632,
+              0.069003,
+              0.070051,
+              0.070051,
+              0.07047,
+              0.069492,
+              0.069073,
+              0.069562,
+              0.069492,
+              0.069073,
+              0.070609,
+              0.069632,
+              0.069003,
+              0.069142,
+              0.069562,
+              0.07047,
+              0.069073,
+              0.071518
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1915441,
+              "unique_rows": 3889,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 244,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 243,
+              "zlib_blocks": 243,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3889
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "99a85de2ff15a843787c443e90b9c1dd25d61a0acd43c2878fa12520da63e324",
+            "table_sha256": "c479ac14cfa94eedb8c7789490d50097e48391f3f7556aedfe8b721a8677549b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1829489329829812,
+          "representatives_sha256": "ffe6744fb8805a4bf8e5b3fd5ab7e84ef8c0d556dc0063e801ba1ec429934754",
+          "structurally_merged_rows": 1444,
+          "backend_artifact_bytes": 1916643,
+          "backend_with_key_registry_bytes": 1987577,
+          "backend_with_datrie_key_index_bytes": 1959699,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800443686538259,
+            "mean_cosine": 0.9989493697934625,
+            "p05_cosine": 0.9936464642843283,
+            "relative_l2_mean": 0.021843835841248167,
+            "relative_l2_p95": 0.11269904523450791,
+            "relative_l2_max": 0.19941118699057925,
+            "weighted_relative_l2_mean": 0.008671316985251821,
+            "weighted_relative_frobenius": 0.009987027162445301,
+            "weighted_mean_cosine": 0.9996186797240005,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800443686538259,
+            "mean_cosine": 0.9989493697934625,
+            "p05_cosine": 0.9936464642843283,
+            "relative_l2_mean": 0.021843835841248167,
+            "relative_l2_p95": 0.11269904523450791,
+            "relative_l2_max": 0.19941118699057925,
+            "weighted_relative_l2_mean": 0.008671316985251821,
+            "weighted_relative_frobenius": 0.009987027162445301,
+            "weighted_mean_cosine": 0.9996186797240005,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.255946,
+            "warm_p50_ms": 0.07043550000000001,
+            "warm_p95_ms": 0.07389535,
+            "warm_p99_ms": 0.09339562999999998,
+            "samples_ms": [
+              0.075289,
+              0.073822,
+              0.073822,
+              0.072774,
+              0.072356,
+              0.072915,
+              0.070959,
+              0.073333,
+              0.070121,
+              0.069981,
+              0.070959,
+              0.104972,
+              0.071867,
+              0.070959,
+              0.07054,
+              0.069981,
+              0.07054,
+              0.069073,
+              0.070889,
+              0.07047,
+              0.069981,
+              0.069562,
+              0.07054,
+              0.069981,
+              0.07047,
+              0.069143,
+              0.069981,
+              0.07047,
+              0.070051,
+              0.069632,
+              0.069073,
+              0.070401,
+              0.069492,
+              0.069632,
+              0.069562,
+              0.070889,
+              0.069492,
+              0.070051,
+              0.069562,
+              0.069492
+            ],
+            "warm_rows_per_second": 7269061.765728928
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1909992,
+              "unique_rows": 3878,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 243,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3878
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "565c2bc329ce53a0df8e37745f7a91eee8511cd55df1cd2ce4dcfe98fa366bb8",
+            "table_sha256": "ed3305384acbdfe75476c9295724ebd61bae347ac82710479133bcde6b51108f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1924193510785699,
+          "representatives_sha256": "7d436e33228c3b99bbd1f3685fbf66aa455c3e4abf4ca1c4abd4453aabfcd630",
+          "structurally_merged_rows": 1455,
+          "backend_artifact_bytes": 1911194,
+          "backend_with_key_registry_bytes": 1982128,
+          "backend_with_datrie_key_index_bytes": 1954250,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.970372584563533,
+            "mean_cosine": 0.9988918051069324,
+            "p05_cosine": 0.9934823025035637,
+            "relative_l2_mean": 0.02234575232524709,
+            "relative_l2_p95": 0.11406973290377129,
+            "relative_l2_max": 0.24459732928838826,
+            "weighted_relative_l2_mean": 0.00889438856026394,
+            "weighted_relative_frobenius": 0.010374481889143803,
+            "weighted_mean_cosine": 0.9995919364799863,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.970372584563533,
+            "mean_cosine": 0.9988918051069324,
+            "p05_cosine": 0.9934823025035637,
+            "relative_l2_mean": 0.02234575232524709,
+            "relative_l2_p95": 0.11406973290377129,
+            "relative_l2_max": 0.24459732928838826,
+            "weighted_relative_l2_mean": 0.00889438856026394,
+            "weighted_relative_frobenius": 0.010374481889143803,
+            "weighted_mean_cosine": 0.9995919364799863,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.123876,
+            "warm_p50_ms": 0.069073,
+            "warm_p95_ms": 0.07396264999999999,
+            "warm_p99_ms": 0.07985388,
+            "samples_ms": [
+              0.076616,
+              0.073823,
+              0.072845,
+              0.073753,
+              0.071867,
+              0.071937,
+              0.073822,
+              0.073333,
+              0.071936,
+              0.072844,
+              0.069003,
+              0.068165,
+              0.069073,
+              0.068584,
+              0.071029,
+              0.069562,
+              0.067606,
+              0.069143,
+              0.069004,
+              0.069492,
+              0.069073,
+              0.069562,
+              0.069003,
+              0.069073,
+              0.068654,
+              0.069003,
+              0.069073,
+              0.069073,
+              0.081924,
+              0.070051,
+              0.069003,
+              0.069142,
+              0.067676,
+              0.068095,
+              0.068654,
+              0.068514,
+              0.069631,
+              0.068095,
+              0.069003,
+              0.068165
+            ],
+            "warm_rows_per_second": 7412447.700259147
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1907108,
+              "unique_rows": 3872,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3872
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "5f3897021cb5b4d01c49b4f6087e8c83906d531045def14546ddcb40820c166e",
+            "table_sha256": "f5d2240c19cd8b101915061ddee216f591a8dc046e02251627f8be9d4d5dc5ec",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.178886191919446,
+          "representatives_sha256": "991fd3955e7ce0366e0b95960da44d05f5d2571d45f270fef67728c8bf6c01aa",
+          "structurally_merged_rows": 1461,
+          "backend_artifact_bytes": 1908310,
+          "backend_with_key_registry_bytes": 1979244,
+          "backend_with_datrie_key_index_bytes": 1951366,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9539393104479431,
+            "mean_cosine": 0.9988509765773617,
+            "p05_cosine": 0.9933682216614086,
+            "relative_l2_mean": 0.022647303085639288,
+            "relative_l2_p95": 0.1151708920097435,
+            "relative_l2_max": 0.3049388897587284,
+            "weighted_relative_l2_mean": 0.00901257678779398,
+            "weighted_relative_frobenius": 0.010616035362168956,
+            "weighted_mean_cosine": 0.9995754077438983,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9539393104479431,
+            "mean_cosine": 0.9988509765773617,
+            "p05_cosine": 0.9933682216614086,
+            "relative_l2_mean": 0.022647303085639288,
+            "relative_l2_p95": 0.1151708920097435,
+            "relative_l2_max": 0.3049388897587284,
+            "weighted_relative_l2_mean": 0.00901257678779398,
+            "weighted_relative_frobenius": 0.010616035362168956,
+            "weighted_mean_cosine": 0.9995754077438983,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.111654,
+            "warm_p50_ms": 0.07050500000000001,
+            "warm_p95_ms": 0.07761844999999999,
+            "warm_p99_ms": 0.08153316,
+            "samples_ms": [
+              0.078083,
+              0.073823,
+              0.072845,
+              0.072845,
+              0.071937,
+              0.072355,
+              0.073333,
+              0.073822,
+              0.072844,
+              0.073333,
+              0.073823,
+              0.072426,
+              0.077594,
+              0.076197,
+              0.075219,
+              0.070051,
+              0.069004,
+              0.07047,
+              0.071028,
+              0.069073,
+              0.069981,
+              0.07047,
+              0.069562,
+              0.07012,
+              0.07054,
+              0.07047,
+              0.069003,
+              0.069143,
+              0.069003,
+              0.069981,
+              0.069562,
+              0.07005,
+              0.069492,
+              0.083739,
+              0.07054,
+              0.070958,
+              0.069003,
+              0.069073,
+              0.069631,
+              0.068514
+            ],
+            "warm_rows_per_second": 7261896.319409969
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1903248,
+              "unique_rows": 3864,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3864
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "538675e4df80dda66f752b18b57af79ef1484be9de004fc46fc284e5907d7574",
+            "table_sha256": "a0b617de45f4577f4f307ecc63f901bebc97d16c01fd11ec7493f733d878e4a0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1804608351085335,
+          "representatives_sha256": "dfad668d84d3a9dde10fed2c9e5964b59d2c5eaccc988a384af8a2c7bc4af52c",
+          "structurally_merged_rows": 1469,
+          "backend_artifact_bytes": 1904450,
+          "backend_with_key_registry_bytes": 1975384,
+          "backend_with_datrie_key_index_bytes": 1947506,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9037877545708831,
+            "mean_cosine": 0.9987401100496023,
+            "p05_cosine": 0.9932851026858404,
+            "relative_l2_mean": 0.02322164997411739,
+            "relative_l2_p95": 0.1161852959435186,
+            "relative_l2_max": 0.4386936628207428,
+            "weighted_relative_l2_mean": 0.009396651320714072,
+            "weighted_relative_frobenius": 0.014093234342090312,
+            "weighted_mean_cosine": 0.9995019785254639,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9037877545708831,
+            "mean_cosine": 0.9987401100496023,
+            "p05_cosine": 0.9932851026858404,
+            "relative_l2_mean": 0.02322164997411739,
+            "relative_l2_p95": 0.1161852959435186,
+            "relative_l2_max": 0.4386936628207428,
+            "weighted_relative_l2_mean": 0.009396651320714072,
+            "weighted_relative_frobenius": 0.014093234342090312,
+            "weighted_mean_cosine": 0.9995019785254639,
+            "max_relative_norm_change": 0.010048403769123795
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.248753,
+            "warm_p50_ms": 0.0700505,
+            "warm_p95_ms": 0.07893404999999998,
+            "warm_p99_ms": 0.09836647999999999,
+            "samples_ms": [
+              0.078501,
+              0.073822,
+              0.10553,
+              0.075638,
+              0.072845,
+              0.072425,
+              0.071936,
+              0.087162,
+              0.0748,
+              0.073752,
+              0.070401,
+              0.074311,
+              0.073333,
+              0.071937,
+              0.070121,
+              0.069981,
+              0.070051,
+              0.070051,
+              0.07012,
+              0.069562,
+              0.069982,
+              0.069981,
+              0.070051,
+              0.069562,
+              0.069492,
+              0.069562,
+              0.069981,
+              0.069562,
+              0.069073,
+              0.069632,
+              0.068165,
+              0.069562,
+              0.07005,
+              0.068654,
+              0.069981,
+              0.068095,
+              0.069632,
+              0.069981,
+              0.070051,
+              0.069632
+            ],
+            "warm_rows_per_second": 7309012.783634664
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 1365248,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "590fdfdcc048589926d117e6f06ff1ebd64a0fd2815cc57b8de70080aab734da",
+            "table_sha256": "4d5e89355e425d36118ebf293bc515da98012d2b8cfb74d7abef5c01f93e5d8b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.01722392486408353,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1366052,
+          "backend_with_key_registry_bytes": 1436986,
+          "backend_with_datrie_key_index_bytes": 1409108,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999643352301,
+            "mean_cosine": 0.9999999789923787,
+            "p05_cosine": 0.9999999731100682,
+            "relative_l2_mean": 0.00020673286727305166,
+            "relative_l2_p95": 0.00023477543729639956,
+            "relative_l2_max": 0.0002705172201136542,
+            "weighted_relative_l2_mean": 0.00020763766850666958,
+            "weighted_relative_frobenius": 0.0002090819556359097,
+            "weighted_mean_cosine": 0.9999999788037498,
+            "max_relative_norm_change": 0.00012555925984645075
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.45327,
+            "warm_p50_ms": 0.22,
+            "warm_p95_ms": 0.22364954999999995,
+            "warm_p99_ms": 0.24744582,
+            "samples_ms": [
+              0.222794,
+              0.220978,
+              0.219511,
+              0.220489,
+              0.220978,
+              0.219512,
+              0.220909,
+              0.220978,
+              0.22,
+              0.220908,
+              0.219442,
+              0.239905,
+              0.222375,
+              0.220978,
+              0.221467,
+              0.220908,
+              0.218603,
+              0.219162,
+              0.219581,
+              0.219581,
+              0.219441,
+              0.218533,
+              0.22,
+              0.22,
+              0.220489,
+              0.219023,
+              0.22049,
+              0.22,
+              0.220489,
+              0.252267,
+              0.222794,
+              0.219581,
+              0.218604,
+              0.219581,
+              0.219581,
+              0.22,
+              0.219441,
+              0.21993,
+              0.220489,
+              0.220489
+            ],
+            "warm_rows_per_second": 2327272.727272727
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329267,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 145,
+              "xor_blocks": 22,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "590fdfdcc048589926d117e6f06ff1ebd64a0fd2815cc57b8de70080aab734da",
+            "table_sha256": "c27d497e5ec13867fc6a5cb4eab31b628eed9707d4617ebfe091170fdca264b0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1538615459576249,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330472,
+          "backend_with_key_registry_bytes": 1401406,
+          "backend_with_datrie_key_index_bytes": 1373528,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999643352301,
+            "mean_cosine": 0.9999999789923787,
+            "p05_cosine": 0.9999999731100682,
+            "relative_l2_mean": 0.00020673286727305166,
+            "relative_l2_p95": 0.00023477543729639956,
+            "relative_l2_max": 0.0002705172201136542,
+            "weighted_relative_l2_mean": 0.00020763766850666958,
+            "weighted_relative_frobenius": 0.0002090819556359097,
+            "weighted_mean_cosine": 0.9999999788037498,
+            "max_relative_norm_change": 0.00012555925984645075
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.113342,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.23362624999999995,
+            "warm_p99_ms": 0.26109463,
+            "samples_ms": [
+              0.231315,
+              0.230896,
+              0.229918,
+              0.229917,
+              0.229848,
+              0.22894,
+              0.229499,
+              0.269239,
+              0.231804,
+              0.228521,
+              0.229499,
+              0.22901,
+              0.232851,
+              0.230895,
+              0.229498,
+              0.22901,
+              0.22894,
+              0.229499,
+              0.229009,
+              0.227962,
+              0.228102,
+              0.227543,
+              0.227124,
+              0.227054,
+              0.248356,
+              0.229918,
+              0.228032,
+              0.226635,
+              0.231804,
+              0.231385,
+              0.229988,
+              0.229987,
+              0.227194,
+              0.227124,
+              0.228521,
+              0.228521,
+              0.227054,
+              0.228032,
+              0.227543,
+              0.227543
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329267,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 145,
+              "xor_blocks": 22,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "590fdfdcc048589926d117e6f06ff1ebd64a0fd2815cc57b8de70080aab734da",
+            "table_sha256": "c27d497e5ec13867fc6a5cb4eab31b628eed9707d4617ebfe091170fdca264b0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14749816106632352,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330471,
+          "backend_with_key_registry_bytes": 1401405,
+          "backend_with_datrie_key_index_bytes": 1373527,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999643352301,
+            "mean_cosine": 0.9999999789923787,
+            "p05_cosine": 0.9999999731100682,
+            "relative_l2_mean": 0.00020673286727305166,
+            "relative_l2_p95": 0.00023477543729639956,
+            "relative_l2_max": 0.0002705172201136542,
+            "weighted_relative_l2_mean": 0.00020763766850666958,
+            "weighted_relative_frobenius": 0.0002090819556359097,
+            "weighted_mean_cosine": 0.9999999788037498,
+            "max_relative_norm_change": 0.00012555925984645075
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.123748,
+            "warm_p50_ms": 0.22859049999999997,
+            "warm_p95_ms": 0.23499894999999996,
+            "warm_p99_ms": 0.25888589,
+            "samples_ms": [
+              0.232362,
+              0.231803,
+              0.230826,
+              0.230895,
+              0.228591,
+              0.22901,
+              0.22901,
+              0.229499,
+              0.22894,
+              0.247937,
+              0.230477,
+              0.22859,
+              0.22901,
+              0.229498,
+              0.227543,
+              0.227124,
+              0.226636,
+              0.228451,
+              0.227962,
+              0.227543,
+              0.22901,
+              0.227124,
+              0.228521,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.265886,
+              0.230896,
+              0.228032,
+              0.234318,
+              0.227543,
+              0.227962,
+              0.227473,
+              0.227613,
+              0.227544,
+              0.227962,
+              0.230336,
+              0.230407,
+              0.228591,
+              0.228102
+            ],
+            "warm_rows_per_second": 2239813.115593168
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1329267,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 145,
+              "xor_blocks": 22,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "590fdfdcc048589926d117e6f06ff1ebd64a0fd2815cc57b8de70080aab734da",
+            "table_sha256": "c27d497e5ec13867fc6a5cb4eab31b628eed9707d4617ebfe091170fdca264b0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13302542688325047,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330471,
+          "backend_with_key_registry_bytes": 1401405,
+          "backend_with_datrie_key_index_bytes": 1373527,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999643352301,
+            "mean_cosine": 0.9999999789923787,
+            "p05_cosine": 0.9999999731100682,
+            "relative_l2_mean": 0.00020673286727305166,
+            "relative_l2_p95": 0.00023477543729639956,
+            "relative_l2_max": 0.0002705172201136542,
+            "weighted_relative_l2_mean": 0.00020763766850666958,
+            "weighted_relative_frobenius": 0.0002090819556359097,
+            "weighted_mean_cosine": 0.9999999788037498,
+            "max_relative_norm_change": 0.00012555925984645075
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.130802,
+            "warm_p50_ms": 0.2289745,
+            "warm_p95_ms": 0.23567629999999998,
+            "warm_p99_ms": 0.24956665,
+            "samples_ms": [
+              0.235156,
+              0.229499,
+              0.228032,
+              0.227543,
+              0.228381,
+              0.230896,
+              0.235086,
+              0.22894,
+              0.245562,
+              0.22908,
+              0.234178,
+              0.228451,
+              0.227473,
+              0.227963,
+              0.228032,
+              0.227613,
+              0.229499,
+              0.229429,
+              0.22901,
+              0.233759,
+              0.228521,
+              0.228032,
+              0.229009,
+              0.233759,
+              0.22894,
+              0.252127,
+              0.231315,
+              0.228591,
+              0.229009,
+              0.22894,
+              0.229009,
+              0.228591,
+              0.229079,
+              0.226705,
+              0.228521,
+              0.22852,
+              0.227543,
+              0.227963,
+              0.229848,
+              0.229009
+            ],
+            "warm_rows_per_second": 2236056.8534924197
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1003858,
+              "unique_rows": 3974,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 125,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3974
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "0af80157f7cec6abae5c8ce14fab160a50fc8c5c8f53170ca34bd5ea8a5abfea",
+            "table_sha256": "93f2ac65cdc2b3db24833dae2c21c216a6da481f1034c89cf04c84a27848c36b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.11185197299346328,
+          "representatives_sha256": "9205e2842ffd9234a133ac92f8a1de72edcec80d72ef19103846162fb17ba50f",
+          "structurally_merged_rows": 1359,
+          "backend_artifact_bytes": 1005060,
+          "backend_with_key_registry_bytes": 1075994,
+          "backend_with_datrie_key_index_bytes": 1048116,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900522844601786,
+            "mean_cosine": 0.9991640375629814,
+            "p05_cosine": 0.994637472144233,
+            "relative_l2_mean": 0.019390212010629005,
+            "relative_l2_p95": 0.10369440961747017,
+            "relative_l2_max": 0.1408746714806218,
+            "weighted_relative_l2_mean": 0.007857378964608506,
+            "weighted_relative_frobenius": 0.006748195908759052,
+            "weighted_mean_cosine": 0.9997006623119686,
+            "max_relative_norm_change": 0.010017310244631894
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900483856073877,
+            "mean_cosine": 0.9991640300187963,
+            "p05_cosine": 0.9946371997686602,
+            "relative_l2_mean": 0.01923620903668173,
+            "relative_l2_p95": 0.10369892786180715,
+            "relative_l2_max": 0.14089291500468373,
+            "weighted_relative_l2_mean": 0.0076744640102752925,
+            "weighted_relative_frobenius": 0.0067452159501694255,
+            "weighted_mean_cosine": 0.9997006691776221,
+            "max_relative_norm_change": 0.01002151577688962
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.949505,
+            "warm_p50_ms": 0.2286955,
+            "warm_p95_ms": 0.23725484999999996,
+            "warm_p99_ms": 0.25157525999999997,
+            "samples_ms": [
+              0.236972,
+              0.235575,
+              0.232293,
+              0.229429,
+              0.230406,
+              0.229429,
+              0.228451,
+              0.22894,
+              0.22852,
+              0.228521,
+              0.230406,
+              0.22887,
+              0.229429,
+              0.228521,
+              0.227054,
+              0.242629,
+              0.228521,
+              0.228451,
+              0.22901,
+              0.227124,
+              0.228102,
+              0.228521,
+              0.228521,
+              0.227124,
+              0.227194,
+              0.229498,
+              0.229918,
+              0.234737,
+              0.231314,
+              0.231384,
+              0.229918,
+              0.228451,
+              0.257295,
+              0.231803,
+              0.228102,
+              0.228032,
+              0.227543,
+              0.228381,
+              0.227543,
+              0.227543
+            ],
+            "warm_rows_per_second": 2238784.759647654
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 982914,
+              "unique_rows": 3888,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 122,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 122,
+              "zlib_blocks": 122,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3888
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "57bc51a9a2d3fcd6169ebf714210f12d448cd80c00b891e9a028edf2c76553ef",
+            "table_sha256": "489d1abf7dd67e6d5e892f3b492148f767fa16b42cc9fa234b5e6d130fa1f2bc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10486064408905804,
+          "representatives_sha256": "277f019233b6f3bcb6249b67edee96960c8bd860780e6d0f441e0b2f195a85e8",
+          "structurally_merged_rows": 1445,
+          "backend_artifact_bytes": 984115,
+          "backend_with_key_registry_bytes": 1055049,
+          "backend_with_datrie_key_index_bytes": 1027171,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800424596233465,
+            "mean_cosine": 0.9989484689878441,
+            "p05_cosine": 0.9936446007266101,
+            "relative_l2_mean": 0.022013031924056462,
+            "relative_l2_p95": 0.11268591633659679,
+            "relative_l2_max": 0.1994210431944021,
+            "weighted_relative_l2_mean": 0.008858269765568291,
+            "weighted_relative_frobenius": 0.0099899658176846,
+            "weighted_mean_cosine": 0.9996184151248343,
+            "max_relative_norm_change": 0.010017310244631894
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800416084647343,
+            "mean_cosine": 0.9989484649095248,
+            "p05_cosine": 0.9936429216293082,
+            "relative_l2_mean": 0.0218623178175955,
+            "relative_l2_p95": 0.11267980114319776,
+            "relative_l2_max": 0.19942483799749702,
+            "weighted_relative_l2_mean": 0.008676578811208108,
+            "weighted_relative_frobenius": 0.009987917577146297,
+            "weighted_mean_cosine": 0.9996184239003195,
+            "max_relative_norm_change": 0.01002151577688962
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.938051,
+            "warm_p50_ms": 0.22900949999999998,
+            "warm_p95_ms": 0.23153759999999995,
+            "warm_p99_ms": 0.25725179,
+            "samples_ms": [
+              0.230895,
+              0.22859,
+              0.22901,
+              0.229009,
+              0.230895,
+              0.229918,
+              0.229918,
+              0.229918,
+              0.22901,
+              0.229987,
+              0.22901,
+              0.229498,
+              0.228521,
+              0.229499,
+              0.227613,
+              0.243747,
+              0.229918,
+              0.229009,
+              0.226635,
+              0.227194,
+              0.22852,
+              0.229499,
+              0.229009,
+              0.228102,
+              0.227543,
+              0.227613,
+              0.228032,
+              0.22901,
+              0.226984,
+              0.228451,
+              0.229429,
+              0.229009,
+              0.227962,
+              0.265886,
+              0.230406,
+              0.229498,
+              0.22894,
+              0.229429,
+              0.228032,
+              0.22852
+            ],
+            "warm_rows_per_second": 2235715.1122551686
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 980262,
+              "unique_rows": 3877,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 122,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 122,
+              "zlib_blocks": 122,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3877
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "612c9ba3bc97d5c29f8e2f370f231068dc671aa45b7a3395fb771afe2fdee4f4",
+            "table_sha256": "8eeec69636b33454a26b28c61ed60da3875531986a2afca64bf707960cd85d00",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10655394801869988,
+          "representatives_sha256": "4bbd7d01ad58d7ae302ef3ed98e470624383f7b5a9f3f268f8ddeb9609451463",
+          "structurally_merged_rows": 1456,
+          "backend_artifact_bytes": 981463,
+          "backend_with_key_registry_bytes": 1052397,
+          "backend_with_datrie_key_index_bytes": 1024519,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.970374756828758,
+            "mean_cosine": 0.9988909074575562,
+            "p05_cosine": 0.9934819196205635,
+            "relative_l2_mean": 0.02251451345037744,
+            "relative_l2_p95": 0.11408063305368717,
+            "relative_l2_max": 0.24458470025994816,
+            "weighted_relative_l2_mean": 0.00908119703018639,
+            "weighted_relative_frobenius": 0.010377290834367692,
+            "weighted_mean_cosine": 0.9995916730687094,
+            "max_relative_norm_change": 0.010017310244631894
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9703788044938143,
+            "mean_cosine": 0.9988909009032235,
+            "p05_cosine": 0.9934813324528675,
+            "relative_l2_mean": 0.022364235080523234,
+            "relative_l2_p95": 0.1140800857828706,
+            "relative_l2_max": 0.2445684164990833,
+            "weighted_relative_l2_mean": 0.008899661323857288,
+            "weighted_relative_frobenius": 0.010375380765568555,
+            "weighted_mean_cosine": 0.9995916793899848,
+            "max_relative_norm_change": 0.01002151577688962
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.284953,
+            "warm_p50_ms": 0.22897499999999998,
+            "warm_p95_ms": 0.23607435,
+            "warm_p99_ms": 0.25046152,
+            "samples_ms": [
+              0.231315,
+              0.22894,
+              0.229918,
+              0.228521,
+              0.229918,
+              0.235575,
+              0.233759,
+              0.230895,
+              0.22901,
+              0.233759,
+              0.245562,
+              0.230895,
+              0.229429,
+              0.228451,
+              0.22901,
+              0.232782,
+              0.23327,
+              0.231803,
+              0.230477,
+              0.228591,
+              0.22901,
+              0.228521,
+              0.228102,
+              0.229079,
+              0.226705,
+              0.227613,
+              0.227124,
+              0.253594,
+              0.233201,
+              0.228521,
+              0.228032,
+              0.227613,
+              0.227613,
+              0.228102,
+              0.228032,
+              0.226635,
+              0.22859,
+              0.227613,
+              0.227054,
+              0.228521
+            ],
+            "warm_rows_per_second": 2236051.970739164
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 978672,
+              "unique_rows": 3871,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3871
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "e1c4e492180d3f8aadf7964d5d73b2ccab7d0f5b43af055766c9334f87af0542",
+            "table_sha256": "636ed25eab773bd9a5f38c6b1f00298c8181cc2fa02545b77ed4ada9328cf84f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10646545910276473,
+          "representatives_sha256": "212263313d6ae3a91d10ddbf617f814b1c08438e03dc93b0fe181bfa7a5fa9f2",
+          "structurally_merged_rows": 1462,
+          "backend_artifact_bytes": 979873,
+          "backend_with_key_registry_bytes": 1050807,
+          "backend_with_datrie_key_index_bytes": 1022929,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9539257055513554,
+            "mean_cosine": 0.9988500772716368,
+            "p05_cosine": 0.9933672096666714,
+            "relative_l2_mean": 0.022815834585993885,
+            "relative_l2_p95": 0.11517078666926303,
+            "relative_l2_max": 0.30498064308212897,
+            "weighted_relative_l2_mean": 0.00919929728101851,
+            "weighted_relative_frobenius": 0.010618802479643075,
+            "weighted_mean_cosine": 0.9995751438592744,
+            "max_relative_norm_change": 0.010017310244631894
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9539276501271642,
+            "mean_cosine": 0.9988500722968754,
+            "p05_cosine": 0.9933665941569161,
+            "relative_l2_mean": 0.022665786508838028,
+            "relative_l2_p95": 0.11516667455361981,
+            "relative_l2_max": 0.3049780712056362,
+            "weighted_relative_l2_mean": 0.009017849454424659,
+            "weighted_relative_frobenius": 0.010616933019063798,
+            "weighted_mean_cosine": 0.9995751505526811,
+            "max_relative_norm_change": 0.01002151577688962
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.188852,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.2387707,
+            "warm_p99_ms": 0.25491474000000003,
+            "samples_ms": [
+              0.23327,
+              0.231314,
+              0.230895,
+              0.229499,
+              0.227613,
+              0.261207,
+              0.238439,
+              0.233759,
+              0.229918,
+              0.230406,
+              0.229917,
+              0.232362,
+              0.231873,
+              0.229918,
+              0.227124,
+              0.227543,
+              0.227543,
+              0.228032,
+              0.228521,
+              0.226636,
+              0.228451,
+              0.227543,
+              0.245073,
+              0.232712,
+              0.22901,
+              0.233689,
+              0.228451,
+              0.227962,
+              0.227124,
+              0.228032,
+              0.226286,
+              0.227124,
+              0.228521,
+              0.228032,
+              0.23313,
+              0.228521,
+              0.227613,
+              0.227194,
+              0.227124,
+              0.228032
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 976769,
+              "unique_rows": 3863,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3863
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "10807aca492adfffea37a8a846e93364723fe3ff514ff35f03072b2e27fbacc8",
+            "table_sha256": "afc91dc5e1502b2be927ab8476e155f4bea0ba5d4b6af74bc58c0779b103093c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10740412608720362,
+          "representatives_sha256": "f5f18875305939bf17ea579b32984c74a8ca2c9d708c8fd969ad4f13c7dd6ea7",
+          "structurally_merged_rows": 1470,
+          "backend_artifact_bytes": 977970,
+          "backend_with_key_registry_bytes": 1048904,
+          "backend_with_datrie_key_index_bytes": 1021026,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9037792527690864,
+            "mean_cosine": 0.9987392065989559,
+            "p05_cosine": 0.9932839992700851,
+            "relative_l2_mean": 0.023389868840546283,
+            "relative_l2_p95": 0.11619517829097764,
+            "relative_l2_max": 0.43871066183303176,
+            "weighted_relative_l2_mean": 0.00958315800202989,
+            "weighted_relative_frobenius": 0.01409531774117527,
+            "weighted_mean_cosine": 0.9995017141288418,
+            "max_relative_norm_change": 0.010017310244631894
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9037807344037438,
+            "mean_cosine": 0.9987391954638807,
+            "p05_cosine": 0.9932847885012078,
+            "relative_l2_mean": 0.023240150456866986,
+            "relative_l2_p95": 0.11619874549726088,
+            "relative_l2_max": 0.43869563375108495,
+            "weighted_relative_l2_mean": 0.009401932052507061,
+            "weighted_relative_frobenius": 0.014094520590897984,
+            "weighted_mean_cosine": 0.9995017151988554,
+            "max_relative_norm_change": 0.01002151577688962
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.251709,
+            "warm_p50_ms": 0.229918,
+            "warm_p95_ms": 0.23778939999999998,
+            "warm_p99_ms": 0.25599151,
+            "samples_ms": [
+              0.23327,
+              0.233759,
+              0.23327,
+              0.230407,
+              0.231385,
+              0.26449,
+              0.232781,
+              0.230896,
+              0.229499,
+              0.22901,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.22894,
+              0.22901,
+              0.231873,
+              0.234108,
+              0.232782,
+              0.229918,
+              0.228101,
+              0.228032,
+              0.228032,
+              0.242699,
+              0.232711,
+              0.229987,
+              0.232292,
+              0.231314,
+              0.229918,
+              0.229499,
+              0.232293,
+              0.227963,
+              0.227543,
+              0.228451,
+              0.227962,
+              0.228032,
+              0.227613,
+              0.227613,
+              0.228521,
+              0.233689,
+              0.237531
+            ],
+            "warm_rows_per_second": 2226880.887968754
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 703956,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "5208f73b4895fa6286c9b958779d6930895d8e6968f9ee970b34284151bd9200",
+            "table_sha256": "1695a383af41a932d3e663426935548621422726475092855d2e0fca6971008f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.013848282862454653,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 704803,
+          "backend_with_key_registry_bytes": 775737,
+          "backend_with_datrie_key_index_bytes": 747859,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999401787751158,
+            "mean_cosine": 0.999979209003611,
+            "p05_cosine": 0.9999685946479178,
+            "relative_l2_mean": 0.006417865941609127,
+            "relative_l2_p95": 0.007940894253651317,
+            "relative_l2_max": 0.01093801745716858,
+            "weighted_relative_l2_mean": 0.006443848531946682,
+            "weighted_relative_frobenius": 0.006579211484067163,
+            "weighted_mean_cosine": 0.9999790416837705,
+            "max_relative_norm_change": 0.0023069212797726902
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.317498,
+            "warm_p50_ms": 0.122502,
+            "warm_p95_ms": 0.1254769,
+            "warm_p99_ms": 0.13296165,
+            "samples_ms": [
+              0.125435,
+              0.123479,
+              0.123479,
+              0.122502,
+              0.122921,
+              0.124458,
+              0.123061,
+              0.122082,
+              0.121594,
+              0.122572,
+              0.123061,
+              0.121174,
+              0.121594,
+              0.12299,
+              0.12299,
+              0.122991,
+              0.121105,
+              0.122501,
+              0.121594,
+              0.120616,
+              0.122013,
+              0.122572,
+              0.122572,
+              0.122571,
+              0.122572,
+              0.121105,
+              0.122082,
+              0.126273,
+              0.121663,
+              0.122991,
+              0.137238,
+              0.122991,
+              0.122502,
+              0.121036,
+              0.121035,
+              0.121524,
+              0.121524,
+              0.122432,
+              0.121593,
+              0.121175
+            ],
+            "warm_rows_per_second": 4179523.5996147003
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712514,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "5208f73b4895fa6286c9b958779d6930895d8e6968f9ee970b34284151bd9200",
+            "table_sha256": "ed7fa4a02a98023f8dbae82b832b3d270653cea1709997b9c0432c8c36bb5de8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07655254704877734,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713758,
+          "backend_with_key_registry_bytes": 784692,
+          "backend_with_datrie_key_index_bytes": 756814,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999401787751158,
+            "mean_cosine": 0.999979209003611,
+            "p05_cosine": 0.9999685946479178,
+            "relative_l2_mean": 0.006417865941609127,
+            "relative_l2_p95": 0.007940894253651317,
+            "relative_l2_max": 0.01093801745716858,
+            "weighted_relative_l2_mean": 0.006443848531946682,
+            "weighted_relative_frobenius": 0.006579211484067163,
+            "weighted_mean_cosine": 0.9999790416837705,
+            "max_relative_norm_change": 0.0023069212797726902
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.440431,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13729709999999995,
+            "warm_p99_ms": 0.15884004,
+            "samples_ms": [
+              0.134445,
+              0.132001,
+              0.131092,
+              0.131022,
+              0.165105,
+              0.136331,
+              0.132489,
+              0.131511,
+              0.131511,
+              0.134374,
+              0.132908,
+              0.132,
+              0.133816,
+              0.132978,
+              0.132978,
+              0.132489,
+              0.136679,
+              0.132,
+              0.131092,
+              0.130673,
+              0.131022,
+              0.132489,
+              0.132978,
+              0.132,
+              0.131092,
+              0.132,
+              0.132419,
+              0.132489,
+              0.131023,
+              0.131023,
+              0.131023,
+              0.132,
+              0.132,
+              0.131092,
+              0.149041,
+              0.132489,
+              0.131511,
+              0.130604,
+              0.136261,
+              0.130603
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712514,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "5208f73b4895fa6286c9b958779d6930895d8e6968f9ee970b34284151bd9200",
+            "table_sha256": "ed7fa4a02a98023f8dbae82b832b3d270653cea1709997b9c0432c8c36bb5de8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1030453268904239,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713757,
+          "backend_with_key_registry_bytes": 784691,
+          "backend_with_datrie_key_index_bytes": 756813,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999401787751158,
+            "mean_cosine": 0.999979209003611,
+            "p05_cosine": 0.9999685946479178,
+            "relative_l2_mean": 0.006417865941609127,
+            "relative_l2_p95": 0.007940894253651317,
+            "relative_l2_max": 0.01093801745716858,
+            "weighted_relative_l2_mean": 0.006443848531946682,
+            "weighted_relative_frobenius": 0.006579211484067163,
+            "weighted_mean_cosine": 0.9999790416837705,
+            "max_relative_norm_change": 0.0023069212797726902
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.502381,
+            "warm_p50_ms": 0.13130199999999997,
+            "warm_p95_ms": 0.13998995,
+            "warm_p99_ms": 0.14282131,
+            "samples_ms": [
+              0.139962,
+              0.135353,
+              0.13626,
+              0.134374,
+              0.132,
+              0.132489,
+              0.132,
+              0.130115,
+              0.130115,
+              0.131512,
+              0.131092,
+              0.132,
+              0.130603,
+              0.131092,
+              0.131511,
+              0.130044,
+              0.130114,
+              0.131092,
+              0.131511,
+              0.131512,
+              0.131023,
+              0.132419,
+              0.131511,
+              0.131092,
+              0.144292,
+              0.131023,
+              0.129626,
+              0.131512,
+              0.129207,
+              0.130604,
+              0.131511,
+              0.129207,
+              0.128717,
+              0.131511,
+              0.130534,
+              0.131093,
+              0.140521,
+              0.129625,
+              0.130115,
+              0.131511
+            ],
+            "warm_rows_per_second": 3899407.472848853
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712514,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 39,
+              "xor_blocks": 47,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "5208f73b4895fa6286c9b958779d6930895d8e6968f9ee970b34284151bd9200",
+            "table_sha256": "ed7fa4a02a98023f8dbae82b832b3d270653cea1709997b9c0432c8c36bb5de8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07710743695497513,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713757,
+          "backend_with_key_registry_bytes": 784691,
+          "backend_with_datrie_key_index_bytes": 756813,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999401787751158,
+            "mean_cosine": 0.999979209003611,
+            "p05_cosine": 0.9999685946479178,
+            "relative_l2_mean": 0.006417865941609127,
+            "relative_l2_p95": 0.007940894253651317,
+            "relative_l2_max": 0.01093801745716858,
+            "weighted_relative_l2_mean": 0.006443848531946682,
+            "weighted_relative_frobenius": 0.006579211484067163,
+            "weighted_mean_cosine": 0.9999790416837705,
+            "max_relative_norm_change": 0.0023069212797726902
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.437987,
+            "warm_p50_ms": 0.1305685,
+            "warm_p95_ms": 0.13727029999999998,
+            "warm_p99_ms": 0.16159836,
+            "samples_ms": [
+              0.135771,
+              0.132419,
+              0.132489,
+              0.130603,
+              0.130603,
+              0.131511,
+              0.132,
+              0.170832,
+              0.13675,
+              0.130115,
+              0.131581,
+              0.129695,
+              0.130114,
+              0.130114,
+              0.130114,
+              0.130603,
+              0.129136,
+              0.130044,
+              0.129555,
+              0.129067,
+              0.131023,
+              0.130604,
+              0.130185,
+              0.130185,
+              0.130115,
+              0.131023,
+              0.132001,
+              0.129137,
+              0.130534,
+              0.130534,
+              0.130534,
+              0.129626,
+              0.130603,
+              0.128299,
+              0.129695,
+              0.130114,
+              0.130603,
+              0.147156,
+              0.131023,
+              0.130604
+            ],
+            "warm_rows_per_second": 3921313.3336141566
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 546329,
+              "unique_rows": 3977,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 65,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 64,
+              "zlib_blocks": 64,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3977
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "92880d90fc03d5cf3eead03b8520a9862a554add3465aaba0f4a40c16f0900cd",
+            "table_sha256": "8fdf4025fddce61416df8d32ea46611f332df585b3f46a74511e95488f428e70",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06986642582342029,
+          "representatives_sha256": "645a1bae78604bd202f048c41638ba6c7eb3b361380b0dad44050b671e577b19",
+          "structurally_merged_rows": 1356,
+          "backend_artifact_bytes": 547570,
+          "backend_with_key_registry_bytes": 618504,
+          "backend_with_datrie_key_index_bytes": 590626,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900137733965927,
+            "mean_cosine": 0.9991445037125608,
+            "p05_cosine": 0.994620323071824,
+            "relative_l2_mean": 0.024068633513318827,
+            "relative_l2_p95": 0.10367830120510269,
+            "relative_l2_max": 0.1411979477508241,
+            "weighted_relative_l2_mean": 0.013385180034982664,
+            "weighted_relative_frobenius": 0.009414340895132815,
+            "weighted_mean_cosine": 0.999680359251853,
+            "max_relative_norm_change": 0.011010627250046198
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900061938975968,
+            "mean_cosine": 0.9991546302983773,
+            "p05_cosine": 0.9945684798321575,
+            "relative_l2_mean": 0.019365973926123135,
+            "relative_l2_p95": 0.10420154679809014,
+            "relative_l2_max": 0.14183076097570288,
+            "weighted_relative_l2_mean": 0.0077497218899546345,
+            "weighted_relative_frobenius": 0.006861641269675814,
+            "weighted_mean_cosine": 0.9996964030636359,
+            "max_relative_norm_change": 0.010000496728499994
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.135586,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.14236145,
+            "warm_p99_ms": 0.15935577999999997,
+            "samples_ms": [
+              0.136191,
+              0.133397,
+              0.130114,
+              0.131092,
+              0.132489,
+              0.132001,
+              0.142826,
+              0.132,
+              0.142337,
+              0.133467,
+              0.131092,
+              0.131511,
+              0.130114,
+              0.130603,
+              0.131022,
+              0.130534,
+              0.131023,
+              0.131023,
+              0.132489,
+              0.132,
+              0.130184,
+              0.169924,
+              0.135283,
+              0.131022,
+              0.130604,
+              0.130185,
+              0.131512,
+              0.132978,
+              0.132,
+              0.129695,
+              0.131511,
+              0.129625,
+              0.130603,
+              0.132419,
+              0.131511,
+              0.131022,
+              0.132,
+              0.130603,
+              0.132489,
+              0.141498
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 535034,
+              "unique_rows": 3888,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3888
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "46de879590309ce9fba0421c568f33bf654acaa684151f0cacba63d878cddb71",
+            "table_sha256": "f5d885199c8c2656804be6296f41356c9129e24120bbeb8ca88263487b2fb53e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06275161588564515,
+          "representatives_sha256": "48ad575a29acd9ac1a08b0d40b2a7e55fde5b214c6f072df671c11c296d5cef4",
+          "structurally_merged_rows": 1445,
+          "backend_artifact_bytes": 536275,
+          "backend_with_key_registry_bytes": 607209,
+          "backend_with_datrie_key_index_bytes": 579331,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9806577959612811,
+            "mean_cosine": 0.9989227975167413,
+            "p05_cosine": 0.9935783568809586,
+            "relative_l2_mean": 0.02667343768566283,
+            "relative_l2_p95": 0.11329985959849637,
+            "relative_l2_max": 0.19763775510265796,
+            "weighted_relative_l2_mean": 0.014358287795764325,
+            "weighted_relative_frobenius": 0.011897454390846881,
+            "weighted_mean_cosine": 0.9995975749788588,
+            "max_relative_norm_change": 0.011010627250046198
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9805934384917934,
+            "mean_cosine": 0.9989324308298284,
+            "p05_cosine": 0.9935625597806309,
+            "relative_l2_mean": 0.022079363647086014,
+            "relative_l2_p95": 0.11344617562647018,
+            "relative_l2_max": 0.19807229127563497,
+            "weighted_relative_l2_mean": 0.008766229228731699,
+            "weighted_relative_frobenius": 0.01001933521861662,
+            "weighted_mean_cosine": 0.99961331448753,
+            "max_relative_norm_change": 0.010054287587219024
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.077338,
+            "warm_p50_ms": 0.132419,
+            "warm_p95_ms": 0.13852409999999998,
+            "warm_p99_ms": 0.16038694999999997,
+            "samples_ms": [
+              0.133886,
+              0.132,
+              0.132489,
+              0.133886,
+              0.133397,
+              0.169784,
+              0.132,
+              0.138147,
+              0.133397,
+              0.132978,
+              0.131093,
+              0.133397,
+              0.132908,
+              0.131092,
+              0.131512,
+              0.132,
+              0.132489,
+              0.131581,
+              0.130533,
+              0.132978,
+              0.132,
+              0.132419,
+              0.132489,
+              0.132909,
+              0.132419,
+              0.132,
+              0.130114,
+              0.132489,
+              0.131023,
+              0.132,
+              0.131092,
+              0.132908,
+              0.132,
+              0.130534,
+              0.145689,
+              0.133397,
+              0.131023,
+              0.132489,
+              0.131022,
+              0.130603
+            ],
+            "warm_rows_per_second": 3866514.624034315
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 533505,
+              "unique_rows": 3876,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3876
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "2df46e39c77b01a7cd6794a6017d58b9c4fd0b0c8a6cfa0b40063ed84298037d",
+            "table_sha256": "e724bfcd1107587aeda1ca6e0eab4b71b0adb40bcfd5c86e60d2ea5610a4a5da",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06969936494715512,
+          "representatives_sha256": "5af76ac7da327441b5d21cb174a802de2b99b43f5c565afa8201077eaea031f8",
+          "structurally_merged_rows": 1457,
+          "backend_artifact_bytes": 534746,
+          "backend_with_key_registry_bytes": 605680,
+          "backend_with_datrie_key_index_bytes": 577802,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9703153181619626,
+            "mean_cosine": 0.9988612658052478,
+            "p05_cosine": 0.9933448473360086,
+            "relative_l2_mean": 0.02719928555694859,
+            "relative_l2_p95": 0.11534418300944277,
+            "relative_l2_max": 0.24441432359402698,
+            "weighted_relative_l2_mean": 0.014598146855964915,
+            "weighted_relative_frobenius": 0.01226492094403948,
+            "weighted_mean_cosine": 0.9995686228195856,
+            "max_relative_norm_change": 0.011010627250046198
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9702101180641064,
+            "mean_cosine": 0.9988708674464274,
+            "p05_cosine": 0.9933316178451478,
+            "relative_l2_mean": 0.02261960249918222,
+            "relative_l2_p95": 0.11551730729681066,
+            "relative_l2_max": 0.2437288874566517,
+            "weighted_relative_l2_mean": 0.0090110590653126,
+            "weighted_relative_frobenius": 0.010455888060020459,
+            "weighted_mean_cosine": 0.9995842673801404,
+            "max_relative_norm_change": 0.010054287587219024
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.971319,
+            "warm_p50_ms": 0.131581,
+            "warm_p95_ms": 0.1366627,
+            "warm_p99_ms": 0.16107101999999998,
+            "samples_ms": [
+              0.135771,
+              0.134375,
+              0.132978,
+              0.132,
+              0.132489,
+              0.132908,
+              0.132,
+              0.132908,
+              0.132,
+              0.132,
+              0.132,
+              0.132489,
+              0.132,
+              0.131512,
+              0.131023,
+              0.131022,
+              0.142965,
+              0.130603,
+              0.131511,
+              0.131092,
+              0.130044,
+              0.172647,
+              0.130114,
+              0.129207,
+              0.136191,
+              0.131511,
+              0.131581,
+              0.131511,
+              0.132001,
+              0.136331,
+              0.130604,
+              0.131581,
+              0.130533,
+              0.130604,
+              0.130603,
+              0.128787,
+              0.132,
+              0.131581,
+              0.131022,
+              0.131022
+            ],
+            "warm_rows_per_second": 3891139.298226948
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 532751,
+              "unique_rows": 3870,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3870
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "1326558a36adab45eb74657d89612cf5d4e966215e2b6767ec780ece8ec58a18",
+            "table_sha256": "ffe88508bd76be26454466a622516d4c6528496b960d89628909a825fbe396b5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07675173482857645,
+          "representatives_sha256": "9283c93386c03bb302c9f7b181f223f010bb6252536ccb514cdd28e60d378107",
+          "structurally_merged_rows": 1463,
+          "backend_artifact_bytes": 533992,
+          "backend_with_key_registry_bytes": 604926,
+          "backend_with_datrie_key_index_bytes": 577048,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9536840917457966,
+            "mean_cosine": 0.9988204158980151,
+            "p05_cosine": 0.9933078276560026,
+            "relative_l2_mean": 0.0274940284608687,
+            "relative_l2_p95": 0.11572949516287494,
+            "relative_l2_max": 0.3058572569757398,
+            "weighted_relative_l2_mean": 0.014713795536892137,
+            "weighted_relative_frobenius": 0.012470527446288186,
+            "weighted_mean_cosine": 0.9995520841447151,
+            "max_relative_norm_change": 0.011010627250046198
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9535673050738439,
+            "mean_cosine": 0.9988300177098813,
+            "p05_cosine": 0.9932640311753331,
+            "relative_l2_mean": 0.022921253553751512,
+            "relative_l2_p95": 0.11644333695897566,
+            "relative_l2_max": 0.3063228619560601,
+            "weighted_relative_l2_mean": 0.00912933391785955,
+            "weighted_relative_frobenius": 0.01069657460148448,
+            "weighted_mean_cosine": 0.9995677220810844,
+            "max_relative_norm_change": 0.010054287587219024
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.135516,
+            "warm_p50_ms": 0.13221,
+            "warm_p95_ms": 0.14197054999999997,
+            "warm_p99_ms": 0.15036738,
+            "samples_ms": [
+              0.137657,
+              0.141569,
+              0.133886,
+              0.130044,
+              0.132,
+              0.134374,
+              0.134445,
+              0.133467,
+              0.1496,
+              0.134444,
+              0.132489,
+              0.130533,
+              0.133466,
+              0.132908,
+              0.132,
+              0.137169,
+              0.137239,
+              0.134794,
+              0.132001,
+              0.133467,
+              0.133816,
+              0.132,
+              0.131581,
+              0.131092,
+              0.130533,
+              0.132001,
+              0.132419,
+              0.131511,
+              0.131511,
+              0.133397,
+              0.132,
+              0.132908,
+              0.131093,
+              0.131022,
+              0.131022,
+              0.131511,
+              0.132,
+              0.132001,
+              0.150858,
+              0.130603
+            ],
+            "warm_rows_per_second": 3872626.8814764395
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 531770,
+              "unique_rows": 3862,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3862
+            },
+            "source_float32_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b",
+            "decoded_float32_sha256": "7211c59801c5795c3b3925ab3fa757b1cee00caea511a0242254ee11e45d4c96",
+            "table_sha256": "9691fd208b593744b9dbba163a604afc4372d52ac2d57d134df4eb774def4a8e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0665085930377245,
+          "representatives_sha256": "a75e3508a0ffe6b1bde4d8e97191ec9cb936367875475d634e0557b84f75c9a3",
+          "structurally_merged_rows": 1471,
+          "backend_artifact_bytes": 533011,
+          "backend_with_key_registry_bytes": 603945,
+          "backend_with_datrie_key_index_bytes": 576067,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9038088300906122,
+            "mean_cosine": 0.9987095735022165,
+            "p05_cosine": 0.9931008619725634,
+            "relative_l2_mean": 0.02805887765538132,
+            "relative_l2_p95": 0.11731227593917865,
+            "relative_l2_max": 0.4387194163405977,
+            "weighted_relative_l2_mean": 0.015091432431308172,
+            "weighted_relative_frobenius": 0.015538193567423851,
+            "weighted_mean_cosine": 0.9994786605194113,
+            "max_relative_norm_change": 0.011010627250046198
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9036987430160472,
+            "mean_cosine": 0.9987190532983201,
+            "p05_cosine": 0.9931055175354562,
+            "relative_l2_mean": 0.023495856889297635,
+            "relative_l2_p95": 0.11749266590090074,
+            "relative_l2_max": 0.43882451952200247,
+            "weighted_relative_l2_mean": 0.00951363456066782,
+            "weighted_relative_frobenius": 0.01415687281307621,
+            "weighted_mean_cosine": 0.9994941974605697,
+            "max_relative_norm_change": 0.010054287587219024
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.185801,
+            "warm_p50_ms": 0.13245400000000002,
+            "warm_p95_ms": 0.1397071,
+            "warm_p99_ms": 0.14891707,
+            "samples_ms": [
+              0.137657,
+              0.142825,
+              0.134375,
+              0.132489,
+              0.132,
+              0.13619,
+              0.133956,
+              0.132489,
+              0.131511,
+              0.133886,
+              0.133397,
+              0.152812,
+              0.133327,
+              0.132489,
+              0.133886,
+              0.132978,
+              0.139543,
+              0.132978,
+              0.135701,
+              0.132,
+              0.132419,
+              0.130115,
+              0.131512,
+              0.130603,
+              0.135282,
+              0.132,
+              0.129695,
+              0.130603,
+              0.129695,
+              0.130603,
+              0.131511,
+              0.135213,
+              0.133467,
+              0.132001,
+              0.132,
+              0.130044,
+              0.130603,
+              0.130114,
+              0.132,
+              0.132419
+            ],
+            "warm_rows_per_second": 3865492.925845954
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "8e02a804ab58387d46d2ffc3cf20b2e4afe2a2d05b24dca43ec60087753a574b"
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "rows": 5333,
+      "dim": 128,
+      "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+      "source_float32_bytes": 2730496,
+      "key_registry_bytes": 70934,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 43056,
+      "query_rows": 512,
+      "query_ids_sha256": "87677d489e681e6c0a39b8460231cf990090e3318abb13c912a002c527931d01",
+      "frequency_trace_sha256": "0e7a36c623f2fc5cc1e4fd51bc27b7b98d60f0c1b31a56fb66253e951084f56a",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 2730496,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "table_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.015308177098631859,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2731299,
+          "backend_with_key_registry_bytes": 2802233,
+          "backend_with_datrie_key_index_bytes": 2774355,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.340197,
+            "warm_p50_ms": 0.062019,
+            "warm_p95_ms": 0.06301795,
+            "warm_p99_ms": 0.06401258,
+            "samples_ms": [
+              0.064394,
+              0.062508,
+              0.062508,
+              0.062927,
+              0.061879,
+              0.06153,
+              0.062997,
+              0.062508,
+              0.060553,
+              0.060972,
+              0.061949,
+              0.062019,
+              0.062508,
+              0.062508,
+              0.06188,
+              0.06153,
+              0.060552,
+              0.063416,
+              0.062508,
+              0.061531,
+              0.06195,
+              0.062368,
+              0.062508,
+              0.062438,
+              0.0616,
+              0.061461,
+              0.061949,
+              0.060622,
+              0.060134,
+              0.062438,
+              0.062508,
+              0.062508,
+              0.062019,
+              0.06202,
+              0.062368,
+              0.061949,
+              0.061041,
+              0.061111,
+              0.062857,
+              0.06188
+            ],
+            "warm_rows_per_second": 8255534.594237249
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607383,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 298,
+              "xor_blocks": 36,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "table_sha256": "4465813fb78d28bdba11b7014025de4b6859d2738003af396758fd432063ecab",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23725302796810865,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608587,
+          "backend_with_key_registry_bytes": 2679521,
+          "backend_with_datrie_key_index_bytes": 2651643,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.498284,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.0757534,
+            "warm_p99_ms": 0.09110106,
+            "samples_ms": [
+              0.076616,
+              0.073823,
+              0.075708,
+              0.073752,
+              0.073822,
+              0.071937,
+              0.073823,
+              0.075219,
+              0.071937,
+              0.073334,
+              0.071029,
+              0.100362,
+              0.07515,
+              0.071937,
+              0.07054,
+              0.070051,
+              0.069004,
+              0.069981,
+              0.069561,
+              0.070051,
+              0.070051,
+              0.069492,
+              0.069981,
+              0.070051,
+              0.069073,
+              0.070889,
+              0.069562,
+              0.069632,
+              0.069562,
+              0.069073,
+              0.069562,
+              0.069632,
+              0.069073,
+              0.069004,
+              0.069981,
+              0.070539,
+              0.069562,
+              0.070958,
+              0.0704,
+              0.069493
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607383,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 298,
+              "xor_blocks": 36,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "table_sha256": "4465813fb78d28bdba11b7014025de4b6859d2738003af396758fd432063ecab",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2622648940887302,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608586,
+          "backend_with_key_registry_bytes": 2679520,
+          "backend_with_datrie_key_index_bytes": 2651642,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.52629,
+            "warm_p50_ms": 0.070959,
+            "warm_p95_ms": 0.07661945,
+            "warm_p99_ms": 0.09082968,
+            "samples_ms": [
+              0.076685,
+              0.076616,
+              0.0748,
+              0.099873,
+              0.074311,
+              0.074171,
+              0.073822,
+              0.073403,
+              0.071936,
+              0.073822,
+              0.072914,
+              0.073822,
+              0.073752,
+              0.069981,
+              0.069981,
+              0.07047,
+              0.07061,
+              0.069632,
+              0.071378,
+              0.069003,
+              0.07054,
+              0.07005,
+              0.069073,
+              0.069422,
+              0.069142,
+              0.071029,
+              0.070889,
+              0.069981,
+              0.070958,
+              0.070959,
+              0.070959,
+              0.070959,
+              0.070051,
+              0.070959,
+              0.071448,
+              0.071378,
+              0.070889,
+              0.070889,
+              0.070889,
+              0.070051
+            ],
+            "warm_rows_per_second": 7215434.264857171
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 2607383,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 334,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 334,
+              "zlib_blocks": 298,
+              "xor_blocks": 36,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "table_sha256": "4465813fb78d28bdba11b7014025de4b6859d2738003af396758fd432063ecab",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23869595117866993,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2608586,
+          "backend_with_key_registry_bytes": 2679520,
+          "backend_with_datrie_key_index_bytes": 2651642,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.503522,
+            "warm_p50_ms": 0.0700505,
+            "warm_p95_ms": 0.073822,
+            "warm_p99_ms": 0.08421761999999999,
+            "samples_ms": [
+              0.090864,
+              0.073333,
+              0.071936,
+              0.071937,
+              0.073334,
+              0.073753,
+              0.073822,
+              0.072426,
+              0.071937,
+              0.073333,
+              0.071936,
+              0.069562,
+              0.069073,
+              0.069073,
+              0.069073,
+              0.069562,
+              0.073822,
+              0.070958,
+              0.07047,
+              0.070959,
+              0.07047,
+              0.068654,
+              0.070959,
+              0.071378,
+              0.069073,
+              0.07012,
+              0.069562,
+              0.07047,
+              0.069492,
+              0.069143,
+              0.068654,
+              0.069004,
+              0.069143,
+              0.068584,
+              0.069492,
+              0.068654,
+              0.069003,
+              0.069981,
+              0.069143,
+              0.069981
+            ],
+            "warm_rows_per_second": 7309012.783634664
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1968073,
+              "unique_rows": 3998,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 250,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 250,
+              "zlib_blocks": 250,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3998
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "8eb928aaa7073a9ca338dd2537d05b79bf8d542536c211384f987218d2e09d51",
+            "table_sha256": "32675e6148c95f00069758bb3f78daac16c7eb7578877c6c34642e708b01a11b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18388285115361214,
+          "representatives_sha256": "1c84eef9686f2d387df0529d6f8c244ea07ca48509de04df67e0e50c6d680702",
+          "structurally_merged_rows": 1335,
+          "backend_artifact_bytes": 1969275,
+          "backend_with_key_registry_bytes": 2040209,
+          "backend_with_datrie_key_index_bytes": 2012331,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900325358107495,
+            "mean_cosine": 0.9991851815172184,
+            "p05_cosine": 0.9947963921319865,
+            "relative_l2_mean": 0.018818578252097564,
+            "relative_l2_p95": 0.1020233298539952,
+            "relative_l2_max": 0.14137685298673708,
+            "weighted_relative_l2_mean": 0.0075909892553223425,
+            "weighted_relative_frobenius": 0.006788218213522045,
+            "weighted_mean_cosine": 0.9997044562858881,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900325358107495,
+            "mean_cosine": 0.9991851815172184,
+            "p05_cosine": 0.9947963921319865,
+            "relative_l2_mean": 0.018818578252097564,
+            "relative_l2_p95": 0.1020233298539952,
+            "relative_l2_max": 0.14137685298673708,
+            "weighted_relative_l2_mean": 0.0075909892553223425,
+            "weighted_relative_frobenius": 0.006788218213522045,
+            "weighted_mean_cosine": 0.9997044562858881,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.617445,
+            "warm_p50_ms": 0.070784,
+            "warm_p95_ms": 0.0742934,
+            "warm_p99_ms": 0.07554459,
+            "samples_ms": [
+              0.075289,
+              0.073822,
+              0.072774,
+              0.073333,
+              0.073334,
+              0.073334,
+              0.073822,
+              0.073334,
+              0.074241,
+              0.072355,
+              0.07061,
+              0.072495,
+              0.073334,
+              0.075708,
+              0.074241,
+              0.07061,
+              0.070958,
+              0.070959,
+              0.072845,
+              0.073264,
+              0.071447,
+              0.07054,
+              0.069004,
+              0.069073,
+              0.070539,
+              0.071029,
+              0.070121,
+              0.070051,
+              0.069004,
+              0.070051,
+              0.070051,
+              0.069493,
+              0.069143,
+              0.069562,
+              0.069492,
+              0.069003,
+              0.069493,
+              0.069632,
+              0.070051,
+              0.069981
+            ],
+            "warm_rows_per_second": 7233273.056057866
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1912055,
+              "unique_rows": 3882,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 243,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3882
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "e165804434e8b2612590d199b2805e2c962eecfe00fa342f9cf42695b81c1fbf",
+            "table_sha256": "6ccc91d2a792298155061479d627108bae5c69e627fa69d211579841315b1445",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1820334519725293,
+          "representatives_sha256": "526b2f53594f83bee7561ae6618b98fff3af1c262afe84aceb614f36c693f4bd",
+          "structurally_merged_rows": 1451,
+          "backend_artifact_bytes": 1913257,
+          "backend_with_key_registry_bytes": 1984191,
+          "backend_with_datrie_key_index_bytes": 1956313,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.980050565596075,
+            "mean_cosine": 0.9988970098862606,
+            "p05_cosine": 0.9930372589094937,
+            "relative_l2_mean": 0.02234897656608579,
+            "relative_l2_p95": 0.11789988934867349,
+            "relative_l2_max": 0.19904708995990741,
+            "weighted_relative_l2_mean": 0.008612040314153803,
+            "weighted_relative_frobenius": 0.007105333389532846,
+            "weighted_mean_cosine": 0.9996212089362276,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.980050565596075,
+            "mean_cosine": 0.9988970098862606,
+            "p05_cosine": 0.9930372589094937,
+            "relative_l2_mean": 0.02234897656608579,
+            "relative_l2_p95": 0.11789988934867349,
+            "relative_l2_max": 0.19904708995990741,
+            "weighted_relative_l2_mean": 0.008612040314153803,
+            "weighted_relative_frobenius": 0.007105333389532846,
+            "weighted_mean_cosine": 0.9996212089362276,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.144759,
+            "warm_p50_ms": 0.071448,
+            "warm_p95_ms": 0.08397744999999998,
+            "warm_p99_ms": 0.10604113999999999,
+            "samples_ms": [
+              0.074242,
+              0.073822,
+              0.074241,
+              0.073334,
+              0.074731,
+              0.071518,
+              0.072006,
+              0.070959,
+              0.071448,
+              0.071517,
+              0.071378,
+              0.069073,
+              0.069073,
+              0.071517,
+              0.069143,
+              0.069073,
+              0.069004,
+              0.070121,
+              0.072914,
+              0.071517,
+              0.071029,
+              0.071518,
+              0.117263,
+              0.073333,
+              0.071378,
+              0.070889,
+              0.071866,
+              0.070889,
+              0.070889,
+              0.070539,
+              0.071448,
+              0.071517,
+              0.071448,
+              0.070959,
+              0.072426,
+              0.070539,
+              0.070121,
+              0.088489,
+              0.08374,
+              0.071447
+            ],
+            "warm_rows_per_second": 7166050.834173105
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1908982,
+              "unique_rows": 3876,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 243,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3876
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "d94ce50a3aaa6506480e876528b4f8bb8bfc273d02285a4c6253bc232f78b662",
+            "table_sha256": "78ed4ab50acd0e1953318e8d063724ce18ae3ccd996b9f79f7d4e7b9abd2a5df",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2236357107758522,
+          "representatives_sha256": "adaf5dd35d194f4bd19e7f348d2d4e6f88cff8790b2d2bdb8d7d8eb345aac93f",
+          "structurally_merged_rows": 1457,
+          "backend_artifact_bytes": 1910184,
+          "backend_with_key_registry_bytes": 1981118,
+          "backend_with_datrie_key_index_bytes": 1953240,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.974592749547151,
+            "mean_cosine": 0.9988713550106368,
+            "p05_cosine": 0.9929501043360548,
+            "relative_l2_mean": 0.022588941888132666,
+            "relative_l2_p95": 0.11875619066074654,
+            "relative_l2_max": 0.2246727709380708,
+            "weighted_relative_l2_mean": 0.008680336560416798,
+            "weighted_relative_frobenius": 0.007114297581872774,
+            "weighted_mean_cosine": 0.9996139073324438,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.974592749547151,
+            "mean_cosine": 0.9988713550106368,
+            "p05_cosine": 0.9929501043360548,
+            "relative_l2_mean": 0.022588941888132666,
+            "relative_l2_p95": 0.11875619066074654,
+            "relative_l2_max": 0.2246727709380708,
+            "weighted_relative_l2_mean": 0.008680336560416798,
+            "weighted_relative_frobenius": 0.007114297581872774,
+            "weighted_mean_cosine": 0.9996139073324438,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.247844,
+            "warm_p50_ms": 0.07092399999999999,
+            "warm_p95_ms": 0.07503045,
+            "warm_p99_ms": 0.08090045,
+            "samples_ms": [
+              0.079409,
+              0.0748,
+              0.073822,
+              0.073822,
+              0.073333,
+              0.073333,
+              0.072844,
+              0.073333,
+              0.072845,
+              0.071099,
+              0.072006,
+              0.072355,
+              0.071518,
+              0.071029,
+              0.069981,
+              0.070889,
+              0.069492,
+              0.071378,
+              0.070959,
+              0.069143,
+              0.069492,
+              0.073893,
+              0.069073,
+              0.069492,
+              0.071028,
+              0.068584,
+              0.081854,
+              0.069562,
+              0.070889,
+              0.069423,
+              0.070121,
+              0.069073,
+              0.068514,
+              0.071517,
+              0.069073,
+              0.069073,
+              0.069562,
+              0.068654,
+              0.068095,
+              0.069143
+            ],
+            "warm_rows_per_second": 7218994.980542554
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1904168,
+              "unique_rows": 3866,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3866
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "55ea65a0c372435523a39ff35007088ad1ed00eb1d96f5ef67498de6c2250f0b",
+            "table_sha256": "323a389e405126fa74b4ccfce7f273d0be0103079868fcb3cdc9fca02ad37cd5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18119738181121647,
+          "representatives_sha256": "c8dc8fcd1fcfc72a5977c5b2a2e679a5707784d65f7950540f6c4f47c865e933",
+          "structurally_merged_rows": 1467,
+          "backend_artifact_bytes": 1905370,
+          "backend_with_key_registry_bytes": 1976304,
+          "backend_with_datrie_key_index_bytes": 1948426,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9510872301154241,
+            "mean_cosine": 0.9987918492822377,
+            "p05_cosine": 0.9927808823560548,
+            "relative_l2_mean": 0.023153683395507205,
+            "relative_l2_p95": 0.12037670247217518,
+            "relative_l2_max": 0.31151735584289914,
+            "weighted_relative_l2_mean": 0.00908691072317337,
+            "weighted_relative_frobenius": 0.008899206643852799,
+            "weighted_mean_cosine": 0.9995569912219132,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9510872301154241,
+            "mean_cosine": 0.9987918492822377,
+            "p05_cosine": 0.9927808823560548,
+            "relative_l2_mean": 0.023153683395507205,
+            "relative_l2_p95": 0.12037670247217518,
+            "relative_l2_max": 0.31151735584289914,
+            "weighted_relative_l2_mean": 0.00908691072317337,
+            "weighted_relative_frobenius": 0.008899206643852799,
+            "weighted_mean_cosine": 0.9995569912219132,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.751971,
+            "warm_p50_ms": 0.069632,
+            "warm_p95_ms": 0.07729035,
+            "warm_p99_ms": 0.08680057999999999,
+            "samples_ms": [
+              0.077245,
+              0.09233,
+              0.078152,
+              0.074242,
+              0.073753,
+              0.073822,
+              0.072007,
+              0.070889,
+              0.070889,
+              0.072845,
+              0.071378,
+              0.069492,
+              0.070051,
+              0.069143,
+              0.069562,
+              0.068095,
+              0.069632,
+              0.068584,
+              0.069492,
+              0.068584,
+              0.069981,
+              0.069492,
+              0.069143,
+              0.069143,
+              0.069004,
+              0.069143,
+              0.069073,
+              0.069004,
+              0.068654,
+              0.068165,
+              0.069562,
+              0.069631,
+              0.069981,
+              0.0704,
+              0.069981,
+              0.069073,
+              0.07005,
+              0.069981,
+              0.069981,
+              0.069632
+            ],
+            "warm_rows_per_second": 7352941.176470588
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2730496,
+              "artifact_bytes": 1901839,
+              "unique_rows": 3861,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 242,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3861
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "68eaa11999ab3221c4db3a9e438703b55d59bd2a50c27d15bd5cb056bcc6241d",
+            "table_sha256": "0197dd4a6473f21e2eac1ca153165eedc05861570240e9d5e4e159f2c6e1dff2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.180918226018548,
+          "representatives_sha256": "1075cc01ecee84c61b5d73b08234d943406ba73bfffd6143b6358618207444a4",
+          "structurally_merged_rows": 1472,
+          "backend_artifact_bytes": 1903041,
+          "backend_with_key_registry_bytes": 1973975,
+          "backend_with_datrie_key_index_bytes": 1946097,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9127493431159585,
+            "mean_cosine": 0.9986919900464016,
+            "p05_cosine": 0.9925640858758106,
+            "relative_l2_mean": 0.023674874425416603,
+            "relative_l2_p95": 0.12177663040843287,
+            "relative_l2_max": 0.4187222387947898,
+            "weighted_relative_l2_mean": 0.009475765678451318,
+            "weighted_relative_frobenius": 0.013167753291854253,
+            "weighted_mean_cosine": 0.9994853902004286,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9127493431159585,
+            "mean_cosine": 0.9986919900464016,
+            "p05_cosine": 0.9925640858758106,
+            "relative_l2_mean": 0.023674874425416603,
+            "relative_l2_p95": 0.12177663040843287,
+            "relative_l2_max": 0.4187222387947898,
+            "weighted_relative_l2_mean": 0.009475765678451318,
+            "weighted_relative_frobenius": 0.013167753291854253,
+            "weighted_mean_cosine": 0.9994853902004286,
+            "max_relative_norm_change": 0.010066885851052261
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.805959,
+            "warm_p50_ms": 0.070959,
+            "warm_p95_ms": 0.0743783,
+            "warm_p99_ms": 0.075638,
+            "samples_ms": [
+              0.075638,
+              0.073752,
+              0.075638,
+              0.073823,
+              0.073264,
+              0.073334,
+              0.074312,
+              0.072426,
+              0.072844,
+              0.072355,
+              0.072844,
+              0.072356,
+              0.073334,
+              0.072915,
+              0.069981,
+              0.073752,
+              0.071936,
+              0.072915,
+              0.070959,
+              0.070539,
+              0.070959,
+              0.0704,
+              0.070051,
+              0.071029,
+              0.07054,
+              0.070121,
+              0.070051,
+              0.069981,
+              0.069562,
+              0.07005,
+              0.07054,
+              0.07047,
+              0.069003,
+              0.069562,
+              0.069562,
+              0.069911,
+              0.069562,
+              0.07054,
+              0.070051,
+              0.070959
+            ],
+            "warm_rows_per_second": 7215434.264857171
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 1365248,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "31d7dd18c6916ca11b7d50daa0b11adb6c6761085215b2407cd691841766649b",
+            "table_sha256": "0ed0935ce9f5e17b24267182eca235c452de95389f0197f3762fa1b231326bce",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.017962428042665124,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1366052,
+          "backend_with_key_registry_bytes": 1436986,
+          "backend_with_datrie_key_index_bytes": 1409108,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999644045328,
+            "mean_cosine": 0.9999999789970508,
+            "p05_cosine": 0.9999999733072,
+            "relative_l2_mean": 0.00020670589716848589,
+            "relative_l2_p95": 0.00023385651072794117,
+            "relative_l2_max": 0.00026765789895794544,
+            "weighted_relative_l2_mean": 0.00020683610612723765,
+            "weighted_relative_frobenius": 0.00020894692652536232,
+            "weighted_mean_cosine": 0.9999999789186156,
+            "max_relative_norm_change": 0.00012501920765291697
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.450895,
+            "warm_p50_ms": 0.2200005,
+            "warm_p95_ms": 0.2322719,
+            "warm_p99_ms": 0.24794164999999999,
+            "samples_ms": [
+              0.222305,
+              0.257366,
+              0.223772,
+              0.221886,
+              0.220419,
+              0.220419,
+              0.21993,
+              0.220001,
+              0.220001,
+              0.22,
+              0.22,
+              0.219023,
+              0.219023,
+              0.220001,
+              0.219581,
+              0.220978,
+              0.219092,
+              0.219581,
+              0.219581,
+              0.233201,
+              0.221467,
+              0.219022,
+              0.219511,
+              0.22,
+              0.219511,
+              0.219511,
+              0.221397,
+              0.222864,
+              0.219511,
+              0.219511,
+              0.220489,
+              0.220978,
+              0.22049,
+              0.219581,
+              0.219093,
+              0.219162,
+              0.219023,
+              0.232223,
+              0.220489,
+              0.22007
+            ],
+            "warm_rows_per_second": 2327267.4380285502
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1328953,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "31d7dd18c6916ca11b7d50daa0b11adb6c6761085215b2407cd691841766649b",
+            "table_sha256": "ed4a1926028c10f5f42578dfcb839d0a5f1e1ec0218903327b75f854b6db8e60",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12861166195943952,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330158,
+          "backend_with_key_registry_bytes": 1401092,
+          "backend_with_datrie_key_index_bytes": 1373214,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999644045328,
+            "mean_cosine": 0.9999999789970508,
+            "p05_cosine": 0.9999999733072,
+            "relative_l2_mean": 0.00020670589716848589,
+            "relative_l2_p95": 0.00023385651072794117,
+            "relative_l2_max": 0.00026765789895794544,
+            "weighted_relative_l2_mean": 0.00020683610612723765,
+            "weighted_relative_frobenius": 0.00020894692652536232,
+            "weighted_mean_cosine": 0.9999999789186156,
+            "max_relative_norm_change": 0.00012501920765291697
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.093018,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.23618624999999996,
+            "warm_p99_ms": 0.2516672,
+            "samples_ms": [
+              0.232362,
+              0.230336,
+              0.235645,
+              0.231874,
+              0.230896,
+              0.230336,
+              0.230476,
+              0.22901,
+              0.229009,
+              0.228032,
+              0.228102,
+              0.227054,
+              0.227054,
+              0.228451,
+              0.228521,
+              0.227962,
+              0.25499,
+              0.230407,
+              0.228521,
+              0.229499,
+              0.229009,
+              0.228102,
+              0.227124,
+              0.228591,
+              0.22901,
+              0.228521,
+              0.228102,
+              0.22859,
+              0.228102,
+              0.226705,
+              0.227124,
+              0.228032,
+              0.227963,
+              0.227962,
+              0.24647,
+              0.229429,
+              0.227473,
+              0.228032,
+              0.229499,
+              0.228032
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1328953,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "31d7dd18c6916ca11b7d50daa0b11adb6c6761085215b2407cd691841766649b",
+            "table_sha256": "ed4a1926028c10f5f42578dfcb839d0a5f1e1ec0218903327b75f854b6db8e60",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15969895594753325,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330157,
+          "backend_with_key_registry_bytes": 1401091,
+          "backend_with_datrie_key_index_bytes": 1373213,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999644045328,
+            "mean_cosine": 0.9999999789970508,
+            "p05_cosine": 0.9999999733072,
+            "relative_l2_mean": 0.00020670589716848589,
+            "relative_l2_p95": 0.00023385651072794117,
+            "relative_l2_max": 0.00026765789895794544,
+            "weighted_relative_l2_mean": 0.00020683610612723765,
+            "weighted_relative_frobenius": 0.00020894692652536232,
+            "weighted_mean_cosine": 0.9999999789186156,
+            "max_relative_norm_change": 0.00012501920765291697
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.446904,
+            "warm_p50_ms": 0.277759,
+            "warm_p95_ms": 0.2962492,
+            "warm_p99_ms": 0.31126753999999995,
+            "samples_ms": [
+              0.230895,
+              0.230337,
+              0.22859,
+              0.229499,
+              0.258762,
+              0.282369,
+              0.278178,
+              0.277759,
+              0.275804,
+              0.282508,
+              0.278667,
+              0.298571,
+              0.280064,
+              0.278737,
+              0.280553,
+              0.277689,
+              0.296127,
+              0.241232,
+              0.229499,
+              0.228521,
+              0.227613,
+              0.229009,
+              0.228032,
+              0.228521,
+              0.228521,
+              0.228102,
+              0.227125,
+              0.319385,
+              0.279156,
+              0.280133,
+              0.282019,
+              0.277759,
+              0.279575,
+              0.278178,
+              0.279156,
+              0.275455,
+              0.277759,
+              0.273499,
+              0.279644,
+              0.28195
+            ],
+            "warm_rows_per_second": 1843324.6087435512
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1328953,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 167,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 167,
+              "zlib_blocks": 146,
+              "xor_blocks": 21,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "31d7dd18c6916ca11b7d50daa0b11adb6c6761085215b2407cd691841766649b",
+            "table_sha256": "ed4a1926028c10f5f42578dfcb839d0a5f1e1ec0218903327b75f854b6db8e60",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1359516391530633,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1330157,
+          "backend_with_key_registry_bytes": 1401091,
+          "backend_with_datrie_key_index_bytes": 1373213,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999644045328,
+            "mean_cosine": 0.9999999789970508,
+            "p05_cosine": 0.9999999733072,
+            "relative_l2_mean": 0.00020670589716848589,
+            "relative_l2_p95": 0.00023385651072794117,
+            "relative_l2_max": 0.00026765789895794544,
+            "weighted_relative_l2_mean": 0.00020683610612723765,
+            "weighted_relative_frobenius": 0.00020894692652536232,
+            "weighted_mean_cosine": 0.9999999789186156,
+            "max_relative_norm_change": 0.00012501920765291697
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.161113,
+            "warm_p50_ms": 0.22782249999999998,
+            "warm_p95_ms": 0.2777449,
+            "warm_p99_ms": 0.29136984,
+            "samples_ms": [
+              0.231873,
+              0.22894,
+              0.227543,
+              0.245981,
+              0.231385,
+              0.229079,
+              0.22908,
+              0.286768,
+              0.227683,
+              0.229987,
+              0.227613,
+              0.227124,
+              0.228521,
+              0.228451,
+              0.227544,
+              0.22901,
+              0.227474,
+              0.227962,
+              0.227124,
+              0.227613,
+              0.294312,
+              0.235155,
+              0.229988,
+              0.231314,
+              0.226636,
+              0.227613,
+              0.227683,
+              0.227613,
+              0.227543,
+              0.228032,
+              0.226077,
+              0.227543,
+              0.227124,
+              0.227543,
+              0.227613,
+              0.227543,
+              0.232781,
+              0.27727,
+              0.232711,
+              0.227543
+            ],
+            "warm_rows_per_second": 2247363.627385355
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 1009598,
+              "unique_rows": 3998,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 125,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3998
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "d82a65c6e1e5eaa45e3dec8e0290e765ae7e1907061d70e69f0cf90c0cd6fea7",
+            "table_sha256": "993bbb7fcf9cf986c66605694c2fc4593c7e071cff3183528670fc2614cd5584",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.11485298606567085,
+          "representatives_sha256": "440e2d6bdd0874af8f64f811c85840996a519b5535ca13cd99366b0737b6ceae",
+          "structurally_merged_rows": 1335,
+          "backend_artifact_bytes": 1010800,
+          "backend_with_key_registry_bytes": 1081734,
+          "backend_with_datrie_key_index_bytes": 1053856,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900297489440841,
+            "mean_cosine": 0.9991859754494833,
+            "p05_cosine": 0.9948008103489178,
+            "relative_l2_mean": 0.018964019676226754,
+            "relative_l2_p95": 0.1019787228960663,
+            "relative_l2_max": 0.14139286698093315,
+            "weighted_relative_l2_mean": 0.007774702292468263,
+            "weighted_relative_frobenius": 0.006792836185212061,
+            "weighted_mean_cosine": 0.9997045343265375,
+            "max_relative_norm_change": 0.010144653073261482
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900292416446087,
+            "mean_cosine": 0.9991859895150045,
+            "p05_cosine": 0.9948020602316103,
+            "relative_l2_mean": 0.018809038392007316,
+            "relative_l2_p95": 0.10196921350794233,
+            "relative_l2_max": 0.14139712152680467,
+            "weighted_relative_l2_mean": 0.007592158104580025,
+            "weighted_relative_frobenius": 0.0067896740613937155,
+            "weighted_mean_cosine": 0.9997045524928819,
+            "max_relative_norm_change": 0.010084202899738793
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.216859,
+            "warm_p50_ms": 0.228276,
+            "warm_p95_ms": 0.27095269999999994,
+            "warm_p99_ms": 0.31252341999999994,
+            "samples_ms": [
+              0.229918,
+              0.229498,
+              0.230407,
+              0.228032,
+              0.227613,
+              0.227613,
+              0.226635,
+              0.227054,
+              0.227962,
+              0.228032,
+              0.227613,
+              0.227194,
+              0.329302,
+              0.23327,
+              0.228591,
+              0.22852,
+              0.228032,
+              0.232781,
+              0.233759,
+              0.230896,
+              0.230476,
+              0.227543,
+              0.228521,
+              0.228521,
+              0.227194,
+              0.226147,
+              0.227473,
+              0.229429,
+              0.228521,
+              0.270146,
+              0.230825,
+              0.230407,
+              0.22901,
+              0.28628,
+              0.226635,
+              0.227683,
+              0.228032,
+              0.227543,
+              0.226565,
+              0.228032
+            ],
+            "warm_rows_per_second": 2242898.946888854
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 981368,
+              "unique_rows": 3882,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 122,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 122,
+              "zlib_blocks": 122,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3882
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "89f4f162ebd0c7b68354a2308b72e8317a36060395f1556936fc2274ec48ab62",
+            "table_sha256": "14be1afd3c9cf04650f676d4a8a403d19863c5a28aedb7b6799a22533f939520",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10346870590001345,
+          "representatives_sha256": "1861b5297294a7d87f4d7b3d1e73fd35fcb9f66791b206e956f8f266e337f62d",
+          "structurally_merged_rows": 1451,
+          "backend_artifact_bytes": 982569,
+          "backend_with_key_registry_bytes": 1053503,
+          "backend_with_datrie_key_index_bytes": 1025625,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800553769769432,
+            "mean_cosine": 0.9988970173074616,
+            "p05_cosine": 0.9930376882360196,
+            "relative_l2_mean": 0.022494958949884042,
+            "relative_l2_p95": 0.11788731479341936,
+            "relative_l2_max": 0.19902064111331721,
+            "weighted_relative_l2_mean": 0.0087958824132922,
+            "weighted_relative_frobenius": 0.007109698929287029,
+            "weighted_mean_cosine": 0.9996210633671456,
+            "max_relative_norm_change": 0.010144653073261482
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800556007168431,
+            "mean_cosine": 0.9988970348161804,
+            "p05_cosine": 0.9930386649816408,
+            "relative_l2_mean": 0.02234447086639264,
+            "relative_l2_p95": 0.11788397443690124,
+            "relative_l2_max": 0.19901867636766674,
+            "weighted_relative_l2_mean": 0.008614642592702672,
+            "weighted_relative_frobenius": 0.007106717676646518,
+            "weighted_mean_cosine": 0.9996210821053663,
+            "max_relative_norm_change": 0.010084202899738793
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.148693,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.2543934499999999,
+            "warm_p99_ms": 0.29506654,
+            "samples_ms": [
+              0.239905,
+              0.231803,
+              0.229359,
+              0.233689,
+              0.232781,
+              0.299479,
+              0.288165,
+              0.22901,
+              0.227613,
+              0.22901,
+              0.228101,
+              0.228032,
+              0.227054,
+              0.230895,
+              0.229498,
+              0.230826,
+              0.229499,
+              0.228521,
+              0.227543,
+              0.230895,
+              0.231803,
+              0.22901,
+              0.252616,
+              0.232293,
+              0.22894,
+              0.228102,
+              0.227543,
+              0.228102,
+              0.228101,
+              0.226636,
+              0.227962,
+              0.227543,
+              0.228451,
+              0.227543,
+              0.227613,
+              0.228521,
+              0.227543,
+              0.228102,
+              0.227124,
+              0.228521
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 979908,
+              "unique_rows": 3876,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 122,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 122,
+              "zlib_blocks": 122,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3876
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "206a08fd9da8392d4fc54e6f38a599574975df4d6f5e22ebe4f3be43d722ec68",
+            "table_sha256": "9388381cca8a68f49a1dfe4cce8cc8c12f19e2130a928103b6dd228e5f8070c2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10100568109191954,
+          "representatives_sha256": "4935ba9823018254815ad15642eaa99c21801c525d4d04b4494377ed343292bf",
+          "structurally_merged_rows": 1457,
+          "backend_artifact_bytes": 981109,
+          "backend_with_key_registry_bytes": 1052043,
+          "backend_with_datrie_key_index_bytes": 1024165,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9745920179413181,
+            "mean_cosine": 0.9988713623700916,
+            "p05_cosine": 0.9929502053254349,
+            "relative_l2_mean": 0.022734702380910424,
+            "relative_l2_p95": 0.11875486523989011,
+            "relative_l2_max": 0.22467937737027865,
+            "weighted_relative_l2_mean": 0.008864115507414503,
+            "weighted_relative_frobenius": 0.007118657593170506,
+            "weighted_mean_cosine": 0.9996137617457883,
+            "max_relative_norm_change": 0.010144653073261482
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9745930835830295,
+            "mean_cosine": 0.9988713824533704,
+            "p05_cosine": 0.9929487131771021,
+            "relative_l2_mean": 0.022584422313542345,
+            "relative_l2_p95": 0.11876937698750527,
+            "relative_l2_max": 0.22467708936171987,
+            "weighted_relative_l2_mean": 0.008682934890047607,
+            "weighted_relative_frobenius": 0.00711567916296217,
+            "weighted_mean_cosine": 0.9996137812167515,
+            "max_relative_norm_change": 0.010084202899738793
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.985963,
+            "warm_p50_ms": 0.228591,
+            "warm_p95_ms": 0.23533834999999992,
+            "warm_p99_ms": 0.26056118,
+            "samples_ms": [
+              0.232292,
+              0.234179,
+              0.232292,
+              0.229918,
+              0.22901,
+              0.22894,
+              0.22894,
+              0.229847,
+              0.229988,
+              0.229499,
+              0.22908,
+              0.257366,
+              0.2332,
+              0.228521,
+              0.226705,
+              0.228591,
+              0.228032,
+              0.227543,
+              0.227054,
+              0.226635,
+              0.228032,
+              0.227613,
+              0.228591,
+              0.228521,
+              0.226147,
+              0.22894,
+              0.229359,
+              0.232781,
+              0.262604,
+              0.232293,
+              0.227543,
+              0.227543,
+              0.229429,
+              0.227473,
+              0.228451,
+              0.226565,
+              0.226635,
+              0.228032,
+              0.226705,
+              0.228032
+            ],
+            "warm_rows_per_second": 2239808.216421469
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 977365,
+              "unique_rows": 3866,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3866
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "7efe602c6977216fc4abf2dca03750a0bebb93ff8e17327e8ee30e95772584a4",
+            "table_sha256": "151081f64e92a899110e41c9aef2788262d113c66230a7bf2a911a08dde0ee29",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10517758410423994,
+          "representatives_sha256": "e2028acf3fb33a1d82863d1469d2e27d2193ec91593a1f620da3f2f4aacda754",
+          "structurally_merged_rows": 1467,
+          "backend_artifact_bytes": 978566,
+          "backend_with_key_registry_bytes": 1049500,
+          "backend_with_datrie_key_index_bytes": 1021622,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9510868764099407,
+            "mean_cosine": 0.9987918573459835,
+            "p05_cosine": 0.9927821767369956,
+            "relative_l2_mean": 0.023299050710395626,
+            "relative_l2_p95": 0.12037584768935825,
+            "relative_l2_max": 0.3115171417508406,
+            "weighted_relative_l2_mean": 0.009270404592701302,
+            "weighted_relative_frobenius": 0.008902606932115491,
+            "weighted_mean_cosine": 0.9995568479061023,
+            "max_relative_norm_change": 0.010144653073261482
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9510758394745452,
+            "mean_cosine": 0.9987918781979689,
+            "p05_cosine": 0.992780348192306,
+            "relative_l2_mean": 0.02314915489090952,
+            "relative_l2_p95": 0.1203808277603667,
+            "relative_l2_max": 0.3115519347010528,
+            "weighted_relative_l2_mean": 0.009089482196330162,
+            "weighted_relative_frobenius": 0.008900056852594328,
+            "weighted_mean_cosine": 0.9995568722623082,
+            "max_relative_norm_change": 0.010084202899738793
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.922966,
+            "warm_p50_ms": 0.229045,
+            "warm_p95_ms": 0.24441994999999997,
+            "warm_p99_ms": 0.27214144,
+            "samples_ms": [
+              0.233759,
+              0.232292,
+              0.231314,
+              0.230407,
+              0.229498,
+              0.229499,
+              0.22894,
+              0.229429,
+              0.227962,
+              0.22894,
+              0.22901,
+              0.229917,
+              0.228521,
+              0.228591,
+              0.286768,
+              0.244165,
+              0.229988,
+              0.229918,
+              0.233759,
+              0.228102,
+              0.228032,
+              0.227474,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.227543,
+              0.228521,
+              0.228521,
+              0.227055,
+              0.22894,
+              0.228939,
+              0.231384,
+              0.249264,
+              0.230966,
+              0.23362,
+              0.232781,
+              0.229988,
+              0.22908,
+              0.226635,
+              0.227054
+            ],
+            "warm_rows_per_second": 2235368.595690803
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1365248,
+              "artifact_bytes": 976156,
+              "unique_rows": 3861,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 121,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 121,
+              "zlib_blocks": 121,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3861
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "05ff2c9ba69f563e1b4ebe145fcd35517d25e37a623cc252734285239838132c",
+            "table_sha256": "87034ecba5c013dc118a949b28a05e2c518a2c0af2f1834c000c6bf8db772f8f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10555849899537861,
+          "representatives_sha256": "35458ec71543f84bb961a8eb01e723c2636d5a7e881f6ebb28ac2fc7803d893e",
+          "structurally_merged_rows": 1472,
+          "backend_artifact_bytes": 977357,
+          "backend_with_key_registry_bytes": 1048291,
+          "backend_with_datrie_key_index_bytes": 1020413,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9127490251613625,
+            "mean_cosine": 0.9986919996624374,
+            "p05_cosine": 0.9925628236350986,
+            "relative_l2_mean": 0.023820038942016522,
+            "relative_l2_p95": 0.12178604963188834,
+            "relative_l2_max": 0.41871917428766875,
+            "weighted_relative_l2_mean": 0.009659084390710736,
+            "weighted_relative_frobenius": 0.013169823033350842,
+            "weighted_mean_cosine": 0.9994852500344135,
+            "max_relative_norm_change": 0.010144653073261482
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9127456807937895,
+            "mean_cosine": 0.9986920245008379,
+            "p05_cosine": 0.9925641423895385,
+            "relative_l2_mean": 0.023670324181361044,
+            "relative_l2_p95": 0.12176897934386684,
+            "relative_l2_max": 0.41873337973536934,
+            "weighted_relative_l2_mean": 0.009478314565333906,
+            "weighted_relative_frobenius": 0.01316775731103199,
+            "weighted_mean_cosine": 0.9994852786825348,
+            "max_relative_norm_change": 0.010084202899738793
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.896006,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.23533379999999998,
+            "warm_p99_ms": 0.25027555999999995,
+            "samples_ms": [
+              0.233759,
+              0.235016,
+              0.23334,
+              0.230406,
+              0.231803,
+              0.229918,
+              0.229918,
+              0.22852,
+              0.228521,
+              0.229498,
+              0.231385,
+              0.230896,
+              0.228451,
+              0.22901,
+              0.227962,
+              0.228521,
+              0.255968,
+              0.234178,
+              0.229499,
+              0.227473,
+              0.228521,
+              0.228521,
+              0.22901,
+              0.23327,
+              0.227124,
+              0.227054,
+              0.228032,
+              0.231803,
+              0.230895,
+              0.231315,
+              0.228451,
+              0.229429,
+              0.22894,
+              0.241372,
+              0.22901,
+              0.228032,
+              0.228591,
+              0.228591,
+              0.228032,
+              0.228102
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 703956,
+              "unique_rows": 5333,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "49c40289aa5709af39591af7618b4d2796626664399a25a1da1c9f1231474746",
+            "table_sha256": "39a5bfb46dcda9abae79229e8fb09380005212fafa61770793c05a633311fbe3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.013785704970359802,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 704803,
+          "backend_with_key_registry_bytes": 775737,
+          "backend_with_datrie_key_index_bytes": 747859,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999462992105821,
+            "mean_cosine": 0.9999792931538555,
+            "p05_cosine": 0.999968339662035,
+            "relative_l2_mean": 0.006403173405174251,
+            "relative_l2_p95": 0.007979164492074683,
+            "relative_l2_max": 0.010381556328689853,
+            "weighted_relative_l2_mean": 0.006403568186156278,
+            "weighted_relative_frobenius": 0.006504947549050006,
+            "weighted_mean_cosine": 0.9999792801327788,
+            "max_relative_norm_change": 0.002201939701089459
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.319874,
+            "warm_p50_ms": 0.122013,
+            "warm_p95_ms": 0.13200005,
+            "warm_p99_ms": 0.13493998,
+            "samples_ms": [
+              0.12348,
+              0.122501,
+              0.12348,
+              0.121105,
+              0.121593,
+              0.122502,
+              0.122013,
+              0.132,
+              0.132001,
+              0.121524,
+              0.122013,
+              0.121035,
+              0.120127,
+              0.122012,
+              0.122152,
+              0.122153,
+              0.136819,
+              0.121594,
+              0.121105,
+              0.122502,
+              0.122083,
+              0.121105,
+              0.121594,
+              0.120616,
+              0.121175,
+              0.121105,
+              0.122083,
+              0.121105,
+              0.122502,
+              0.12299,
+              0.121105,
+              0.121104,
+              0.121175,
+              0.120266,
+              0.122502,
+              0.121594,
+              0.122571,
+              0.122572,
+              0.12299,
+              0.12299
+            ],
+            "warm_rows_per_second": 4196274.167506741
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712456,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 37,
+              "xor_blocks": 49,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "49c40289aa5709af39591af7618b4d2796626664399a25a1da1c9f1231474746",
+            "table_sha256": "67b0076714b293ec1ce3a042ba79a1d455bff8813b1654e3d68f5c7df4f0ea40",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07455829693935812,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713700,
+          "backend_with_key_registry_bytes": 784634,
+          "backend_with_datrie_key_index_bytes": 756756,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999462992105821,
+            "mean_cosine": 0.9999792931538555,
+            "p05_cosine": 0.999968339662035,
+            "relative_l2_mean": 0.006403173405174251,
+            "relative_l2_p95": 0.007979164492074683,
+            "relative_l2_max": 0.010381556328689853,
+            "weighted_relative_l2_mean": 0.006403568186156278,
+            "weighted_relative_frobenius": 0.006504947549050006,
+            "weighted_mean_cosine": 0.9999792801327788,
+            "max_relative_norm_change": 0.002201939701089459
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.456565,
+            "warm_p50_ms": 0.1310575,
+            "warm_p95_ms": 0.14261905,
+            "warm_p99_ms": 0.16575328999999997,
+            "samples_ms": [
+              0.135771,
+              0.142406,
+              0.132978,
+              0.132489,
+              0.131022,
+              0.131022,
+              0.130603,
+              0.132489,
+              0.131092,
+              0.177956,
+              0.132489,
+              0.132001,
+              0.130603,
+              0.130184,
+              0.130185,
+              0.129696,
+              0.138635,
+              0.139124,
+              0.130534,
+              0.131023,
+              0.130115,
+              0.129696,
+              0.131582,
+              0.131023,
+              0.131511,
+              0.130114,
+              0.130603,
+              0.131022,
+              0.132,
+              0.129625,
+              0.131511,
+              0.131092,
+              0.130673,
+              0.130533,
+              0.134934,
+              0.129206,
+              0.129695,
+              0.134375,
+              0.146667,
+              0.131581
+            ],
+            "warm_rows_per_second": 3906682.181485226
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712456,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 37,
+              "xor_blocks": 49,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "49c40289aa5709af39591af7618b4d2796626664399a25a1da1c9f1231474746",
+            "table_sha256": "67b0076714b293ec1ce3a042ba79a1d455bff8813b1654e3d68f5c7df4f0ea40",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.09629292599856853,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713699,
+          "backend_with_key_registry_bytes": 784633,
+          "backend_with_datrie_key_index_bytes": 756755,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999462992105821,
+            "mean_cosine": 0.9999792931538555,
+            "p05_cosine": 0.999968339662035,
+            "relative_l2_mean": 0.006403173405174251,
+            "relative_l2_p95": 0.007979164492074683,
+            "relative_l2_max": 0.010381556328689853,
+            "weighted_relative_l2_mean": 0.006403568186156278,
+            "weighted_relative_frobenius": 0.006504947549050006,
+            "weighted_mean_cosine": 0.9999792801327788,
+            "max_relative_norm_change": 0.002201939701089459
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.487714,
+            "warm_p50_ms": 0.131023,
+            "warm_p95_ms": 0.1367044,
+            "warm_p99_ms": 0.1536563,
+            "samples_ms": [
+              0.135353,
+              0.13668,
+              0.133467,
+              0.129695,
+              0.136261,
+              0.132,
+              0.130114,
+              0.132419,
+              0.131511,
+              0.131093,
+              0.132908,
+              0.137168,
+              0.130114,
+              0.131022,
+              0.131022,
+              0.130533,
+              0.130603,
+              0.130603,
+              0.130533,
+              0.132,
+              0.129626,
+              0.164198,
+              0.132,
+              0.131511,
+              0.131511,
+              0.131581,
+              0.132,
+              0.130604,
+              0.130115,
+              0.131023,
+              0.130115,
+              0.130603,
+              0.130603,
+              0.130045,
+              0.131512,
+              0.130185,
+              0.130604,
+              0.131023,
+              0.130115,
+              0.131023
+            ],
+            "warm_rows_per_second": 3907710.8599253567
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 712456,
+              "unique_rows": 5333,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 87,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 86,
+              "zlib_blocks": 37,
+              "xor_blocks": 49,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 5333
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "49c40289aa5709af39591af7618b4d2796626664399a25a1da1c9f1231474746",
+            "table_sha256": "67b0076714b293ec1ce3a042ba79a1d455bff8813b1654e3d68f5c7df4f0ea40",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07648577890358865,
+          "representatives_sha256": "b87cb171f9ce05babadb9abe917f696021522d5fafe1c497d777370a59cf220d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 713699,
+          "backend_with_key_registry_bytes": 784633,
+          "backend_with_datrie_key_index_bytes": 756755,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999462992105821,
+            "mean_cosine": 0.9999792931538555,
+            "p05_cosine": 0.999968339662035,
+            "relative_l2_mean": 0.006403173405174251,
+            "relative_l2_p95": 0.007979164492074683,
+            "relative_l2_max": 0.010381556328689853,
+            "weighted_relative_l2_mean": 0.006403568186156278,
+            "weighted_relative_frobenius": 0.006504947549050006,
+            "weighted_mean_cosine": 0.9999792801327788,
+            "max_relative_norm_change": 0.002201939701089459
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.521378,
+            "warm_p50_ms": 0.131092,
+            "warm_p95_ms": 0.1372169,
+            "warm_p99_ms": 0.15403710999999998,
+            "samples_ms": [
+              0.138146,
+              0.134863,
+              0.132,
+              0.132,
+              0.130533,
+              0.131511,
+              0.131093,
+              0.130534,
+              0.135283,
+              0.132489,
+              0.133886,
+              0.132489,
+              0.130533,
+              0.131092,
+              0.131022,
+              0.13633,
+              0.130603,
+              0.131022,
+              0.131511,
+              0.132001,
+              0.131512,
+              0.130115,
+              0.130115,
+              0.130604,
+              0.164197,
+              0.137168,
+              0.130603,
+              0.130114,
+              0.130533,
+              0.130044,
+              0.129137,
+              0.130534,
+              0.129137,
+              0.128718,
+              0.130114,
+              0.130603,
+              0.131581,
+              0.13633,
+              0.131092,
+              0.132
+            ],
+            "warm_rows_per_second": 3905654.0444878405
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 549156,
+              "unique_rows": 3998,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 65,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 65,
+              "zlib_blocks": 65,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3998
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "aae123abfc4f71a68e7ec0af3535ffc6617e0834f1e0b1028025359d5084208c",
+            "table_sha256": "3c28cf8d5727899c9f383550f7241c82ac43bd61e46d4d4251dd8252acb30a83",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06409340887330472,
+          "representatives_sha256": "4b481ab0d27e04463dcd26f8162ab7756547ef8ca42c11f8f54d90b15ebf1883",
+          "structurally_merged_rows": 1335,
+          "backend_artifact_bytes": 550397,
+          "backend_with_key_registry_bytes": 621331,
+          "backend_with_datrie_key_index_bytes": 593453,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9899934222289732,
+            "mean_cosine": 0.9991632929825155,
+            "p05_cosine": 0.9947887591206397,
+            "relative_l2_mean": 0.023713495632551772,
+            "relative_l2_p95": 0.10212735134839708,
+            "relative_l2_max": 0.1417056444563921,
+            "weighted_relative_l2_mean": 0.013278828741218295,
+            "weighted_relative_frobenius": 0.00940051238979808,
+            "weighted_mean_cosine": 0.9996842272959379,
+            "max_relative_norm_change": 0.01097164479864802
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9900189817284225,
+            "mean_cosine": 0.9991737332185844,
+            "p05_cosine": 0.9947844121822593,
+            "relative_l2_mean": 0.01899638009320118,
+            "relative_l2_p95": 0.10218295670728121,
+            "relative_l2_max": 0.14142651092374273,
+            "weighted_relative_l2_mean": 0.00767327899498125,
+            "weighted_relative_frobenius": 0.006914346925094502,
+            "weighted_mean_cosine": 0.999700063737909,
+            "max_relative_norm_change": 0.010031623350154936
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.264164,
+            "warm_p50_ms": 0.131512,
+            "warm_p95_ms": 0.13653605,
+            "warm_p99_ms": 0.14164416,
+            "samples_ms": [
+              0.140451,
+              0.135772,
+              0.133956,
+              0.133816,
+              0.13633,
+              0.132908,
+              0.132978,
+              0.130603,
+              0.131022,
+              0.131512,
+              0.132908,
+              0.132978,
+              0.132,
+              0.130604,
+              0.131512,
+              0.131512,
+              0.131022,
+              0.132,
+              0.131022,
+              0.131092,
+              0.132,
+              0.131023,
+              0.131511,
+              0.132489,
+              0.131092,
+              0.131092,
+              0.13626,
+              0.132001,
+              0.142407,
+              0.131512,
+              0.130604,
+              0.131163,
+              0.132489,
+              0.131022,
+              0.131022,
+              0.130184,
+              0.131092,
+              0.129136,
+              0.130533,
+              0.130114
+            ],
+            "warm_rows_per_second": 3893180.850416692
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 534807,
+              "unique_rows": 3885,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3885
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "28ac3a00592d6854a1800e8d1c425a58515b10fe0f050b78fce37d6a702884c2",
+            "table_sha256": "1683f4fcdeece02634106cbcf8e679bf09d615129da3444cdb90789326bbb95d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0614638130646199,
+          "representatives_sha256": "e2ff6c1c1b12ba8084d1d0766d5491ea4619d8c7f76acb95dab2e151b9bc08ca",
+          "structurally_merged_rows": 1448,
+          "backend_artifact_bytes": 536048,
+          "backend_with_key_registry_bytes": 606982,
+          "backend_with_datrie_key_index_bytes": 579104,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800401744851072,
+            "mean_cosine": 0.9988806200285881,
+            "p05_cosine": 0.9930299198404723,
+            "relative_l2_mean": 0.02703043177233258,
+            "relative_l2_p95": 0.11799639536476662,
+            "relative_l2_max": 0.19908866256523516,
+            "weighted_relative_l2_mean": 0.014238363469704323,
+            "weighted_relative_frobenius": 0.009627358087898327,
+            "weighted_mean_cosine": 0.99960255758857,
+            "max_relative_norm_change": 0.01097164479864802
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9800988294273547,
+            "mean_cosine": 0.998890430134469,
+            "p05_cosine": 0.9929888872159995,
+            "relative_l2_mean": 0.02245089322008093,
+            "relative_l2_p95": 0.11850476828542113,
+            "relative_l2_max": 0.1987932467735768,
+            "weighted_relative_l2_mean": 0.008672756110095822,
+            "weighted_relative_frobenius": 0.007221971183909667,
+            "weighted_mean_cosine": 0.9996181977174599,
+            "max_relative_norm_change": 0.010031623350154936
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.222119,
+            "warm_p50_ms": 0.1322095,
+            "warm_p95_ms": 0.1349094,
+            "warm_p99_ms": 0.15426171,
+            "samples_ms": [
+              0.134863,
+              0.132908,
+              0.134374,
+              0.132,
+              0.132489,
+              0.132489,
+              0.130603,
+              0.135772,
+              0.132978,
+              0.134864,
+              0.132419,
+              0.130184,
+              0.132978,
+              0.132,
+              0.131093,
+              0.130534,
+              0.130603,
+              0.133886,
+              0.132,
+              0.131023,
+              0.131512,
+              0.131023,
+              0.131022,
+              0.134375,
+              0.133886,
+              0.131512,
+              0.134794,
+              0.134444,
+              0.166083,
+              0.133467,
+              0.131162,
+              0.132489,
+              0.133956,
+              0.131092,
+              0.130533,
+              0.130603,
+              0.130603,
+              0.130603,
+              0.129625,
+              0.132978
+            ],
+            "warm_rows_per_second": 3872641.527273002
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 534042,
+              "unique_rows": 3879,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3879
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "f69b24dbe40c19ba537d061ae1827fb052af652887b23876ca007bd0447136e5",
+            "table_sha256": "c1d551af235707630b731567b459b997766dc2e7c68dfdc452aafc7438ffc103",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06319161807186902,
+          "representatives_sha256": "dcec11d97205c1f7cd9e55c9be1a1ddfced8d21268c04e7cb3c02dd07fa9e577",
+          "structurally_merged_rows": 1454,
+          "backend_artifact_bytes": 535283,
+          "backend_with_key_registry_bytes": 606217,
+          "backend_with_datrie_key_index_bytes": 578339,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9746593100882213,
+            "mean_cosine": 0.9988549663087168,
+            "p05_cosine": 0.9929140091542047,
+            "relative_l2_mean": 0.027263932824013213,
+            "relative_l2_p95": 0.11901936063559732,
+            "relative_l2_max": 0.22429710615850762,
+            "weighted_relative_l2_mean": 0.014304819927630079,
+            "weighted_relative_frobenius": 0.009633974231074247,
+            "weighted_mean_cosine": 0.9995952563137235,
+            "max_relative_norm_change": 0.01097164479864802
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9747256332809409,
+            "mean_cosine": 0.9988647192842288,
+            "p05_cosine": 0.9929013771709432,
+            "relative_l2_mean": 0.02269106920580281,
+            "relative_l2_p95": 0.11919248437636946,
+            "relative_l2_max": 0.22395884382247594,
+            "weighted_relative_l2_mean": 0.008741112313097998,
+            "weighted_relative_frobenius": 0.007230809611545858,
+            "weighted_mean_cosine": 0.9996108801828067,
+            "max_relative_norm_change": 0.010031623350154936
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.142081,
+            "warm_p50_ms": 0.132245,
+            "warm_p95_ms": 0.13864179999999998,
+            "warm_p99_ms": 0.15049662,
+            "samples_ms": [
+              0.140101,
+              0.136261,
+              0.138565,
+              0.134724,
+              0.135283,
+              0.133467,
+              0.133886,
+              0.133467,
+              0.13633,
+              0.135212,
+              0.135702,
+              0.134864,
+              0.13668,
+              0.132909,
+              0.132489,
+              0.157143,
+              0.134863,
+              0.132,
+              0.132,
+              0.130115,
+              0.132001,
+              0.131093,
+              0.132,
+              0.130603,
+              0.132,
+              0.134375,
+              0.132,
+              0.131022,
+              0.132977,
+              0.132,
+              0.133397,
+              0.131022,
+              0.130114,
+              0.131512,
+              0.130604,
+              0.131512,
+              0.131511,
+              0.130603,
+              0.131581,
+              0.131022
+            ],
+            "warm_rows_per_second": 3871601.9509244207
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 532560,
+              "unique_rows": 3867,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 63,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3867
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "7b8a07f1b071e86d8514bb4249c7eeec40dc7ea14c98d8e8970c4c4a795f7c1a",
+            "table_sha256": "7a360b583fe1f338120c00165101d62a4216fde4a27a6198320713e01225ca80",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06164735509082675,
+          "representatives_sha256": "6640075131d383beb880b09f5208eb1b47e3ca8fcd0b3886ec27fcbe6b7d1ab8",
+          "structurally_merged_rows": 1466,
+          "backend_artifact_bytes": 533801,
+          "backend_with_key_registry_bytes": 604735,
+          "backend_with_datrie_key_index_bytes": 576857,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.9509876848478194,
+            "mean_cosine": 0.9987614785689874,
+            "p05_cosine": 0.9927806778831033,
+            "relative_l2_mean": 0.027916173556634682,
+            "relative_l2_p95": 0.1201832795122255,
+            "relative_l2_max": 0.311851238175594,
+            "weighted_relative_l2_mean": 0.014731416817497978,
+            "weighted_relative_frobenius": 0.011073839881895566,
+            "weighted_mean_cosine": 0.9995343569310857,
+            "max_relative_norm_change": 0.01097164479864802
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9509615279952359,
+            "mean_cosine": 0.9987712563715393,
+            "p05_cosine": 0.9927357309980902,
+            "relative_l2_mean": 0.023357600049515495,
+            "relative_l2_p95": 0.12065559752209504,
+            "relative_l2_max": 0.31193165760070524,
+            "weighted_relative_l2_mean": 0.009175777532520312,
+            "weighted_relative_frobenius": 0.009049998438847075,
+            "weighted_mean_cosine": 0.99955017708866,
+            "max_relative_norm_change": 0.010031623350154936
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.187129,
+            "warm_p50_ms": 0.1336415,
+            "warm_p95_ms": 0.1372834,
+            "warm_p99_ms": 0.14449426999999998,
+            "samples_ms": [
+              0.137168,
+              0.133397,
+              0.137238,
+              0.134794,
+              0.133466,
+              0.133886,
+              0.132489,
+              0.132419,
+              0.135283,
+              0.138146,
+              0.135702,
+              0.134864,
+              0.132489,
+              0.135772,
+              0.132419,
+              0.148553,
+              0.133816,
+              0.133467,
+              0.132001,
+              0.132489,
+              0.135353,
+              0.134864,
+              0.135282,
+              0.132978,
+              0.131092,
+              0.132489,
+              0.132978,
+              0.133397,
+              0.135283,
+              0.134864,
+              0.133816,
+              0.133397,
+              0.135771,
+              0.132978,
+              0.132908,
+              0.13675,
+              0.134864,
+              0.13242,
+              0.131581,
+              0.131511
+            ],
+            "warm_rows_per_second": 3831145.2655051015
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              5333,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 703956,
+              "artifact_bytes": 531805,
+              "unique_rows": 3861,
+              "row_map_bytes": 42664,
+              "n_rows": 5333,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 63,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 63,
+              "zlib_blocks": 62,
+              "xor_blocks": 1,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 3861
+            },
+            "source_float32_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966",
+            "decoded_float32_sha256": "e824ba3aae4a0129d26cdbf7d29d7fe22d50454ef80c15da374388e67f0bc0b7",
+            "table_sha256": "3864b7a9fc3c2be506a9fca7d7131b003f94db0fbbe851b34b63b60305fdec1b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0668308399617672,
+          "representatives_sha256": "f50613b9c916ca0c6b2ba4bcb1489ab2196e96f509a08f96ddfa1b4f7b6941e1",
+          "structurally_merged_rows": 1472,
+          "backend_artifact_bytes": 533046,
+          "backend_with_key_registry_bytes": 603980,
+          "backend_with_datrie_key_index_bytes": 576102,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 5333,
+            "minimum_cosine": 0.8996025209240703,
+            "mean_cosine": 0.9986426261248615,
+            "p05_cosine": 0.9925659301041087,
+            "relative_l2_mean": 0.02851507216503056,
+            "relative_l2_p95": 0.12180405322443522,
+            "relative_l2_max": 0.450476772178466,
+            "weighted_relative_l2_mean": 0.015210267558143175,
+            "weighted_relative_frobenius": 0.014919251451837928,
+            "weighted_mean_cosine": 0.999441083525298,
+            "max_relative_norm_change": 0.01097164479864802
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 5333,
+            "minimum_cosine": 0.9001643705394677,
+            "mean_cosine": 0.9986525094715527,
+            "p05_cosine": 0.9925633786418048,
+            "relative_l2_mean": 0.023963313369431437,
+            "relative_l2_p95": 0.12183598817005416,
+            "relative_l2_max": 0.44917041932412277,
+            "weighted_relative_l2_mean": 0.009661088397133939,
+            "weighted_relative_frobenius": 0.013479473656458102,
+            "weighted_mean_cosine": 0.9994570772808833,
+            "max_relative_norm_change": 0.010031623350154936
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.178119,
+            "warm_p50_ms": 0.132489,
+            "warm_p95_ms": 0.13957354999999996,
+            "warm_p99_ms": 0.15823072,
+            "samples_ms": [
+              0.135702,
+              0.133397,
+              0.133397,
+              0.132978,
+              0.131511,
+              0.131511,
+              0.148134,
+              0.137168,
+              0.139123,
+              0.132908,
+              0.133956,
+              0.133816,
+              0.132489,
+              0.131581,
+              0.133467,
+              0.131512,
+              0.133467,
+              0.132489,
+              0.134375,
+              0.134374,
+              0.131511,
+              0.131511,
+              0.135282,
+              0.132489,
+              0.132489,
+              0.131022,
+              0.130533,
+              0.132489,
+              0.130603,
+              0.131092,
+              0.130114,
+              0.132001,
+              0.133816,
+              0.131512,
+              0.132,
+              0.164686,
+              0.134794,
+              0.133397,
+              0.132419,
+              0.130603
+            ],
+            "warm_rows_per_second": 3864471.7674674885
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "36ddfdc77bbd89e4a6d29ace0eb8d7434db7c6aea2f962b09a109ebd23d40966"
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "rows": 13424,
+      "dim": 128,
+      "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+      "source_float32_bytes": 6873088,
+      "key_registry_bytes": 203948,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 108592,
+      "query_rows": 512,
+      "query_ids_sha256": "80ab83de1ecc982405671e980d9e9a66070e51aead43121126faabb6b44a50cd",
+      "frequency_trace_sha256": "1a0389197253d049e85973cd9812529ea0dc3eae69dcdb62085a34b49c0d90b8",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 6873088,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "table_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.036947192158550024,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6873893,
+          "backend_with_key_registry_bytes": 7077841,
+          "backend_with_datrie_key_index_bytes": 6982485,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.363315,
+            "warm_p50_ms": 0.060553,
+            "warm_p95_ms": 0.06190695,
+            "warm_p99_ms": 0.07662476999999998,
+            "samples_ms": [
+              0.061879,
+              0.060553,
+              0.085695,
+              0.060063,
+              0.060063,
+              0.060063,
+              0.06146,
+              0.062438,
+              0.060552,
+              0.060971,
+              0.061111,
+              0.06146,
+              0.060063,
+              0.060134,
+              0.060553,
+              0.059715,
+              0.06153,
+              0.060553,
+              0.061041,
+              0.059644,
+              0.06146,
+              0.061041,
+              0.060552,
+              0.059085,
+              0.059575,
+              0.060483,
+              0.0616,
+              0.060553,
+              0.061042,
+              0.060623,
+              0.060553,
+              0.060134,
+              0.060063,
+              0.060553,
+              0.061042,
+              0.060553,
+              0.060553,
+              0.0616,
+              0.059644,
+              0.060901
+            ],
+            "warm_rows_per_second": 8455402.705068287
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6480560,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 56,
+              "xor_blocks": 783,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "table_sha256": "1c958153046d8ba8ddd207bf7597464d496d4246381783d9c4446b6e678e8de0",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6004768090788275,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6481769,
+          "backend_with_key_registry_bytes": 6685717,
+          "backend_with_datrie_key_index_bytes": 6590361,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.405151,
+            "warm_p50_ms": 0.0724255,
+            "warm_p95_ms": 0.0771983,
+            "warm_p99_ms": 0.09488110999999999,
+            "samples_ms": [
+              0.07899,
+              0.076756,
+              0.075708,
+              0.105041,
+              0.077104,
+              0.075289,
+              0.07473,
+              0.075289,
+              0.074312,
+              0.074241,
+              0.074311,
+              0.075219,
+              0.071936,
+              0.071867,
+              0.072426,
+              0.072495,
+              0.072006,
+              0.071448,
+              0.07047,
+              0.073822,
+              0.071447,
+              0.071518,
+              0.071029,
+              0.071867,
+              0.072356,
+              0.072426,
+              0.072426,
+              0.072425,
+              0.072495,
+              0.071448,
+              0.071937,
+              0.071028,
+              0.072915,
+              0.072356,
+              0.071937,
+              0.072006,
+              0.07054,
+              0.071517,
+              0.07054,
+              0.076127
+            ],
+            "warm_rows_per_second": 7069333.314923611
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6480560,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 56,
+              "xor_blocks": 783,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "table_sha256": "1c958153046d8ba8ddd207bf7597464d496d4246381783d9c4446b6e678e8de0",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6389819530304521,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6481768,
+          "backend_with_key_registry_bytes": 6685716,
+          "backend_with_datrie_key_index_bytes": 6590360,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.377843,
+            "warm_p50_ms": 0.072006,
+            "warm_p95_ms": 0.07664395,
+            "warm_p99_ms": 0.09272450999999998,
+            "samples_ms": [
+              0.077175,
+              0.075219,
+              0.075288,
+              0.072426,
+              0.074312,
+              0.0748,
+              0.07473,
+              0.074241,
+              0.074311,
+              0.07473,
+              0.074242,
+              0.074242,
+              0.072356,
+              0.071797,
+              0.072355,
+              0.071866,
+              0.070889,
+              0.102666,
+              0.072356,
+              0.071937,
+              0.070051,
+              0.072426,
+              0.070051,
+              0.072006,
+              0.069981,
+              0.071866,
+              0.076616,
+              0.070051,
+              0.071448,
+              0.070051,
+              0.072006,
+              0.071448,
+              0.07047,
+              0.069911,
+              0.071867,
+              0.072355,
+              0.069981,
+              0.071867,
+              0.071447,
+              0.069632
+            ],
+            "warm_rows_per_second": 7110518.56789712
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6480560,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 56,
+              "xor_blocks": 783,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "table_sha256": "1c958153046d8ba8ddd207bf7597464d496d4246381783d9c4446b6e678e8de0",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5854424799326807,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6481768,
+          "backend_with_key_registry_bytes": 6685716,
+          "backend_with_datrie_key_index_bytes": 6590360,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.37484,
+            "warm_p50_ms": 0.071867,
+            "warm_p95_ms": 0.07780369999999999,
+            "warm_p99_ms": 0.08846669,
+            "samples_ms": [
+              0.077664,
+              0.080458,
+              0.074311,
+              0.07473,
+              0.093587,
+              0.077174,
+              0.075219,
+              0.071937,
+              0.072356,
+              0.073823,
+              0.073334,
+              0.073823,
+              0.072006,
+              0.072844,
+              0.071517,
+              0.073892,
+              0.072426,
+              0.071867,
+              0.071936,
+              0.072426,
+              0.070959,
+              0.071028,
+              0.070051,
+              0.071448,
+              0.070051,
+              0.071867,
+              0.071448,
+              0.069981,
+              0.0704,
+              0.069981,
+              0.071028,
+              0.0704,
+              0.071377,
+              0.07047,
+              0.070889,
+              0.071448,
+              0.07054,
+              0.071028,
+              0.07054,
+              0.073822
+            ],
+            "warm_rows_per_second": 7124271.223231804
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 4096126,
+              "unique_rows": 8305,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 520,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 519,
+              "zlib_blocks": 370,
+              "xor_blocks": 149,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8305
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "dc605d0a3b37e596c145e6d11c388507ab6c4bdbbea2a957dd48b38b2c13cc64",
+            "table_sha256": "458ad7e65187ad8d1b501429bd99d2ca31f6c807f52ba83e2d7d0c5a23d46755",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37950568506494164,
+          "representatives_sha256": "25fa7cbbb9d1e2e5d9cc53c8fe066b825fab9b925285db1c3e5875fab20eaa86",
+          "structurally_merged_rows": 5119,
+          "backend_artifact_bytes": 4097333,
+          "backend_with_key_registry_bytes": 4301281,
+          "backend_with_datrie_key_index_bytes": 4205925,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900126594367357,
+            "mean_cosine": 0.9985937157194625,
+            "p05_cosine": 0.9930711762913733,
+            "relative_l2_mean": 0.03088048812596691,
+            "relative_l2_p95": 0.11792570917396121,
+            "relative_l2_max": 0.14211742856778714,
+            "weighted_relative_l2_mean": 0.017521503643948114,
+            "weighted_relative_frobenius": 0.009587863324407826,
+            "weighted_mean_cosine": 0.9992425122949266,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900126594367357,
+            "mean_cosine": 0.9985937157194625,
+            "p05_cosine": 0.9930711762913733,
+            "relative_l2_mean": 0.03088048812596691,
+            "relative_l2_p95": 0.11792570917396121,
+            "relative_l2_max": 0.14211742856778714,
+            "weighted_relative_l2_mean": 0.017521503643948114,
+            "weighted_relative_frobenius": 0.009587863324407826,
+            "weighted_mean_cosine": 0.9992425122949266,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.31445,
+            "warm_p50_ms": 0.069632,
+            "warm_p95_ms": 0.07613045,
+            "warm_p99_ms": 0.09212980999999999,
+            "samples_ms": [
+              0.076196,
+              0.073333,
+              0.102317,
+              0.076127,
+              0.075219,
+              0.076127,
+              0.073823,
+              0.073264,
+              0.072356,
+              0.072915,
+              0.072425,
+              0.072844,
+              0.070121,
+              0.07054,
+              0.069981,
+              0.068166,
+              0.070051,
+              0.071028,
+              0.069073,
+              0.069003,
+              0.069073,
+              0.069073,
+              0.069562,
+              0.069143,
+              0.069074,
+              0.069003,
+              0.069632,
+              0.069074,
+              0.069073,
+              0.069562,
+              0.069004,
+              0.070051,
+              0.069632,
+              0.068165,
+              0.068584,
+              0.069073,
+              0.069143,
+              0.069003,
+              0.069492,
+              0.07012
+            ],
+            "warm_rows_per_second": 7352941.176470588
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3847377,
+              "unique_rows": 7785,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 487,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 487,
+              "zlib_blocks": 388,
+              "xor_blocks": 99,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7785
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "12223f8457285e033aa2aff4b723c3ca69d08120454890e32e1f1342c7859782",
+            "table_sha256": "2739ed9bd81b3f30b6293fd71b0cbcebf573f5ad5025994d16110cca7cdd7fac",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3562793149612844,
+          "representatives_sha256": "51abef867e22e4b21b773a2aaf8f2176e35911b200214cc09b84b2ff51efb3a1",
+          "structurally_merged_rows": 5639,
+          "backend_artifact_bytes": 3848583,
+          "backend_with_key_registry_bytes": 4052531,
+          "backend_with_datrie_key_index_bytes": 3957175,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9801116849489457,
+            "mean_cosine": 0.9980497479485829,
+            "p05_cosine": 0.9906083903349477,
+            "relative_l2_mean": 0.03735267712132519,
+            "relative_l2_p95": 0.13703607338904397,
+            "relative_l2_max": 0.20024584710789572,
+            "weighted_relative_l2_mean": 0.020662773018602778,
+            "weighted_relative_frobenius": 0.010050265018434344,
+            "weighted_mean_cosine": 0.9989785122367599,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9801116849489457,
+            "mean_cosine": 0.9980497479485829,
+            "p05_cosine": 0.9906083903349477,
+            "relative_l2_mean": 0.03735267712132519,
+            "relative_l2_p95": 0.13703607338904397,
+            "relative_l2_max": 0.20024584710789572,
+            "weighted_relative_l2_mean": 0.020662773018602778,
+            "weighted_relative_frobenius": 0.010050265018434344,
+            "weighted_mean_cosine": 0.9989785122367599,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.490381,
+            "warm_p50_ms": 0.069981,
+            "warm_p95_ms": 0.07344919999999999,
+            "warm_p99_ms": 0.0756807,
+            "samples_ms": [
+              0.075638,
+              0.073334,
+              0.075708,
+              0.072845,
+              0.072845,
+              0.072845,
+              0.072356,
+              0.07047,
+              0.071448,
+              0.071377,
+              0.071378,
+              0.071448,
+              0.070539,
+              0.071029,
+              0.071028,
+              0.07054,
+              0.068585,
+              0.069562,
+              0.069003,
+              0.069003,
+              0.069143,
+              0.069073,
+              0.069003,
+              0.069074,
+              0.069073,
+              0.068584,
+              0.069073,
+              0.068096,
+              0.068654,
+              0.069073,
+              0.069981,
+              0.069492,
+              0.069562,
+              0.070539,
+              0.07047,
+              0.069492,
+              0.07054,
+              0.069981,
+              0.069981,
+              0.069492
+            ],
+            "warm_rows_per_second": 7316271.559423272
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3814746,
+              "unique_rows": 7716,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 483,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 483,
+              "zlib_blocks": 383,
+              "xor_blocks": 100,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7716
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "c1a3d5cd5433063d3d18270293cda41808482290a5b8ce0cfb9919b812db7933",
+            "table_sha256": "8aab45d929724120ca9235ab2e8a16e5676eb92a106e183c7686cc680cf24f15",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3821442211046815,
+          "representatives_sha256": "571db57df46df6ae8c314e1e6b2e66dea12151fbaf5130c80f961307e39296da",
+          "structurally_merged_rows": 5708,
+          "backend_artifact_bytes": 3815953,
+          "backend_with_key_registry_bytes": 4019901,
+          "backend_with_datrie_key_index_bytes": 3924545,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.970343081661601,
+            "mean_cosine": 0.9979239946075346,
+            "p05_cosine": 0.9900978443322698,
+            "relative_l2_mean": 0.03848967424519778,
+            "relative_l2_p95": 0.14086231295128412,
+            "relative_l2_max": 0.24497659089464754,
+            "weighted_relative_l2_mean": 0.021211546951327244,
+            "weighted_relative_frobenius": 0.010113759652953795,
+            "weighted_mean_cosine": 0.99891781713554,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.970343081661601,
+            "mean_cosine": 0.9979239946075346,
+            "p05_cosine": 0.9900978443322698,
+            "relative_l2_mean": 0.03848967424519778,
+            "relative_l2_p95": 0.14086231295128412,
+            "relative_l2_max": 0.24497659089464754,
+            "weighted_relative_l2_mean": 0.021211546951327244,
+            "weighted_relative_frobenius": 0.010113759652953795,
+            "weighted_mean_cosine": 0.99891781713554,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.277993,
+            "warm_p50_ms": 0.0710285,
+            "warm_p95_ms": 0.0747789,
+            "warm_p99_ms": 0.08895780999999998,
+            "samples_ms": [
+              0.075708,
+              0.07473,
+              0.07473,
+              0.072844,
+              0.072355,
+              0.072355,
+              0.071937,
+              0.072356,
+              0.071936,
+              0.072006,
+              0.072495,
+              0.074241,
+              0.071937,
+              0.071029,
+              0.071028,
+              0.070121,
+              0.071028,
+              0.071378,
+              0.071378,
+              0.070889,
+              0.069981,
+              0.069981,
+              0.069632,
+              0.069981,
+              0.069981,
+              0.071867,
+              0.069981,
+              0.070051,
+              0.070051,
+              0.069492,
+              0.097429,
+              0.072425,
+              0.070051,
+              0.069492,
+              0.069981,
+              0.071029,
+              0.070051,
+              0.070959,
+              0.069492,
+              0.069911
+            ],
+            "warm_rows_per_second": 7208374.10335288
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3804432,
+              "unique_rows": 7696,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 481,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 481,
+              "zlib_blocks": 381,
+              "xor_blocks": 100,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7696
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "c7f75a54b1f5d74974e2b6334235f06471c9bb162f668cde6cd109269e64a611",
+            "table_sha256": "59e5334f1e93fe7fedf5cec6d9222c38ee6cae22ff80ee758577ba9c84647f46",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3475266571622342,
+          "representatives_sha256": "2e9e6d353edbf6a33317e108cefb746a100f4890e40169f11fd6c96afef18d88",
+          "structurally_merged_rows": 5728,
+          "backend_artifact_bytes": 3805639,
+          "backend_with_key_registry_bytes": 4009587,
+          "backend_with_datrie_key_index_bytes": 3914231,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9515267263969356,
+            "mean_cosine": 0.9978276087481274,
+            "p05_cosine": 0.989916908259933,
+            "relative_l2_mean": 0.03913300939645236,
+            "relative_l2_p95": 0.14200964850446474,
+            "relative_l2_max": 0.31035210487769166,
+            "weighted_relative_l2_mean": 0.0215610588496456,
+            "weighted_relative_frobenius": 0.011062901641116845,
+            "weighted_mean_cosine": 0.9988659972406398,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9515267263969356,
+            "mean_cosine": 0.9978276087481274,
+            "p05_cosine": 0.989916908259933,
+            "relative_l2_mean": 0.03913300939645236,
+            "relative_l2_p95": 0.14200964850446474,
+            "relative_l2_max": 0.31035210487769166,
+            "weighted_relative_l2_mean": 0.0215610588496456,
+            "weighted_relative_frobenius": 0.011062901641116845,
+            "weighted_mean_cosine": 0.9988659972406398,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.476272,
+            "warm_p50_ms": 0.070435,
+            "warm_p95_ms": 0.07289389999999998,
+            "warm_p99_ms": 0.09405913999999999,
+            "samples_ms": [
+              0.073823,
+              0.071378,
+              0.072425,
+              0.071866,
+              0.071448,
+              0.072356,
+              0.072845,
+              0.07047,
+              0.071937,
+              0.072845,
+              0.072356,
+              0.071378,
+              0.070889,
+              0.071448,
+              0.069143,
+              0.069073,
+              0.106997,
+              0.070051,
+              0.07047,
+              0.068165,
+              0.070051,
+              0.07047,
+              0.0704,
+              0.069981,
+              0.069632,
+              0.069073,
+              0.069911,
+              0.068235,
+              0.068654,
+              0.070889,
+              0.070959,
+              0.069632,
+              0.070959,
+              0.069562,
+              0.068095,
+              0.069143,
+              0.069562,
+              0.069492,
+              0.070121,
+              0.069562
+            ],
+            "warm_rows_per_second": 7269113.366934053
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3798092,
+              "unique_rows": 7682,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 481,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 481,
+              "zlib_blocks": 391,
+              "xor_blocks": 90,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7682
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "24bed3551c44c8f6a7587e26c7fa086581fe8706a07bb5672f4f3aa298697be7",
+            "table_sha256": "8d1a5bb633ab680ffcbb3fa549a2f65ede3aa2d56cee75db9fe171ff5c96dc89",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4390689739957452,
+          "representatives_sha256": "02853bc63111f33dfd64232ee44c0a3dac0182bc7fffccb4618903cecbcd5a0f",
+          "structurally_merged_rows": 5742,
+          "backend_artifact_bytes": 3799298,
+          "backend_with_key_registry_bytes": 4003246,
+          "backend_with_datrie_key_index_bytes": 3907890,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.901636957934259,
+            "mean_cosine": 0.9976914672684307,
+            "p05_cosine": 0.9897294932832881,
+            "relative_l2_mean": 0.03979940049850905,
+            "relative_l2_p95": 0.14344509893530952,
+            "relative_l2_max": 0.44557719917122357,
+            "weighted_relative_l2_mean": 0.022108816306860343,
+            "weighted_relative_frobenius": 0.01276195516775435,
+            "weighted_mean_cosine": 0.998756420601568,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.901636957934259,
+            "mean_cosine": 0.9976914672684307,
+            "p05_cosine": 0.9897294932832881,
+            "relative_l2_mean": 0.03979940049850905,
+            "relative_l2_p95": 0.14344509893530952,
+            "relative_l2_max": 0.44557719917122357,
+            "weighted_relative_l2_mean": 0.022108816306860343,
+            "weighted_relative_frobenius": 0.01276195516775435,
+            "weighted_mean_cosine": 0.998756420601568,
+            "max_relative_norm_change": 0.010085628995169935
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.45546,
+            "warm_p50_ms": 0.07047,
+            "warm_p95_ms": 0.0729593,
+            "warm_p99_ms": 0.08933676999999998,
+            "samples_ms": [
+              0.07515,
+              0.072844,
+              0.072425,
+              0.072356,
+              0.0704,
+              0.071867,
+              0.071378,
+              0.071378,
+              0.071866,
+              0.071867,
+              0.072775,
+              0.072844,
+              0.072425,
+              0.072355,
+              0.071936,
+              0.069073,
+              0.0704,
+              0.07047,
+              0.068235,
+              0.07047,
+              0.07047,
+              0.070051,
+              0.07054,
+              0.070051,
+              0.069562,
+              0.069911,
+              0.07047,
+              0.071029,
+              0.07012,
+              0.07054,
+              0.069981,
+              0.098407,
+              0.071867,
+              0.0704,
+              0.07047,
+              0.069561,
+              0.070051,
+              0.069073,
+              0.069981,
+              0.069632
+            ],
+            "warm_rows_per_second": 7265503.050943663
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3436544,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "df8b79955d7468b7b2f0161394c5f6357e57ff0ab38d908a1ce9d750765b1361",
+            "table_sha256": "6246b2b9b270b1f329de11d92199f3fb5bb751123b26cb5a9f7b789465490a8b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.042963535990566015,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3437350,
+          "backend_with_key_registry_bytes": 3641298,
+          "backend_with_datrie_key_index_bytes": 3545942,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999651577072,
+            "mean_cosine": 0.9999999790112526,
+            "p05_cosine": 0.9999999732767585,
+            "relative_l2_mean": 0.00020655615851127175,
+            "relative_l2_p95": 0.00023390014156990472,
+            "relative_l2_max": 0.0002665638639023805,
+            "weighted_relative_l2_mean": 0.00020622079510946033,
+            "weighted_relative_frobenius": 0.00020596156618784485,
+            "weighted_mean_cosine": 0.9999999790907921,
+            "max_relative_norm_change": 0.0001125115961258942
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.486375,
+            "warm_p50_ms": 0.22,
+            "warm_p95_ms": 0.23145480000000002,
+            "warm_p99_ms": 0.24982195999999995,
+            "samples_ms": [
+              0.220978,
+              0.220489,
+              0.260717,
+              0.221467,
+              0.220978,
+              0.22475,
+              0.219023,
+              0.219931,
+              0.219023,
+              0.22,
+              0.219512,
+              0.220001,
+              0.218674,
+              0.220001,
+              0.220489,
+              0.218604,
+              0.220419,
+              0.21993,
+              0.22426,
+              0.231385,
+              0.220908,
+              0.219022,
+              0.219092,
+              0.219092,
+              0.218603,
+              0.22007,
+              0.219511,
+              0.219022,
+              0.219022,
+              0.219511,
+              0.22,
+              0.22,
+              0.218114,
+              0.220489,
+              0.219511,
+              0.219441,
+              0.219511,
+              0.232781,
+              0.221886,
+              0.221886
+            ],
+            "warm_rows_per_second": 2327272.727272727
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3247131,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "df8b79955d7468b7b2f0161394c5f6357e57ff0ab38d908a1ce9d750765b1361",
+            "table_sha256": "f868590cc6cca6b19dcc63977294a94461d481250dc1489640b26f6f449582fc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.33485457277856767,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3248340,
+          "backend_with_key_registry_bytes": 3452288,
+          "backend_with_datrie_key_index_bytes": 3356932,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999651577072,
+            "mean_cosine": 0.9999999790112526,
+            "p05_cosine": 0.9999999732767585,
+            "relative_l2_mean": 0.00020655615851127175,
+            "relative_l2_p95": 0.00023390014156990472,
+            "relative_l2_max": 0.0002665638639023805,
+            "weighted_relative_l2_mean": 0.00020622079510946033,
+            "weighted_relative_frobenius": 0.00020596156618784485,
+            "weighted_mean_cosine": 0.9999999790907921,
+            "max_relative_norm_change": 0.0001125115961258942
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.104495,
+            "warm_p50_ms": 0.229499,
+            "warm_p95_ms": 0.23576705,
+            "warm_p99_ms": 0.24346335,
+            "samples_ms": [
+              0.231385,
+              0.230826,
+              0.229918,
+              0.230336,
+              0.229499,
+              0.234667,
+              0.230825,
+              0.230896,
+              0.22894,
+              0.235575,
+              0.229988,
+              0.22894,
+              0.228939,
+              0.228032,
+              0.239416,
+              0.231804,
+              0.230406,
+              0.229987,
+              0.22894,
+              0.228451,
+              0.22894,
+              0.22901,
+              0.235086,
+              0.228521,
+              0.228521,
+              0.22901,
+              0.235575,
+              0.230896,
+              0.229499,
+              0.228591,
+              0.228591,
+              0.246051,
+              0.231384,
+              0.22894,
+              0.228451,
+              0.227473,
+              0.228521,
+              0.22901,
+              0.22901,
+              0.235086
+            ],
+            "warm_rows_per_second": 2230946.54007207
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3247131,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "df8b79955d7468b7b2f0161394c5f6357e57ff0ab38d908a1ce9d750765b1361",
+            "table_sha256": "f868590cc6cca6b19dcc63977294a94461d481250dc1489640b26f6f449582fc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37537303287535906,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3248339,
+          "backend_with_key_registry_bytes": 3452287,
+          "backend_with_datrie_key_index_bytes": 3356931,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999651577072,
+            "mean_cosine": 0.9999999790112526,
+            "p05_cosine": 0.9999999732767585,
+            "relative_l2_mean": 0.00020655615851127175,
+            "relative_l2_p95": 0.00023390014156990472,
+            "relative_l2_max": 0.0002665638639023805,
+            "weighted_relative_l2_mean": 0.00020622079510946033,
+            "weighted_relative_frobenius": 0.00020596156618784485,
+            "weighted_mean_cosine": 0.9999999790907921,
+            "max_relative_norm_change": 0.0001125115961258942
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.122096,
+            "warm_p50_ms": 0.2292195,
+            "warm_p95_ms": 0.23530269999999998,
+            "warm_p99_ms": 0.25095052,
+            "samples_ms": [
+              0.232362,
+              0.231314,
+              0.230406,
+              0.230407,
+              0.234597,
+              0.230895,
+              0.230406,
+              0.229988,
+              0.254083,
+              0.234737,
+              0.229988,
+              0.229917,
+              0.228451,
+              0.229429,
+              0.22894,
+              0.228032,
+              0.234597,
+              0.228032,
+              0.228102,
+              0.22859,
+              0.22901,
+              0.232711,
+              0.228032,
+              0.227962,
+              0.227543,
+              0.22852,
+              0.246051,
+              0.230406,
+              0.228521,
+              0.228591,
+              0.228521,
+              0.228591,
+              0.228521,
+              0.228591,
+              0.230406,
+              0.229499,
+              0.22901,
+              0.228591,
+              0.234736,
+              0.228521
+            ],
+            "warm_rows_per_second": 2233666.856441097
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3247131,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "df8b79955d7468b7b2f0161394c5f6357e57ff0ab38d908a1ce9d750765b1361",
+            "table_sha256": "f868590cc6cca6b19dcc63977294a94461d481250dc1489640b26f6f449582fc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3818764500319958,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3248339,
+          "backend_with_key_registry_bytes": 3452287,
+          "backend_with_datrie_key_index_bytes": 3356931,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999651577072,
+            "mean_cosine": 0.9999999790112526,
+            "p05_cosine": 0.9999999732767585,
+            "relative_l2_mean": 0.00020655615851127175,
+            "relative_l2_p95": 0.00023390014156990472,
+            "relative_l2_max": 0.0002665638639023805,
+            "weighted_relative_l2_mean": 0.00020622079510946033,
+            "weighted_relative_frobenius": 0.00020596156618784485,
+            "weighted_mean_cosine": 0.9999999790907921,
+            "max_relative_norm_change": 0.0001125115961258942
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.069994,
+            "warm_p50_ms": 0.229499,
+            "warm_p95_ms": 0.23416409999999996,
+            "warm_p99_ms": 0.25996763,
+            "samples_ms": [
+              0.232292,
+              0.230337,
+              0.230477,
+              0.229848,
+              0.22894,
+              0.229918,
+              0.230895,
+              0.22901,
+              0.229429,
+              0.229428,
+              0.229429,
+              0.228451,
+              0.229429,
+              0.233759,
+              0.230477,
+              0.241861,
+              0.231384,
+              0.229499,
+              0.229429,
+              0.229499,
+              0.230337,
+              0.22894,
+              0.22894,
+              0.227613,
+              0.229918,
+              0.229499,
+              0.229498,
+              0.228591,
+              0.229429,
+              0.228102,
+              0.230406,
+              0.229499,
+              0.271544,
+              0.232781,
+              0.229988,
+              0.227613,
+              0.233759,
+              0.228032,
+              0.229429,
+              0.22894
+            ],
+            "warm_rows_per_second": 2230946.54007207
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 2103141,
+              "unique_rows": 8304,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 260,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 260,
+              "zlib_blocks": 120,
+              "xor_blocks": 140,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8304
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "c647a6f03ff7d8da1493c385fa42746f8c9039f23e5ece75eaa237d5dbf9a646",
+            "table_sha256": "33122735c092e5b915a27d2fb2a526daf8c59506737d12440e551b43cc0ab2a9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2212739558890462,
+          "representatives_sha256": "f339349bb2cc6141baa1aed94f7e1bb07d53085b7f1721899cf616772aaac17e",
+          "structurally_merged_rows": 5120,
+          "backend_artifact_bytes": 2104348,
+          "backend_with_key_registry_bytes": 2308296,
+          "backend_with_datrie_key_index_bytes": 2212940,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.989995664652372,
+            "mean_cosine": 0.9985917131225744,
+            "p05_cosine": 0.9930612603811456,
+            "relative_l2_mean": 0.03102973626034901,
+            "relative_l2_p95": 0.11799753123837675,
+            "relative_l2_max": 0.14211255515914975,
+            "weighted_relative_l2_mean": 0.017689505161649466,
+            "weighted_relative_frobenius": 0.009591286480164959,
+            "weighted_mean_cosine": 0.9992415348598541,
+            "max_relative_norm_change": 0.01011448738647392
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900020103581858,
+            "mean_cosine": 0.9985917223456484,
+            "p05_cosine": 0.9930604868870606,
+            "relative_l2_mean": 0.0309019783063906,
+            "relative_l2_p95": 0.1179895543875637,
+            "relative_l2_max": 0.14213321561707243,
+            "weighted_relative_l2_mean": 0.017532013358679342,
+            "weighted_relative_frobenius": 0.009589247498575619,
+            "weighted_mean_cosine": 0.999241545341953,
+            "max_relative_norm_change": 0.010090500650870148
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.969376,
+            "warm_p50_ms": 0.228032,
+            "warm_p95_ms": 0.23362954999999996,
+            "warm_p99_ms": 0.25533849,
+            "samples_ms": [
+              0.230895,
+              0.22901,
+              0.228032,
+              0.227543,
+              0.227055,
+              0.229429,
+              0.229009,
+              0.228451,
+              0.229428,
+              0.264,
+              0.2332,
+              0.228102,
+              0.229429,
+              0.228032,
+              0.228032,
+              0.228521,
+              0.226146,
+              0.227683,
+              0.227124,
+              0.228032,
+              0.227963,
+              0.232711,
+              0.228032,
+              0.228101,
+              0.227613,
+              0.228102,
+              0.228032,
+              0.241791,
+              0.228452,
+              0.227613,
+              0.228032,
+              0.22901,
+              0.226216,
+              0.227124,
+              0.232782,
+              0.227194,
+              0.227124,
+              0.227124,
+              0.226565,
+              0.22852
+            ],
+            "warm_rows_per_second": 2245298.9054167834
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1981949,
+              "unique_rows": 7789,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 244,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 244,
+              "zlib_blocks": 143,
+              "xor_blocks": 101,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7789
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "ab0bb6a4d9becd73d5eba51dc6803ed34e58748286692c8621a31a98fff5db40",
+            "table_sha256": "ac87a3e6bfad8be0da8a26f5034b1f44aa92c96cfdfddf7c310b644585d871e7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3681252470705658,
+          "representatives_sha256": "f25871770dac13fbc1e80ab01dc281b8096a2ddd742b8ef54af18ea84a9a057d",
+          "structurally_merged_rows": 5635,
+          "backend_artifact_bytes": 1983156,
+          "backend_with_key_registry_bytes": 2187104,
+          "backend_with_datrie_key_index_bytes": 2091748,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9801100636412576,
+            "mean_cosine": 0.99805187141531,
+            "p05_cosine": 0.9906073219999877,
+            "relative_l2_mean": 0.037439422532174416,
+            "relative_l2_p95": 0.1369488420509971,
+            "relative_l2_max": 0.20023657268276374,
+            "weighted_relative_l2_mean": 0.020800583754423056,
+            "weighted_relative_frobenius": 0.010050334109087993,
+            "weighted_mean_cosine": 0.9989795261793699,
+            "max_relative_norm_change": 0.010117918800127386
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9801145590004429,
+            "mean_cosine": 0.9980518783295492,
+            "p05_cosine": 0.9906054580284465,
+            "relative_l2_mean": 0.03731964535769372,
+            "relative_l2_p95": 0.13695811856336337,
+            "relative_l2_max": 0.20022589783209746,
+            "weighted_relative_l2_mean": 0.020646967196899225,
+            "weighted_relative_frobenius": 0.01004836675400962,
+            "weighted_mean_cosine": 0.9989795356859189,
+            "max_relative_norm_change": 0.010099054117758131
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.729051,
+            "warm_p50_ms": 0.2289745,
+            "warm_p95_ms": 0.23418489999999997,
+            "warm_p99_ms": 0.25485357,
+            "samples_ms": [
+              0.232781,
+              0.231803,
+              0.2332,
+              0.229987,
+              0.229918,
+              0.228521,
+              0.229429,
+              0.230407,
+              0.22894,
+              0.22894,
+              0.228521,
+              0.243607,
+              0.230896,
+              0.229499,
+              0.229498,
+              0.228102,
+              0.229499,
+              0.228521,
+              0.229917,
+              0.229918,
+              0.228521,
+              0.22894,
+              0.227544,
+              0.228521,
+              0.229009,
+              0.228032,
+              0.228102,
+              0.229499,
+              0.262044,
+              0.232851,
+              0.229079,
+              0.228102,
+              0.233689,
+              0.22894,
+              0.226984,
+              0.228521,
+              0.22894,
+              0.227054,
+              0.228451,
+              0.228451
+            ],
+            "warm_rows_per_second": 2236056.8534924197
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1965068,
+              "unique_rows": 7719,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 150,
+              "xor_blocks": 92,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7719
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "ff83a0d8fb9627fde316cd06428c16c905df3ca890ce92dbcfc81cce194ac942",
+            "table_sha256": "ce5e9b2d5599c74b4bc1d18c3aec2bffadb026b0e6eecf9e2f7d9335e1653af8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21476851403713226,
+          "representatives_sha256": "25a359b0eccdd8b4ffebd880b7df57c500c29652d51ebad842d5f3939af99ba7",
+          "structurally_merged_rows": 5705,
+          "backend_artifact_bytes": 1966274,
+          "backend_with_key_registry_bytes": 2170222,
+          "backend_with_datrie_key_index_bytes": 2074866,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9703426200710272,
+            "mean_cosine": 0.9979244323553459,
+            "p05_cosine": 0.9900997123354504,
+            "relative_l2_mean": 0.03859114289792424,
+            "relative_l2_p95": 0.14087544569897528,
+            "relative_l2_max": 0.24497565577229352,
+            "weighted_relative_l2_mean": 0.021356463889245822,
+            "weighted_relative_frobenius": 0.010114557173851743,
+            "weighted_mean_cosine": 0.998918017462548,
+            "max_relative_norm_change": 0.010117918800127386
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9703459889593165,
+            "mean_cosine": 0.9979244394645114,
+            "p05_cosine": 0.9900974012823818,
+            "relative_l2_mean": 0.038472432653053085,
+            "relative_l2_p95": 0.14086727251138315,
+            "relative_l2_max": 0.2449596840063457,
+            "weighted_relative_l2_mean": 0.021203362287428976,
+            "weighted_relative_frobenius": 0.01011260477785047,
+            "weighted_mean_cosine": 0.998918027063179,
+            "max_relative_norm_change": 0.010099054117758131
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.417699,
+            "warm_p50_ms": 0.22893950000000002,
+            "warm_p95_ms": 0.2384914,
+            "warm_p99_ms": 0.25379566000000003,
+            "samples_ms": [
+              0.23802,
+              0.230896,
+              0.229428,
+              0.22901,
+              0.22894,
+              0.22901,
+              0.229429,
+              0.228939,
+              0.233689,
+              0.257854,
+              0.230406,
+              0.229988,
+              0.226705,
+              0.22901,
+              0.229009,
+              0.228102,
+              0.226705,
+              0.227963,
+              0.228451,
+              0.22894,
+              0.228032,
+              0.232711,
+              0.226705,
+              0.227613,
+              0.226635,
+              0.228451,
+              0.247448,
+              0.229499,
+              0.22901,
+              0.228032,
+              0.231874,
+              0.226984,
+              0.227124,
+              0.227613,
+              0.232292,
+              0.227962,
+              0.228032,
+              0.226635,
+              0.228102,
+              0.228591
+            ],
+            "warm_rows_per_second": 2236398.6992196627
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1960815,
+              "unique_rows": 7699,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 241,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 241,
+              "zlib_blocks": 159,
+              "xor_blocks": 82,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7699
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "045e517281546731b546c8b1d7adfc51d1c9ea926c5bca5a72a5ce04409a0f8c",
+            "table_sha256": "36f2ccb7e6feecafea2be2c1c5aa7f5343e4b2ccd0c5640a3f0b9dfe2b1e614b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21026584203355014,
+          "representatives_sha256": "1d15fcb1d67eedef0defa6c3a30e986b0b9b200376c53338020b637f2e31bc7d",
+          "structurally_merged_rows": 5725,
+          "backend_artifact_bytes": 1962021,
+          "backend_with_key_registry_bytes": 2165969,
+          "backend_with_datrie_key_index_bytes": 2070613,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9515207734429368,
+            "mean_cosine": 0.997828042121488,
+            "p05_cosine": 0.9899147410588622,
+            "relative_l2_mean": 0.03923419065524245,
+            "relative_l2_p95": 0.14203493723420965,
+            "relative_l2_max": 0.31037335562002444,
+            "weighted_relative_l2_mean": 0.02170580614399317,
+            "weighted_relative_frobenius": 0.011063628330345916,
+            "weighted_mean_cosine": 0.9988661954256461,
+            "max_relative_norm_change": 0.010117918800127386
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9515114032704579,
+            "mean_cosine": 0.9978280484143693,
+            "p05_cosine": 0.9899122601784989,
+            "relative_l2_mean": 0.03911578474741316,
+            "relative_l2_p95": 0.14202421468116166,
+            "relative_l2_max": 0.31040553239053054,
+            "weighted_relative_l2_mean": 0.0215528822799628,
+            "weighted_relative_frobenius": 0.011061795795406735,
+            "weighted_mean_cosine": 0.9988662048193726,
+            "max_relative_norm_change": 0.010099054117758131
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.614581,
+            "warm_p50_ms": 0.22806700000000002,
+            "warm_p95_ms": 0.23920269999999993,
+            "warm_p99_ms": 0.27026492,
+            "samples_ms": [
+              0.231804,
+              0.232781,
+              0.228032,
+              0.227962,
+              0.226566,
+              0.22901,
+              0.274895,
+              0.263023,
+              0.229917,
+              0.22894,
+              0.227543,
+              0.22887,
+              0.227054,
+              0.228521,
+              0.228032,
+              0.228521,
+              0.227124,
+              0.228102,
+              0.233759,
+              0.226565,
+              0.228032,
+              0.227543,
+              0.227124,
+              0.237949,
+              0.22901,
+              0.228521,
+              0.228102,
+              0.228102,
+              0.226705,
+              0.228032,
+              0.227124,
+              0.232293,
+              0.22901,
+              0.227613,
+              0.227682,
+              0.228032,
+              0.2332,
+              0.227124,
+              0.227194,
+              0.227124
+            ],
+            "warm_rows_per_second": 2244954.3335949522
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1957354,
+              "unique_rows": 7685,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 241,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 241,
+              "zlib_blocks": 156,
+              "xor_blocks": 85,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7685
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "ee86f39371f052d826061c20167a6abfefa15b99ce9576dc2503a4130acdb9cc",
+            "table_sha256": "e6e1d7d625eca2be032067ada24771cf4090ba89c350102b498e11347412b7da",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20897321705706418,
+          "representatives_sha256": "759730df622c90b1ed104e6406f6e8efdcbdb5b3405c9dd821ba0080e465ed99",
+          "structurally_merged_rows": 5739,
+          "backend_artifact_bytes": 1958560,
+          "backend_with_key_registry_bytes": 2162508,
+          "backend_with_datrie_key_index_bytes": 2067152,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9016499744140217,
+            "mean_cosine": 0.997691905635778,
+            "p05_cosine": 0.9897283669000854,
+            "relative_l2_mean": 0.039900345172597676,
+            "relative_l2_p95": 0.14344021411172275,
+            "relative_l2_max": 0.4455450884412612,
+            "weighted_relative_l2_mean": 0.022253324510674376,
+            "weighted_relative_frobenius": 0.012762492197345335,
+            "weighted_mean_cosine": 0.9987566249052615,
+            "max_relative_norm_change": 0.010117918800127386
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9016575948166327,
+            "mean_cosine": 0.9976919122693515,
+            "p05_cosine": 0.9897270242059109,
+            "relative_l2_mean": 0.03978215263776933,
+            "relative_l2_p95": 0.14342778425751362,
+            "relative_l2_max": 0.44554379064698335,
+            "weighted_relative_l2_mean": 0.022100618010424723,
+            "weighted_relative_frobenius": 0.012760904632781796,
+            "weighted_mean_cosine": 0.9987566336903675,
+            "max_relative_norm_change": 0.010099054117758131
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.496759,
+            "warm_p50_ms": 0.22852099999999997,
+            "warm_p95_ms": 0.23967089999999996,
+            "warm_p99_ms": 0.25179923,
+            "samples_ms": [
+              0.234597,
+              0.234248,
+              0.256457,
+              0.235574,
+              0.230407,
+              0.229429,
+              0.228451,
+              0.226565,
+              0.22901,
+              0.228102,
+              0.226705,
+              0.227613,
+              0.227543,
+              0.227543,
+              0.227054,
+              0.227543,
+              0.228102,
+              0.229499,
+              0.230825,
+              0.244514,
+              0.229498,
+              0.227962,
+              0.231873,
+              0.231803,
+              0.231873,
+              0.22887,
+              0.228451,
+              0.233759,
+              0.227194,
+              0.226636,
+              0.227054,
+              0.231873,
+              0.228591,
+              0.227543,
+              0.227613,
+              0.227194,
+              0.239416,
+              0.22894,
+              0.228101,
+              0.226705
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1771968,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "9f777ab7bd00dedb4404ea8845e359fbaf82aaa095e98cfef4783fbcfeb33df4",
+            "table_sha256": "7c01f03bbb40873f368ce12e55598733cbd8271f035cb510761f8f5794d8d841",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.035551971988752484,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1772818,
+          "backend_with_key_registry_bytes": 1976766,
+          "backend_with_datrie_key_index_bytes": 1881410,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999442322587219,
+            "mean_cosine": 0.9999795979612697,
+            "p05_cosine": 0.9999690851376799,
+            "relative_l2_mean": 0.006358420584391994,
+            "relative_l2_p95": 0.00788237035989277,
+            "relative_l2_max": 0.01059356282798076,
+            "weighted_relative_l2_mean": 0.006371080776756557,
+            "weighted_relative_frobenius": 0.006401343301882059,
+            "weighted_mean_cosine": 0.9999795156917556,
+            "max_relative_norm_change": 0.003028731873775844
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.380845,
+            "warm_p50_ms": 0.122991,
+            "warm_p95_ms": 0.12555354999999999,
+            "warm_p99_ms": 0.1346748,
+            "samples_ms": [
+              0.125365,
+              0.123899,
+              0.12348,
+              0.123061,
+              0.129136,
+              0.122502,
+              0.12348,
+              0.12355,
+              0.122572,
+              0.123479,
+              0.12299,
+              0.122991,
+              0.122991,
+              0.122991,
+              0.123968,
+              0.12348,
+              0.122571,
+              0.123479,
+              0.122991,
+              0.122013,
+              0.122502,
+              0.122501,
+              0.123061,
+              0.122572,
+              0.122082,
+              0.122991,
+              0.121594,
+              0.12348,
+              0.122082,
+              0.138216,
+              0.123968,
+              0.121524,
+              0.122991,
+              0.121175,
+              0.121663,
+              0.12306,
+              0.12348,
+              0.12348,
+              0.122432,
+              0.12299
+            ],
+            "warm_rows_per_second": 4162906.2289110585
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1655350,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "9f777ab7bd00dedb4404ea8845e359fbaf82aaa095e98cfef4783fbcfeb33df4",
+            "table_sha256": "51281896ec1aa4b107e865f42c1f991de94ffca03446b5e95bcde52b96a7ec93",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25538244703784585,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1656603,
+          "backend_with_key_registry_bytes": 1860551,
+          "backend_with_datrie_key_index_bytes": 1765195,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999442322587219,
+            "mean_cosine": 0.9999795979612697,
+            "p05_cosine": 0.9999690851376799,
+            "relative_l2_mean": 0.006358420584391994,
+            "relative_l2_p95": 0.00788237035989277,
+            "relative_l2_max": 0.01059356282798076,
+            "weighted_relative_l2_mean": 0.006371080776756557,
+            "weighted_relative_frobenius": 0.006401343301882059,
+            "weighted_mean_cosine": 0.9999795156917556,
+            "max_relative_norm_change": 0.003028731873775844
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.024469,
+            "warm_p50_ms": 0.132489,
+            "warm_p95_ms": 0.13857554999999994,
+            "warm_p99_ms": 0.16364547999999998,
+            "samples_ms": [
+              0.154698,
+              0.134374,
+              0.132978,
+              0.133886,
+              0.132489,
+              0.134375,
+              0.132978,
+              0.132908,
+              0.132,
+              0.132908,
+              0.132978,
+              0.132978,
+              0.131512,
+              0.133467,
+              0.132489,
+              0.131511,
+              0.131511,
+              0.132489,
+              0.132,
+              0.132,
+              0.131512,
+              0.137169,
+              0.132,
+              0.131511,
+              0.132489,
+              0.132489,
+              0.132,
+              0.131511,
+              0.137727,
+              0.169366,
+              0.136261,
+              0.132001,
+              0.132001,
+              0.133397,
+              0.132489,
+              0.130603,
+              0.131581,
+              0.131582,
+              0.131511,
+              0.131022
+            ],
+            "warm_rows_per_second": 3864471.7674674885
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1655350,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "9f777ab7bd00dedb4404ea8845e359fbaf82aaa095e98cfef4783fbcfeb33df4",
+            "table_sha256": "51281896ec1aa4b107e865f42c1f991de94ffca03446b5e95bcde52b96a7ec93",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23377129808068275,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1656602,
+          "backend_with_key_registry_bytes": 1860550,
+          "backend_with_datrie_key_index_bytes": 1765194,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999442322587219,
+            "mean_cosine": 0.9999795979612697,
+            "p05_cosine": 0.9999690851376799,
+            "relative_l2_mean": 0.006358420584391994,
+            "relative_l2_p95": 0.00788237035989277,
+            "relative_l2_max": 0.01059356282798076,
+            "weighted_relative_l2_mean": 0.006371080776756557,
+            "weighted_relative_frobenius": 0.006401343301882059,
+            "weighted_mean_cosine": 0.9999795156917556,
+            "max_relative_norm_change": 0.003028731873775844
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.984659,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.13584419999999997,
+            "warm_p99_ms": 0.14261235,
+            "samples_ms": [
+              0.135701,
+              0.134794,
+              0.132,
+              0.130534,
+              0.131093,
+              0.132978,
+              0.132,
+              0.131092,
+              0.132,
+              0.132489,
+              0.131581,
+              0.131092,
+              0.131092,
+              0.131511,
+              0.131022,
+              0.130604,
+              0.1452,
+              0.138565,
+              0.131581,
+              0.134375,
+              0.134305,
+              0.132978,
+              0.131092,
+              0.130115,
+              0.130604,
+              0.131511,
+              0.131511,
+              0.130114,
+              0.131511,
+              0.131022,
+              0.131511,
+              0.130603,
+              0.131511,
+              0.133886,
+              0.131581,
+              0.129695,
+              0.130603,
+              0.130603,
+              0.131581,
+              0.131022
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1655350,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "9f777ab7bd00dedb4404ea8845e359fbaf82aaa095e98cfef4783fbcfeb33df4",
+            "table_sha256": "51281896ec1aa4b107e865f42c1f991de94ffca03446b5e95bcde52b96a7ec93",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1943037409801036,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1656602,
+          "backend_with_key_registry_bytes": 1860550,
+          "backend_with_datrie_key_index_bytes": 1765194,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999442322587219,
+            "mean_cosine": 0.9999795979612697,
+            "p05_cosine": 0.9999690851376799,
+            "relative_l2_mean": 0.006358420584391994,
+            "relative_l2_p95": 0.00788237035989277,
+            "relative_l2_max": 0.01059356282798076,
+            "weighted_relative_l2_mean": 0.006371080776756557,
+            "weighted_relative_frobenius": 0.006401343301882059,
+            "weighted_mean_cosine": 0.9999795156917556,
+            "max_relative_norm_change": 0.003028731873775844
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.934094,
+            "warm_p50_ms": 0.13245400000000002,
+            "warm_p95_ms": 0.14004234999999998,
+            "warm_p99_ms": 0.15817857999999999,
+            "samples_ms": [
+              0.13626,
+              0.135352,
+              0.132489,
+              0.135841,
+              0.134793,
+              0.134864,
+              0.132489,
+              0.132,
+              0.135282,
+              0.139543,
+              0.163708,
+              0.132978,
+              0.135352,
+              0.131022,
+              0.130603,
+              0.131022,
+              0.131511,
+              0.130114,
+              0.131022,
+              0.131511,
+              0.132978,
+              0.132908,
+              0.132,
+              0.134444,
+              0.132908,
+              0.133955,
+              0.132419,
+              0.131022,
+              0.130603,
+              0.132,
+              0.130115,
+              0.135771,
+              0.130533,
+              0.131023,
+              0.131023,
+              0.133467,
+              0.130603,
+              0.132,
+              0.130114,
+              0.14953
+            ],
+            "warm_rows_per_second": 3865492.925845954
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1129211,
+              "unique_rows": 8311,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 135,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 134,
+              "zlib_blocks": 1,
+              "xor_blocks": 133,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8311
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "1bdf0ad9b3f1f224ceaa52430fb36f9c423cd334ad1cc2673d744369700cc577",
+            "table_sha256": "35ce753c687e470c242945aff294cec188500c6a6784cd7668d8d257e4b73658",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13416230399161577,
+          "representatives_sha256": "f8a053eb28da44da2bedb7269b459de91eab848d6ba2f892a9993216eb1a3d16",
+          "structurally_merged_rows": 5113,
+          "backend_artifact_bytes": 1130460,
+          "backend_with_key_registry_bytes": 1334408,
+          "backend_with_datrie_key_index_bytes": 1239052,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9899136811807194,
+            "mean_cosine": 0.9985749964000988,
+            "p05_cosine": 0.9930476127303063,
+            "relative_l2_mean": 0.0348989236734183,
+            "relative_l2_p95": 0.11797927934547961,
+            "relative_l2_max": 0.14306266325996833,
+            "weighted_relative_l2_mean": 0.02245632026244996,
+            "weighted_relative_frobenius": 0.011525639114851247,
+            "weighted_mean_cosine": 0.999222689535393,
+            "max_relative_norm_change": 0.010991590798041326
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900110489149397,
+            "mean_cosine": 0.9985798293373181,
+            "p05_cosine": 0.9930382461113353,
+            "relative_l2_mean": 0.031064004534487093,
+            "relative_l2_p95": 0.11811641388146403,
+            "relative_l2_max": 0.14220749334411578,
+            "weighted_relative_l2_mean": 0.017657962537942273,
+            "weighted_relative_frobenius": 0.009713811108145775,
+            "weighted_mean_cosine": 0.9992335472616621,
+            "max_relative_norm_change": 0.01010024019379909
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.240173,
+            "warm_p50_ms": 0.1315115,
+            "warm_p95_ms": 0.13361014999999998,
+            "warm_p99_ms": 0.15648195999999998,
+            "samples_ms": [
+              0.133397,
+              0.133467,
+              0.133397,
+              0.133467,
+              0.131511,
+              0.132978,
+              0.130533,
+              0.131092,
+              0.132908,
+              0.131023,
+              0.131023,
+              0.130534,
+              0.131581,
+              0.130604,
+              0.131023,
+              0.133467,
+              0.131511,
+              0.129626,
+              0.130534,
+              0.129626,
+              0.131512,
+              0.169366,
+              0.132489,
+              0.132,
+              0.131022,
+              0.132,
+              0.132908,
+              0.13633,
+              0.131581,
+              0.131512,
+              0.130534,
+              0.132838,
+              0.131022,
+              0.131511,
+              0.130604,
+              0.13242,
+              0.130115,
+              0.131512,
+              0.131511,
+              0.131511
+            ],
+            "warm_rows_per_second": 3893195.6520912615
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1070809,
+              "unique_rows": 7790,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 126,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 126,
+              "zlib_blocks": 3,
+              "xor_blocks": 123,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7790
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "0ed19c226bc08bca8268d27f1e94ef3177d42a35930d4a26e31d384f2eed8f04",
+            "table_sha256": "8c803988d779ed98ddc748a63b024fb8b9331a5d0ed698777705c9f8e4bec12c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13391485600732267,
+          "representatives_sha256": "ced14b422e7247d7fb744385596f5f3dfbe060303f4f5b132525ea5d30c9cefb",
+          "structurally_merged_rows": 5634,
+          "backend_artifact_bytes": 1072058,
+          "backend_with_key_registry_bytes": 1276006,
+          "backend_with_datrie_key_index_bytes": 1180650,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800819990811546,
+            "mean_cosine": 0.9980303391823193,
+            "p05_cosine": 0.9905511398594655,
+            "relative_l2_mean": 0.04114180380308397,
+            "relative_l2_p95": 0.1376814432707729,
+            "relative_l2_max": 0.2003393432717317,
+            "weighted_relative_l2_mean": 0.02548624139235245,
+            "weighted_relative_frobenius": 0.011914136039216528,
+            "weighted_mean_cosine": 0.9989583493846503,
+            "max_relative_norm_change": 0.010991590798041326
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800028673484945,
+            "mean_cosine": 0.99803364650307,
+            "p05_cosine": 0.9905125901414213,
+            "relative_l2_mean": 0.03755827903409694,
+            "relative_l2_p95": 0.13786314874743147,
+            "relative_l2_max": 0.2006707042295582,
+            "weighted_relative_l2_mean": 0.020809976491343307,
+            "weighted_relative_frobenius": 0.01017311955010261,
+            "weighted_mean_cosine": 0.9989684651491306,
+            "max_relative_norm_change": 0.01010024019379909
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.921278,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13810749999999997,
+            "warm_p99_ms": 0.16200422999999997,
+            "samples_ms": [
+              0.135772,
+              0.135213,
+              0.132001,
+              0.131022,
+              0.130603,
+              0.132,
+              0.132001,
+              0.17181,
+              0.137657,
+              0.134794,
+              0.133886,
+              0.131512,
+              0.132,
+              0.132978,
+              0.130603,
+              0.131092,
+              0.132489,
+              0.132,
+              0.131511,
+              0.130044,
+              0.131022,
+              0.131512,
+              0.132001,
+              0.130534,
+              0.130115,
+              0.130604,
+              0.132978,
+              0.130603,
+              0.131092,
+              0.131511,
+              0.130533,
+              0.130604,
+              0.132,
+              0.132419,
+              0.131511,
+              0.134794,
+              0.146667,
+              0.132489,
+              0.131022,
+              0.135353
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1062349,
+              "unique_rows": 7715,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 3,
+              "xor_blocks": 122,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7715
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "a65ed6f04c6eb38ba974601bea3914635bc1977aa885be2c34a7ef1252e5a0a0",
+            "table_sha256": "db471a073504d12ba7edf777c074f618650e74d07c93eaafc75195ee9fc107a5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13173098699189723,
+          "representatives_sha256": "2c651c7431fd40185e50e6a43e931eddacfe49168f0011ce791f44a0fa4ae7fb",
+          "structurally_merged_rows": 5709,
+          "backend_artifact_bytes": 1063598,
+          "backend_with_key_registry_bytes": 1267546,
+          "backend_with_datrie_key_index_bytes": 1172190,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9701953282035927,
+            "mean_cosine": 0.9978960395945996,
+            "p05_cosine": 0.9900424388819883,
+            "relative_l2_mean": 0.04233024132743534,
+            "relative_l2_p95": 0.1413128536710294,
+            "relative_l2_max": 0.2456655597397933,
+            "weighted_relative_l2_mean": 0.026059843137108237,
+            "weighted_relative_frobenius": 0.011959636682586174,
+            "weighted_mean_cosine": 0.9988935294204053,
+            "max_relative_norm_change": 0.010991590798041326
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9701616210721082,
+            "mean_cosine": 0.9978989440226749,
+            "p05_cosine": 0.9900253707939715,
+            "relative_l2_mean": 0.03878435322246367,
+            "relative_l2_p95": 0.1413036081012778,
+            "relative_l2_max": 0.245592669302795,
+            "weighted_relative_l2_mean": 0.021401743647156593,
+            "weighted_relative_frobenius": 0.010226536183463626,
+            "weighted_mean_cosine": 0.9989034507279311,
+            "max_relative_norm_change": 0.01010024019379909
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.099094,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.1344483,
+            "warm_p99_ms": 0.14103881,
+            "samples_ms": [
+              0.133886,
+              0.135841,
+              0.131511,
+              0.131581,
+              0.134375,
+              0.132,
+              0.131512,
+              0.132489,
+              0.132489,
+              0.132,
+              0.131512,
+              0.13249,
+              0.130604,
+              0.129207,
+              0.130603,
+              0.131511,
+              0.130045,
+              0.131512,
+              0.131582,
+              0.144362,
+              0.132,
+              0.130603,
+              0.131022,
+              0.131511,
+              0.131022,
+              0.131092,
+              0.131581,
+              0.131093,
+              0.131023,
+              0.131511,
+              0.130114,
+              0.131581,
+              0.131092,
+              0.130603,
+              0.131511,
+              0.131022,
+              0.130603,
+              0.131162,
+              0.129137,
+              0.129625
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1060046,
+              "unique_rows": 7693,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 124,
+              "zlib_blocks": 3,
+              "xor_blocks": 121,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7693
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "b66c6be47db4d19b81db87d089815be279d67672e8f73e822b283861f5b7a554",
+            "table_sha256": "d0a8b9d19b68d5939d6742797b4254dbdbbabb180e9ba18a1fe7337f33d137d5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1281924748327583,
+          "representatives_sha256": "34059e133bf2367ed0352f5df1f47ea57baab36d0f1b6bec9f94453ff2b02761",
+          "structurally_merged_rows": 5731,
+          "backend_artifact_bytes": 1061295,
+          "backend_with_key_registry_bytes": 1265243,
+          "backend_with_datrie_key_index_bytes": 1169887,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9513409007200618,
+            "mean_cosine": 0.997793466896943,
+            "p05_cosine": 0.9898396814040983,
+            "relative_l2_mean": 0.04300487377165273,
+            "relative_l2_p95": 0.1425172665914292,
+            "relative_l2_max": 0.3109355148579674,
+            "weighted_relative_l2_mean": 0.026423577148642827,
+            "weighted_relative_frobenius": 0.01277455427633077,
+            "weighted_mean_cosine": 0.9988387228072758,
+            "max_relative_norm_change": 0.010991590798041326
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9513650714582464,
+            "mean_cosine": 0.9977962797082564,
+            "p05_cosine": 0.9898302935962124,
+            "relative_l2_mean": 0.039469799009364724,
+            "relative_l2_p95": 0.14263249893132462,
+            "relative_l2_max": 0.3112027514607818,
+            "weighted_relative_l2_mean": 0.021771616550171242,
+            "weighted_relative_frobenius": 0.01116869855378381,
+            "weighted_mean_cosine": 0.9988485868475183,
+            "max_relative_norm_change": 0.01010024019379909
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.182904,
+            "warm_p50_ms": 0.132489,
+            "warm_p95_ms": 0.13544725,
+            "warm_p99_ms": 0.14328798,
+            "samples_ms": [
+              0.134375,
+              0.132909,
+              0.132489,
+              0.132908,
+              0.134794,
+              0.134794,
+              0.137238,
+              0.133886,
+              0.134794,
+              0.134794,
+              0.134934,
+              0.133397,
+              0.130603,
+              0.132489,
+              0.132977,
+              0.131511,
+              0.130114,
+              0.132,
+              0.131022,
+              0.132908,
+              0.131512,
+              0.131023,
+              0.130045,
+              0.131023,
+              0.131092,
+              0.147156,
+              0.133467,
+              0.130114,
+              0.130114,
+              0.130603,
+              0.130603,
+              0.131511,
+              0.132419,
+              0.135353,
+              0.134864,
+              0.132977,
+              0.133397,
+              0.131022,
+              0.129625,
+              0.129625
+            ],
+            "warm_rows_per_second": 3864471.7674674885
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1058542,
+              "unique_rows": 7681,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 124,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 124,
+              "zlib_blocks": 3,
+              "xor_blocks": 121,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7681
+            },
+            "source_float32_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07",
+            "decoded_float32_sha256": "c798df084039f9f563c0202f4a79c4ca176c0e7a9ba4355c1cc5b182966b3305",
+            "table_sha256": "4c0650eba6aba8af28ecbf7958f4b514c47d67af80085f593d8789966fcc184e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13557358807884157,
+          "representatives_sha256": "75da31e2b4ff5f94336fd5386b6afd1572da78ae180b3ae9e3a8ddd16ea4ee2d",
+          "structurally_merged_rows": 5743,
+          "backend_artifact_bytes": 1059791,
+          "backend_with_key_registry_bytes": 1263739,
+          "backend_with_datrie_key_index_bytes": 1168383,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9013489996890685,
+            "mean_cosine": 0.997651994391575,
+            "p05_cosine": 0.9896481483675127,
+            "relative_l2_mean": 0.04368167817732234,
+            "relative_l2_p95": 0.14425391081360175,
+            "relative_l2_max": 0.4464244868253807,
+            "weighted_relative_l2_mean": 0.02698530975733708,
+            "weighted_relative_frobenius": 0.01432390571017968,
+            "weighted_mean_cosine": 0.9987239127258772,
+            "max_relative_norm_change": 0.010991590798041326
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9014350454777781,
+            "mean_cosine": 0.9976546353753513,
+            "p05_cosine": 0.9896478765184749,
+            "relative_l2_mean": 0.04015194510655089,
+            "relative_l2_p95": 0.14421017659095295,
+            "relative_l2_max": 0.4461840001692348,
+            "weighted_relative_l2_mean": 0.022339067423681105,
+            "weighted_relative_frobenius": 0.012914232859430198,
+            "weighted_mean_cosine": 0.9987336847848998,
+            "max_relative_norm_change": 0.01010024019379909
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.951519,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13439945,
+            "warm_p99_ms": 0.15241613999999998,
+            "samples_ms": [
+              0.133816,
+              0.134375,
+              0.132978,
+              0.132,
+              0.132,
+              0.132489,
+              0.132,
+              0.132489,
+              0.134375,
+              0.133816,
+              0.132,
+              0.131512,
+              0.133886,
+              0.132978,
+              0.130534,
+              0.132,
+              0.130114,
+              0.130533,
+              0.130044,
+              0.130114,
+              0.131022,
+              0.131511,
+              0.130114,
+              0.131092,
+              0.163638,
+              0.134864,
+              0.132908,
+              0.132001,
+              0.130534,
+              0.132489,
+              0.134375,
+              0.133397,
+              0.131511,
+              0.131511,
+              0.131022,
+              0.132,
+              0.130603,
+              0.131023,
+              0.131511,
+              0.132
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "88ef8b5ba65079c79087b3a393cdf85dea46b1782995d5a6bda1289c567d0a07"
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "rows": 13424,
+      "dim": 128,
+      "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+      "source_float32_bytes": 6873088,
+      "key_registry_bytes": 203948,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 108592,
+      "query_rows": 512,
+      "query_ids_sha256": "80ab83de1ecc982405671e980d9e9a66070e51aead43121126faabb6b44a50cd",
+      "frequency_trace_sha256": "1a0389197253d049e85973cd9812529ea0dc3eae69dcdb62085a34b49c0d90b8",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 6873088,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "table_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03638713504187763,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6873893,
+          "backend_with_key_registry_bytes": 7077841,
+          "backend_with_datrie_key_index_bytes": 6982485,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.375607,
+            "warm_p50_ms": 0.060971,
+            "warm_p95_ms": 0.06530545,
+            "warm_p99_ms": 0.08922931999999999,
+            "samples_ms": [
+              0.065302,
+              0.104483,
+              0.065371,
+              0.062927,
+              0.062928,
+              0.06146,
+              0.061949,
+              0.063346,
+              0.061042,
+              0.062927,
+              0.063416,
+              0.062508,
+              0.062019,
+              0.061949,
+              0.062927,
+              0.060552,
+              0.060482,
+              0.060971,
+              0.060063,
+              0.059644,
+              0.060971,
+              0.060622,
+              0.060064,
+              0.060553,
+              0.061112,
+              0.060483,
+              0.060134,
+              0.061041,
+              0.060553,
+              0.060623,
+              0.060133,
+              0.060552,
+              0.059085,
+              0.058667,
+              0.058667,
+              0.060552,
+              0.06153,
+              0.061041,
+              0.060133,
+              0.059644
+            ],
+            "warm_rows_per_second": 8397434.846074363
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6482626,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 46,
+              "xor_blocks": 793,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "table_sha256": "9ed6c5c269513323a75b48c96f80fd98f7c7cbc77060148bafda48caa4abed5b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5779507379047573,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6483835,
+          "backend_with_key_registry_bytes": 6687783,
+          "backend_with_datrie_key_index_bytes": 6592427,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.391392,
+            "warm_p50_ms": 0.0719715,
+            "warm_p95_ms": 0.07622145,
+            "warm_p99_ms": 0.07779376,
+            "samples_ms": [
+              0.078502,
+              0.075708,
+              0.0748,
+              0.076197,
+              0.076686,
+              0.075708,
+              0.0748,
+              0.07473,
+              0.073822,
+              0.07515,
+              0.074731,
+              0.074312,
+              0.074241,
+              0.072426,
+              0.071029,
+              0.07054,
+              0.070889,
+              0.072844,
+              0.072844,
+              0.072775,
+              0.070051,
+              0.07047,
+              0.071867,
+              0.071378,
+              0.071377,
+              0.071378,
+              0.070959,
+              0.071936,
+              0.070959,
+              0.071937,
+              0.071447,
+              0.071518,
+              0.072426,
+              0.072006,
+              0.071029,
+              0.071448,
+              0.071028,
+              0.07047,
+              0.070889,
+              0.073822
+            ],
+            "warm_rows_per_second": 7113927.040564668
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6482626,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 46,
+              "xor_blocks": 793,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "table_sha256": "9ed6c5c269513323a75b48c96f80fd98f7c7cbc77060148bafda48caa4abed5b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6452370139304549,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6483834,
+          "backend_with_key_registry_bytes": 6687782,
+          "backend_with_datrie_key_index_bytes": 6592426,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.670618,
+            "warm_p50_ms": 0.07047,
+            "warm_p95_ms": 0.076616,
+            "warm_p99_ms": 0.09191052999999999,
+            "samples_ms": [
+              0.076616,
+              0.076616,
+              0.076616,
+              0.073823,
+              0.074731,
+              0.07473,
+              0.07473,
+              0.07473,
+              0.07473,
+              0.074311,
+              0.073823,
+              0.069981,
+              0.07047,
+              0.069562,
+              0.07054,
+              0.069142,
+              0.069911,
+              0.0704,
+              0.069143,
+              0.069073,
+              0.069003,
+              0.07047,
+              0.070051,
+              0.07047,
+              0.071447,
+              0.101689,
+              0.073333,
+              0.070889,
+              0.07047,
+              0.069143,
+              0.068585,
+              0.069981,
+              0.069562,
+              0.069632,
+              0.069003,
+              0.0704,
+              0.069003,
+              0.070539,
+              0.070121,
+              0.069492
+            ],
+            "warm_rows_per_second": 7265503.050943663
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6482626,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 46,
+              "xor_blocks": 793,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "table_sha256": "9ed6c5c269513323a75b48c96f80fd98f7c7cbc77060148bafda48caa4abed5b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6974755520932376,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6483834,
+          "backend_with_key_registry_bytes": 6687782,
+          "backend_with_datrie_key_index_bytes": 6592426,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.409901,
+            "warm_p50_ms": 0.07099349999999999,
+            "warm_p95_ms": 0.07664045,
+            "warm_p99_ms": 0.09095139,
+            "samples_ms": [
+              0.077105,
+              0.075219,
+              0.076616,
+              0.07473,
+              0.074241,
+              0.07473,
+              0.075219,
+              0.072356,
+              0.074731,
+              0.074731,
+              0.072356,
+              0.071378,
+              0.072356,
+              0.07047,
+              0.07047,
+              0.070959,
+              0.071448,
+              0.070051,
+              0.069562,
+              0.069982,
+              0.069981,
+              0.071028,
+              0.07054,
+              0.069562,
+              0.099804,
+              0.074312,
+              0.071448,
+              0.071448,
+              0.070051,
+              0.070051,
+              0.069981,
+              0.07047,
+              0.070959,
+              0.070051,
+              0.07047,
+              0.07054,
+              0.070958,
+              0.07047,
+              0.0704,
+              0.071378
+            ],
+            "warm_rows_per_second": 7211927.852549883
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 4080768,
+              "unique_rows": 8271,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 517,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 517,
+              "zlib_blocks": 361,
+              "xor_blocks": 156,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8271
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "1c1d4481afeb929a6c60ffb2dda15be882e5821857e68e1591cdf86a8a23c0e4",
+            "table_sha256": "10c70f4eac16302ceaac2f35eb677e5a8323f44f32c9cba3c656de9460248654",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38640943402424455,
+          "representatives_sha256": "5a0f623392ded7d50ec694118345b2dc49557b1bebd5e7e9870e49eb422a2185",
+          "structurally_merged_rows": 5153,
+          "backend_artifact_bytes": 4081975,
+          "backend_with_key_registry_bytes": 4285923,
+          "backend_with_datrie_key_index_bytes": 4190567,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900053980881236,
+            "mean_cosine": 0.9985802128091349,
+            "p05_cosine": 0.9930332680282773,
+            "relative_l2_mean": 0.03112516137545862,
+            "relative_l2_p95": 0.1181307410446335,
+            "relative_l2_max": 0.14236738964640794,
+            "weighted_relative_l2_mean": 0.017583539902024107,
+            "weighted_relative_frobenius": 0.009429837428214146,
+            "weighted_mean_cosine": 0.9992397497471761,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900053980881236,
+            "mean_cosine": 0.9985802128091349,
+            "p05_cosine": 0.9930332680282773,
+            "relative_l2_mean": 0.03112516137545862,
+            "relative_l2_p95": 0.1181307410446335,
+            "relative_l2_max": 0.14236738964640794,
+            "weighted_relative_l2_mean": 0.017583539902024107,
+            "weighted_relative_frobenius": 0.009429837428214146,
+            "weighted_mean_cosine": 0.9992397497471761,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.797962,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.0748278,
+            "warm_p99_ms": 0.09078736999999999,
+            "samples_ms": [
+              0.076686,
+              0.07473,
+              0.074312,
+              0.072845,
+              0.0704,
+              0.07054,
+              0.070051,
+              0.07054,
+              0.070051,
+              0.070051,
+              0.071378,
+              0.07047,
+              0.069143,
+              0.069073,
+              0.07047,
+              0.069981,
+              0.07047,
+              0.069632,
+              0.069492,
+              0.069004,
+              0.069632,
+              0.068165,
+              0.069004,
+              0.070051,
+              0.07054,
+              0.069562,
+              0.069981,
+              0.069561,
+              0.069073,
+              0.07047,
+              0.069492,
+              0.068654,
+              0.099803,
+              0.071936,
+              0.069562,
+              0.069631,
+              0.070051,
+              0.069911,
+              0.07054,
+              0.069562
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3865416,
+              "unique_rows": 7821,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 489,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 489,
+              "zlib_blocks": 378,
+              "xor_blocks": 111,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7821
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "93cf72dbdf8d27b18b36be0d472cbb4701d8b9a4780bf12c65971e4688b1dbbc",
+            "table_sha256": "2433e4e96782083f94e8266b09ac4dcd0cb92e153b8a2b2eba988288843284ca",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.41839837888255715,
+          "representatives_sha256": "66e0123ae35dfc3e15b0374c3ac98431eec0d321e0ded9a545a8f915195de474",
+          "structurally_merged_rows": 5603,
+          "backend_artifact_bytes": 3866623,
+          "backend_with_key_registry_bytes": 4070571,
+          "backend_with_datrie_key_index_bytes": 3975215,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.980085122495785,
+            "mean_cosine": 0.9981056136973616,
+            "p05_cosine": 0.9910258422608778,
+            "relative_l2_mean": 0.036756417401143396,
+            "relative_l2_p95": 0.13431279623149256,
+            "relative_l2_max": 0.19939341253996173,
+            "weighted_relative_l2_mean": 0.020450147654051058,
+            "weighted_relative_frobenius": 0.011197217894442387,
+            "weighted_mean_cosine": 0.998998288504402,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.980085122495785,
+            "mean_cosine": 0.9981056136973616,
+            "p05_cosine": 0.9910258422608778,
+            "relative_l2_mean": 0.036756417401143396,
+            "relative_l2_p95": 0.13431279623149256,
+            "relative_l2_max": 0.19939341253996173,
+            "weighted_relative_l2_mean": 0.020450147654051058,
+            "weighted_relative_frobenius": 0.011197217894442387,
+            "weighted_mean_cosine": 0.998998288504402,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.351396,
+            "warm_p50_ms": 0.07120299999999999,
+            "warm_p95_ms": 0.07812835,
+            "warm_p99_ms": 0.09402954999999999,
+            "samples_ms": [
+              0.075638,
+              0.075219,
+              0.073333,
+              0.073334,
+              0.072775,
+              0.073334,
+              0.073893,
+              0.078083,
+              0.07899,
+              0.076616,
+              0.074312,
+              0.073823,
+              0.071867,
+              0.070959,
+              0.07047,
+              0.070539,
+              0.071448,
+              0.07054,
+              0.069562,
+              0.072845,
+              0.070539,
+              0.07047,
+              0.069562,
+              0.071937,
+              0.103645,
+              0.075219,
+              0.072775,
+              0.071378,
+              0.069073,
+              0.069631,
+              0.07054,
+              0.07047,
+              0.069422,
+              0.070469,
+              0.07054,
+              0.071028,
+              0.068584,
+              0.069981,
+              0.069981,
+              0.07061
+            ],
+            "warm_rows_per_second": 7190708.256674579
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3836346,
+              "unique_rows": 7760,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 485,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 485,
+              "zlib_blocks": 393,
+              "xor_blocks": 92,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7760
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "3b8d1e499cfda1a058271bc38b401335d3adbba2f23ce3b7c755dd72a698a686",
+            "table_sha256": "7fcc8c95d329446ced6adfab0590a0925f73a2775a7cc06456fee5173d65462f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4337080221157521,
+          "representatives_sha256": "ffcdd62e49e4dc0401a65bc1dd4a3d1d17bdf69c328160ce16d379c2ce01d18a",
+          "structurally_merged_rows": 5664,
+          "backend_artifact_bytes": 3837552,
+          "backend_with_key_registry_bytes": 4041500,
+          "backend_with_datrie_key_index_bytes": 3946144,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.970170421501845,
+            "mean_cosine": 0.9979948273478729,
+            "p05_cosine": 0.9905955432170158,
+            "relative_l2_mean": 0.03776016573206639,
+            "relative_l2_p95": 0.1371075806604864,
+            "relative_l2_max": 0.24352079349033676,
+            "weighted_relative_l2_mean": 0.020934608790724923,
+            "weighted_relative_frobenius": 0.011236415060272766,
+            "weighted_mean_cosine": 0.9989448172515513,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.970170421501845,
+            "mean_cosine": 0.9979948273478729,
+            "p05_cosine": 0.9905955432170158,
+            "relative_l2_mean": 0.03776016573206639,
+            "relative_l2_p95": 0.1371075806604864,
+            "relative_l2_max": 0.24352079349033676,
+            "weighted_relative_l2_mean": 0.020934608790724923,
+            "weighted_relative_frobenius": 0.011236415060272766,
+            "weighted_mean_cosine": 0.9989448172515513,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.50372,
+            "warm_p50_ms": 0.07054,
+            "warm_p95_ms": 0.07667175,
+            "warm_p99_ms": 0.08187248999999999,
+            "samples_ms": [
+              0.076127,
+              0.076127,
+              0.079061,
+              0.076127,
+              0.074311,
+              0.073333,
+              0.072845,
+              0.072845,
+              0.072915,
+              0.073753,
+              0.076546,
+              0.073333,
+              0.070889,
+              0.071378,
+              0.07012,
+              0.068584,
+              0.07047,
+              0.07005,
+              0.070121,
+              0.069073,
+              0.069004,
+              0.07054,
+              0.068654,
+              0.072845,
+              0.071378,
+              0.069562,
+              0.069981,
+              0.069562,
+              0.070051,
+              0.070889,
+              0.07047,
+              0.069073,
+              0.07054,
+              0.071518,
+              0.070539,
+              0.07047,
+              0.069981,
+              0.068165,
+              0.08367,
+              0.069981
+            ],
+            "warm_rows_per_second": 7258293.166997449
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3830251,
+              "unique_rows": 7748,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 485,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 485,
+              "zlib_blocks": 388,
+              "xor_blocks": 97,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7748
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "5bc5de942dd7680276060d940810a0371630e3326ca5108ae9834d3ce44a6b4e",
+            "table_sha256": "2105fdb09947d30bce3a39f65685885452b87de9d161ac24b8543363364265dc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36579897115007043,
+          "representatives_sha256": "f61c8cb0a451eacc74c0b072772ba972d2aba61682b94c5d0d847abf3fccc5ec",
+          "structurally_merged_rows": 5676,
+          "backend_artifact_bytes": 3831457,
+          "backend_with_key_registry_bytes": 4035405,
+          "backend_with_datrie_key_index_bytes": 3940049,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9541835879181099,
+            "mean_cosine": 0.9979284129801629,
+            "p05_cosine": 0.990434384937845,
+            "relative_l2_mean": 0.038211001031595915,
+            "relative_l2_p95": 0.13878562080257548,
+            "relative_l2_max": 0.30221514303946656,
+            "weighted_relative_l2_mean": 0.021162645136322683,
+            "weighted_relative_frobenius": 0.011927566717317878,
+            "weighted_mean_cosine": 0.9989112583547245,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9541835879181099,
+            "mean_cosine": 0.9979284129801629,
+            "p05_cosine": 0.990434384937845,
+            "relative_l2_mean": 0.038211001031595915,
+            "relative_l2_p95": 0.13878562080257548,
+            "relative_l2_max": 0.30221514303946656,
+            "weighted_relative_l2_mean": 0.021162645136322683,
+            "weighted_relative_frobenius": 0.011927566717317878,
+            "weighted_mean_cosine": 0.9989112583547245,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.601149,
+            "warm_p50_ms": 0.07050500000000001,
+            "warm_p95_ms": 0.07572895,
+            "warm_p99_ms": 0.09061206,
+            "samples_ms": [
+              0.07473,
+              0.074312,
+              0.072426,
+              0.071517,
+              0.072844,
+              0.072914,
+              0.071937,
+              0.073334,
+              0.072844,
+              0.071936,
+              0.070959,
+              0.075708,
+              0.076127,
+              0.0748,
+              0.071867,
+              0.070959,
+              0.069073,
+              0.07054,
+              0.069632,
+              0.07047,
+              0.069492,
+              0.069143,
+              0.07047,
+              0.069492,
+              0.099873,
+              0.072914,
+              0.071029,
+              0.0704,
+              0.069073,
+              0.068654,
+              0.067607,
+              0.068723,
+              0.068096,
+              0.069073,
+              0.068654,
+              0.069493,
+              0.068165,
+              0.070051,
+              0.069981,
+              0.0704
+            ],
+            "warm_rows_per_second": 7261896.319409969
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3829955,
+              "unique_rows": 7747,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 485,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 485,
+              "zlib_blocks": 375,
+              "xor_blocks": 110,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7747
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "a09f6b89ed66dd418433bf89edcba90e16e2a747a7f916bd356ca9134c909cbe",
+            "table_sha256": "39ff3027b70891a0029412f7089d882ba34b74c4c3c0f307f90065aa8fab2cd8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5347587501164526,
+          "representatives_sha256": "51455a8f97507a51849fcf8a5d576f6a407a8ecdbaaabde92e2d7f69b81cc634",
+          "structurally_merged_rows": 5677,
+          "backend_artifact_bytes": 3831162,
+          "backend_with_key_registry_bytes": 4035110,
+          "backend_with_datrie_key_index_bytes": 3939754,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9018038404486557,
+            "mean_cosine": 0.9978519567597138,
+            "p05_cosine": 0.9902982040263192,
+            "relative_l2_mean": 0.038567436474365495,
+            "relative_l2_p95": 0.13939661712678836,
+            "relative_l2_max": 0.4441858606483749,
+            "weighted_relative_l2_mean": 0.02147655604447714,
+            "weighted_relative_frobenius": 0.013740973656759222,
+            "weighted_mean_cosine": 0.9988484043357869,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9018038404486557,
+            "mean_cosine": 0.9978519567597138,
+            "p05_cosine": 0.9902982040263192,
+            "relative_l2_mean": 0.038567436474365495,
+            "relative_l2_p95": 0.13939661712678836,
+            "relative_l2_max": 0.4441858606483749,
+            "weighted_relative_l2_mean": 0.02147655604447714,
+            "weighted_relative_frobenius": 0.013740973656759222,
+            "weighted_mean_cosine": 0.9988484043357869,
+            "max_relative_norm_change": 0.010098739162329335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.636209,
+            "warm_p50_ms": 0.071937,
+            "warm_p95_ms": 0.07531329999999999,
+            "warm_p99_ms": 0.08264379999999999,
+            "samples_ms": [
+              0.0748,
+              0.072915,
+              0.072425,
+              0.077105,
+              0.072356,
+              0.074312,
+              0.072845,
+              0.072356,
+              0.072914,
+              0.072355,
+              0.069562,
+              0.07054,
+              0.069981,
+              0.069982,
+              0.069981,
+              0.07054,
+              0.07061,
+              0.071098,
+              0.074241,
+              0.072844,
+              0.071937,
+              0.069632,
+              0.071937,
+              0.086185,
+              0.072426,
+              0.071937,
+              0.074241,
+              0.072425,
+              0.070959,
+              0.075219,
+              0.073333,
+              0.071448,
+              0.069911,
+              0.069073,
+              0.071517,
+              0.071448,
+              0.071029,
+              0.068584,
+              0.071378,
+              0.069562
+            ],
+            "warm_rows_per_second": 7117338.7825458385
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3436544,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "96287e438559898544cb2b53c3e3e1b1fc356fa0de75846da54b3e109092a525",
+            "table_sha256": "2b80ff97b7f3a0bdc95ac7eead482fad4fb6e9e7e25c67eb90f9c67d3d9aefef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.046544023090973496,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3437350,
+          "backend_with_key_registry_bytes": 3641298,
+          "backend_with_datrie_key_index_bytes": 3545942,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999624473883,
+            "mean_cosine": 0.9999999790488479,
+            "p05_cosine": 0.9999999732577625,
+            "relative_l2_mean": 0.00020648776297690362,
+            "relative_l2_p95": 0.00023381194563882685,
+            "relative_l2_max": 0.0002755920071979578,
+            "weighted_relative_l2_mean": 0.0002061626673808047,
+            "weighted_relative_frobenius": 0.00020539489681704117,
+            "weighted_mean_cosine": 0.999999979135146,
+            "max_relative_norm_change": 0.00013809462340430532
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.532261,
+            "warm_p50_ms": 0.22,
+            "warm_p95_ms": 0.22404074999999996,
+            "warm_p99_ms": 0.24538284999999999,
+            "samples_ms": [
+              0.223283,
+              0.221886,
+              0.220489,
+              0.219022,
+              0.22,
+              0.218603,
+              0.22,
+              0.220489,
+              0.22,
+              0.220489,
+              0.220001,
+              0.220908,
+              0.21993,
+              0.238438,
+              0.220978,
+              0.219162,
+              0.219581,
+              0.219582,
+              0.22042,
+              0.219023,
+              0.218953,
+              0.219512,
+              0.219512,
+              0.220001,
+              0.22,
+              0.219162,
+              0.219092,
+              0.219023,
+              0.218534,
+              0.219512,
+              0.22,
+              0.249823,
+              0.222864,
+              0.220419,
+              0.219093,
+              0.219582,
+              0.220559,
+              0.220489,
+              0.22,
+              0.219022
+            ],
+            "warm_rows_per_second": 2327272.727272727
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3248746,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "96287e438559898544cb2b53c3e3e1b1fc356fa0de75846da54b3e109092a525",
+            "table_sha256": "ca615eea8d5329ec5c737f7f154aa51f20547cef4211595c8cc9433f3a5f8f4b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3372036158107221,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3249955,
+          "backend_with_key_registry_bytes": 3453903,
+          "backend_with_datrie_key_index_bytes": 3358547,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999624473883,
+            "mean_cosine": 0.9999999790488479,
+            "p05_cosine": 0.9999999732577625,
+            "relative_l2_mean": 0.00020648776297690362,
+            "relative_l2_p95": 0.00023381194563882685,
+            "relative_l2_max": 0.0002755920071979578,
+            "weighted_relative_l2_mean": 0.0002061626673808047,
+            "weighted_relative_frobenius": 0.00020539489681704117,
+            "weighted_mean_cosine": 0.999999979135146,
+            "max_relative_norm_change": 0.00013809462340430532
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.196826,
+            "warm_p50_ms": 0.23019699999999998,
+            "warm_p95_ms": 0.24275135,
+            "warm_p99_ms": 0.25060545,
+            "samples_ms": [
+              0.232292,
+              0.231385,
+              0.254991,
+              0.234667,
+              0.229918,
+              0.229429,
+              0.229988,
+              0.229499,
+              0.228521,
+              0.228521,
+              0.229987,
+              0.229499,
+              0.229429,
+              0.22901,
+              0.22894,
+              0.230476,
+              0.228451,
+              0.230895,
+              0.229499,
+              0.242699,
+              0.230407,
+              0.230476,
+              0.230407,
+              0.232292,
+              0.231873,
+              0.232292,
+              0.230406,
+              0.228521,
+              0.22859,
+              0.228102,
+              0.229987,
+              0.229918,
+              0.229918,
+              0.232712,
+              0.231874,
+              0.232363,
+              0.230896,
+              0.243746,
+              0.231314,
+              0.22901
+            ],
+            "warm_rows_per_second": 2224181.896375713
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3248746,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "96287e438559898544cb2b53c3e3e1b1fc356fa0de75846da54b3e109092a525",
+            "table_sha256": "ca615eea8d5329ec5c737f7f154aa51f20547cef4211595c8cc9433f3a5f8f4b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37777592497877777,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3249954,
+          "backend_with_key_registry_bytes": 3453902,
+          "backend_with_datrie_key_index_bytes": 3358546,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999624473883,
+            "mean_cosine": 0.9999999790488479,
+            "p05_cosine": 0.9999999732577625,
+            "relative_l2_mean": 0.00020648776297690362,
+            "relative_l2_p95": 0.00023381194563882685,
+            "relative_l2_max": 0.0002755920071979578,
+            "weighted_relative_l2_mean": 0.0002061626673808047,
+            "weighted_relative_frobenius": 0.00020539489681704117,
+            "weighted_mean_cosine": 0.999999979135146,
+            "max_relative_norm_change": 0.00013809462340430532
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.136692,
+            "warm_p50_ms": 0.229499,
+            "warm_p95_ms": 0.23381474999999996,
+            "warm_p99_ms": 0.25277088,
+            "samples_ms": [
+              0.232851,
+              0.232222,
+              0.230895,
+              0.231454,
+              0.231314,
+              0.230407,
+              0.229918,
+              0.228939,
+              0.258273,
+              0.23327,
+              0.22859,
+              0.229499,
+              0.229499,
+              0.228521,
+              0.228521,
+              0.228521,
+              0.229499,
+              0.229917,
+              0.229918,
+              0.22894,
+              0.229009,
+              0.229499,
+              0.228521,
+              0.22901,
+              0.229918,
+              0.244165,
+              0.231384,
+              0.231873,
+              0.22901,
+              0.228102,
+              0.230337,
+              0.228521,
+              0.229009,
+              0.228521,
+              0.229009,
+              0.229429,
+              0.229918,
+              0.228451,
+              0.229359,
+              0.230407
+            ],
+            "warm_rows_per_second": 2230946.54007207
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3248746,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "96287e438559898544cb2b53c3e3e1b1fc356fa0de75846da54b3e109092a525",
+            "table_sha256": "ca615eea8d5329ec5c737f7f154aa51f20547cef4211595c8cc9433f3a5f8f4b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3295996389351785,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3249954,
+          "backend_with_key_registry_bytes": 3453902,
+          "backend_with_datrie_key_index_bytes": 3358546,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999624473883,
+            "mean_cosine": 0.9999999790488479,
+            "p05_cosine": 0.9999999732577625,
+            "relative_l2_mean": 0.00020648776297690362,
+            "relative_l2_p95": 0.00023381194563882685,
+            "relative_l2_max": 0.0002755920071979578,
+            "weighted_relative_l2_mean": 0.0002061626673808047,
+            "weighted_relative_frobenius": 0.00020539489681704117,
+            "weighted_mean_cosine": 0.999999979135146,
+            "max_relative_norm_change": 0.00013809462340430532
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.164629,
+            "warm_p50_ms": 0.23019699999999998,
+            "warm_p95_ms": 0.23499874999999998,
+            "warm_p99_ms": 0.24394329999999997,
+            "samples_ms": [
+              0.234178,
+              0.230966,
+              0.22908,
+              0.23327,
+              0.231873,
+              0.230895,
+              0.229917,
+              0.229918,
+              0.229918,
+              0.228451,
+              0.231315,
+              0.231874,
+              0.229429,
+              0.241302,
+              0.232712,
+              0.231804,
+              0.232293,
+              0.231385,
+              0.228521,
+              0.230895,
+              0.229009,
+              0.231385,
+              0.234667,
+              0.229918,
+              0.228521,
+              0.22894,
+              0.229988,
+              0.229498,
+              0.229918,
+              0.231315,
+              0.245632,
+              0.23327,
+              0.230406,
+              0.229499,
+              0.22901,
+              0.234178,
+              0.228101,
+              0.22908,
+              0.229498,
+              0.22908
+            ],
+            "warm_rows_per_second": 2224181.896375713
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 2095833,
+              "unique_rows": 8273,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 259,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 259,
+              "zlib_blocks": 117,
+              "xor_blocks": 142,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8273
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "56eaf00fd221231d5d3188c9ed0859c7ba0230673f6ccb33a1cace19834895fc",
+            "table_sha256": "92e55c0c7ba1f125aa517d3fa10a34f6fa879ed591f54e5519e4db8fe8fe9a5c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2195942709222436,
+          "representatives_sha256": "ed176ce71e84167bce823c740905ba40eabe50ed8eadf74fb5130a8e2c8c3fbf",
+          "structurally_merged_rows": 5151,
+          "backend_artifact_bytes": 2097040,
+          "backend_with_key_registry_bytes": 2300988,
+          "backend_with_datrie_key_index_bytes": 2205632,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900024178532458,
+            "mean_cosine": 0.9985803974928634,
+            "p05_cosine": 0.9930321598848577,
+            "relative_l2_mean": 0.031243688802523692,
+            "relative_l2_p95": 0.11812890288280987,
+            "relative_l2_max": 0.1423848947835388,
+            "weighted_relative_l2_mean": 0.017730440592170018,
+            "weighted_relative_frobenius": 0.009429329011061569,
+            "weighted_mean_cosine": 0.9992401131688717,
+            "max_relative_norm_change": 0.010144415505645151
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.990000929996695,
+            "mean_cosine": 0.9985803997905448,
+            "p05_cosine": 0.993032265603851,
+            "relative_l2_mean": 0.03111666172324363,
+            "relative_l2_p95": 0.11812310079870236,
+            "relative_l2_max": 0.14239308219003036,
+            "weighted_relative_l2_mean": 0.017573317428987902,
+            "weighted_relative_frobenius": 0.009427344865478818,
+            "weighted_mean_cosine": 0.9992401221857902,
+            "max_relative_norm_change": 0.01009549559175055
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.387586,
+            "warm_p50_ms": 0.228102,
+            "warm_p95_ms": 0.23965684999999998,
+            "warm_p99_ms": 0.25161237,
+            "samples_ms": [
+              0.245563,
+              0.231455,
+              0.230477,
+              0.229009,
+              0.226635,
+              0.229079,
+              0.22901,
+              0.22852,
+              0.228102,
+              0.232781,
+              0.227474,
+              0.228032,
+              0.226635,
+              0.229009,
+              0.227683,
+              0.227124,
+              0.227543,
+              0.25548,
+              0.230895,
+              0.227613,
+              0.228101,
+              0.228102,
+              0.228102,
+              0.228102,
+              0.227124,
+              0.227612,
+              0.228451,
+              0.227543,
+              0.226985,
+              0.227124,
+              0.232292,
+              0.232362,
+              0.231314,
+              0.228032,
+              0.228101,
+              0.239346,
+              0.228451,
+              0.228451,
+              0.226565,
+              0.23327
+            ],
+            "warm_rows_per_second": 2244609.86751541
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1989999,
+              "unique_rows": 7822,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 245,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 245,
+              "zlib_blocks": 142,
+              "xor_blocks": 103,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7822
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "f8f49b81a78fba298b146b9b3466b63acacabde65223e4c097a9958c7340fc89",
+            "table_sha256": "07df28a754d07375c6d041150d8ad49c0c212d4f435a8f0f21a4cd97efb42fa2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21171365305781364,
+          "representatives_sha256": "c2fe82c139ea01fe20fd09fc6180a3ea7206d946373ee9ad388752b37ed24a6f",
+          "structurally_merged_rows": 5602,
+          "backend_artifact_bytes": 1991206,
+          "backend_with_key_registry_bytes": 2195154,
+          "backend_with_datrie_key_index_bytes": 2099798,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800888265045965,
+            "mean_cosine": 0.9981042407515186,
+            "p05_cosine": 0.9910205144552796,
+            "relative_l2_mean": 0.03688405382576256,
+            "relative_l2_p95": 0.13436454643040865,
+            "relative_l2_max": 0.19937838717662318,
+            "weighted_relative_l2_mean": 0.0206012343269577,
+            "weighted_relative_frobenius": 0.011197578046986576,
+            "weighted_mean_cosine": 0.9989979012517765,
+            "max_relative_norm_change": 0.010144415505645151
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800901317835918,
+            "mean_cosine": 0.998104240470195,
+            "p05_cosine": 0.9910197197482495,
+            "relative_l2_mean": 0.03676396341980959,
+            "relative_l2_p95": 0.13435857381636385,
+            "relative_l2_max": 0.19938918351590493,
+            "weighted_relative_l2_mean": 0.020447662594474707,
+            "weighted_relative_frobenius": 0.01119595314295581,
+            "weighted_mean_cosine": 0.998997908979883,
+            "max_relative_norm_change": 0.01009549559175055
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.706283,
+            "warm_p50_ms": 0.228591,
+            "warm_p95_ms": 0.24009024999999998,
+            "warm_p99_ms": 0.25523152,
+            "samples_ms": [
+              0.233759,
+              0.231384,
+              0.228032,
+              0.263512,
+              0.231385,
+              0.229988,
+              0.229917,
+              0.228521,
+              0.235156,
+              0.229429,
+              0.229429,
+              0.227124,
+              0.228521,
+              0.227613,
+              0.228521,
+              0.22901,
+              0.227124,
+              0.228521,
+              0.228521,
+              0.228102,
+              0.22901,
+              0.24228,
+              0.228032,
+              0.228521,
+              0.22901,
+              0.228521,
+              0.229009,
+              0.22901,
+              0.228591,
+              0.228591,
+              0.228101,
+              0.227543,
+              0.227543,
+              0.22894,
+              0.228032,
+              0.22894,
+              0.228032,
+              0.228032,
+              0.239975,
+              0.230477
+            ],
+            "warm_rows_per_second": 2239808.216421469
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1975641,
+              "unique_rows": 7761,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 147,
+              "xor_blocks": 96,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7761
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "268022c62540b0526f85a737bbf91a69cf7b1c17d298b3e74a00a8428cff1ac9",
+            "table_sha256": "f8f3aa3e3bf40280fac9cc141ddb4aa69866396e39e3f7423472b342d4c62aef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21183035802096128,
+          "representatives_sha256": "8b939ab388426fe7cdd6a6cd2e1869f3f58ad8a2a20b6f35de3f206a8ffbeb98",
+          "structurally_merged_rows": 5663,
+          "backend_artifact_bytes": 1976847,
+          "backend_with_key_registry_bytes": 2180795,
+          "backend_with_datrie_key_index_bytes": 2085439,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9701754657329307,
+            "mean_cosine": 0.9979934603727224,
+            "p05_cosine": 0.9905709174976577,
+            "relative_l2_mean": 0.03788685498270028,
+            "relative_l2_p95": 0.13755797514434065,
+            "relative_l2_max": 0.2435025113904524,
+            "weighted_relative_l2_mean": 0.021085238308215817,
+            "weighted_relative_frobenius": 0.011236771970957654,
+            "weighted_mean_cosine": 0.9989444328806925,
+            "max_relative_norm_change": 0.010144415505645151
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9701766525044704,
+            "mean_cosine": 0.9979934598733242,
+            "p05_cosine": 0.9905711754792335,
+            "relative_l2_mean": 0.03776768677619807,
+            "relative_l2_p95": 0.13755447281450678,
+            "relative_l2_max": 0.2435007667911337,
+            "weighted_relative_l2_mean": 0.02093211167713961,
+            "weighted_relative_frobenius": 0.011235152675622983,
+            "weighted_mean_cosine": 0.9989444405035449,
+            "max_relative_norm_change": 0.01009549559175055
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.844988,
+            "warm_p50_ms": 0.22855599999999998,
+            "warm_p95_ms": 0.23528159999999995,
+            "warm_p99_ms": 0.25215681,
+            "samples_ms": [
+              0.234667,
+              0.229428,
+              0.228521,
+              0.229009,
+              0.228521,
+              0.230407,
+              0.22894,
+              0.246959,
+              0.230406,
+              0.229918,
+              0.228521,
+              0.234248,
+              0.228521,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.228032,
+              0.229499,
+              0.228521,
+              0.228591,
+              0.226636,
+              0.22901,
+              0.227054,
+              0.22894,
+              0.25548,
+              0.231385,
+              0.228521,
+              0.22901,
+              0.228032,
+              0.227613,
+              0.228101,
+              0.22908,
+              0.22852,
+              0.228032,
+              0.228102,
+              0.228102,
+              0.22908,
+              0.228591,
+              0.228102,
+              0.22901
+            ],
+            "warm_rows_per_second": 2240151.2102066893
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1972179,
+              "unique_rows": 7748,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 145,
+              "xor_blocks": 98,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7748
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "63cfcd51abe0eda4ed238fd06eb26647a67587409413bfb7ac7f699c9486f1fa",
+            "table_sha256": "a81a1394f0778cafd5297072928a55e30a1bcefd827ceeeba2d960b9b5431172",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21017833007499576,
+          "representatives_sha256": "c481cae84367913420e59ee097fd0ddf5764e1de3671955bd01d640d0f37577a",
+          "structurally_merged_rows": 5676,
+          "backend_artifact_bytes": 1973385,
+          "backend_with_key_registry_bytes": 2177333,
+          "backend_with_datrie_key_index_bytes": 2081977,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.954181865359993,
+            "mean_cosine": 0.9979243542256204,
+            "p05_cosine": 0.9903884267258661,
+            "relative_l2_mean": 0.03835742068413006,
+            "relative_l2_p95": 0.13892009584453222,
+            "relative_l2_max": 0.3022227389598215,
+            "weighted_relative_l2_mean": 0.021322789291119113,
+            "weighted_relative_frobenius": 0.01192848331866381,
+            "weighted_mean_cosine": 0.9989095748776344,
+            "max_relative_norm_change": 0.010144415505645151
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9541761878334689,
+            "mean_cosine": 0.9979243561361446,
+            "p05_cosine": 0.9903923922398393,
+            "relative_l2_mean": 0.038238458244003334,
+            "relative_l2_p95": 0.1389393631537763,
+            "relative_l2_max": 0.30224075637297,
+            "weighted_relative_l2_mean": 0.021169770600335598,
+            "weighted_relative_frobenius": 0.011926915414780088,
+            "weighted_mean_cosine": 0.998909583596941,
+            "max_relative_norm_change": 0.01009549559175055
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.459324,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.2455865,
+            "warm_p99_ms": 0.24980045,
+            "samples_ms": [
+              0.245562,
+              0.230825,
+              0.22901,
+              0.22901,
+              0.22894,
+              0.230896,
+              0.229009,
+              0.228521,
+              0.228521,
+              0.228591,
+              0.228591,
+              0.227613,
+              0.227612,
+              0.227543,
+              0.227473,
+              0.228451,
+              0.227962,
+              0.252197,
+              0.232852,
+              0.229499,
+              0.229079,
+              0.228032,
+              0.229009,
+              0.229499,
+              0.228032,
+              0.227613,
+              0.227124,
+              0.229499,
+              0.226635,
+              0.228451,
+              0.227962,
+              0.22894,
+              0.227962,
+              0.228451,
+              0.227054,
+              0.246052,
+              0.228032,
+              0.228032,
+              0.228521,
+              0.22901
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1971971,
+              "unique_rows": 7747,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 242,
+              "zlib_blocks": 143,
+              "xor_blocks": 99,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7747
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "4c4c6b90e7c737fd6c96215bd44b232c78279c6840afb843c1f8d5faadd708dd",
+            "table_sha256": "591e7973ade21bfc369f95299b23a1cc8d7fab6a0dbcc8f687538101027bbe9c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2120769671164453,
+          "representatives_sha256": "61e1e77f028074e2b570d2862e46e8d8dd4fc04ef591847983ec72799b151b5f",
+          "structurally_merged_rows": 5677,
+          "backend_artifact_bytes": 1973177,
+          "backend_with_key_registry_bytes": 2177125,
+          "backend_with_datrie_key_index_bytes": 2081769,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.901805312261854,
+            "mean_cosine": 0.997847901598986,
+            "p05_cosine": 0.9902505659728731,
+            "relative_l2_mean": 0.03871382576390896,
+            "relative_l2_p95": 0.13970869337341724,
+            "relative_l2_max": 0.4441902891025155,
+            "weighted_relative_l2_mean": 0.02163662011637838,
+            "weighted_relative_frobenius": 0.013741876451980672,
+            "weighted_mean_cosine": 0.9988467197431203,
+            "max_relative_norm_change": 0.010144415505645151
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9017986396335538,
+            "mean_cosine": 0.9978479037967246,
+            "p05_cosine": 0.9902529993504882,
+            "relative_l2_mean": 0.03859487242884875,
+            "relative_l2_p95": 0.1396913321348921,
+            "relative_l2_max": 0.4441979481016298,
+            "weighted_relative_l2_mean": 0.02148367721683346,
+            "weighted_relative_frobenius": 0.01374048403282683,
+            "weighted_mean_cosine": 0.9988467293545563,
+            "max_relative_norm_change": 0.01009549559175055
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.392626,
+            "warm_p50_ms": 0.2289745,
+            "warm_p95_ms": 0.24229995,
+            "warm_p99_ms": 0.26868643999999997,
+            "samples_ms": [
+              0.233689,
+              0.230895,
+              0.229499,
+              0.230896,
+              0.234667,
+              0.22894,
+              0.229009,
+              0.22901,
+              0.229009,
+              0.228032,
+              0.229009,
+              0.22901,
+              0.234248,
+              0.285302,
+              0.227612,
+              0.228102,
+              0.242698,
+              0.232292,
+              0.226705,
+              0.228102,
+              0.22901,
+              0.227543,
+              0.228102,
+              0.227962,
+              0.226565,
+              0.232781,
+              0.22908,
+              0.227613,
+              0.228101,
+              0.231803,
+              0.22901,
+              0.228033,
+              0.228521,
+              0.242279,
+              0.228521,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.228451,
+              0.228521
+            ],
+            "warm_rows_per_second": 2236056.8534924197
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1771968,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "936ada1dd32ce053f2eae8e789655b9755eedb813052ae37096c04d212ea1676",
+            "table_sha256": "2f4c5b511ef141ff93c2e65b8dfe703922f9a8ceb888373c3404c3637462433c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03555343905463815,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1772818,
+          "backend_with_key_registry_bytes": 1976766,
+          "backend_with_datrie_key_index_bytes": 1881410,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999343570082099,
+            "mean_cosine": 0.9999791548061561,
+            "p05_cosine": 0.9999695758894899,
+            "relative_l2_mean": 0.006434222600084341,
+            "relative_l2_p95": 0.007831241239552863,
+            "relative_l2_max": 0.01149384799161637,
+            "weighted_relative_l2_mean": 0.006429317675511283,
+            "weighted_relative_frobenius": 0.006447832497899354,
+            "weighted_mean_cosine": 0.9999791906665058,
+            "max_relative_norm_change": 0.002474475834241514
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.370927,
+            "warm_p50_ms": 0.121593,
+            "warm_p95_ms": 0.12580234999999995,
+            "warm_p99_ms": 0.15032884999999999,
+            "samples_ms": [
+              0.123969,
+              0.122502,
+              0.121035,
+              0.121035,
+              0.120197,
+              0.143384,
+              0.122502,
+              0.121594,
+              0.121594,
+              0.121105,
+              0.121105,
+              0.122991,
+              0.120686,
+              0.120197,
+              0.121663,
+              0.121524,
+              0.121035,
+              0.120616,
+              0.121594,
+              0.121594,
+              0.121105,
+              0.121105,
+              0.121594,
+              0.121105,
+              0.121105,
+              0.121593,
+              0.121594,
+              0.121105,
+              0.121594,
+              0.121175,
+              0.121175,
+              0.122013,
+              0.121036,
+              0.122502,
+              0.122013,
+              0.121593,
+              0.122991,
+              0.154769,
+              0.124877,
+              0.121524
+            ],
+            "warm_rows_per_second": 4210768.712014671
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1650858,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "936ada1dd32ce053f2eae8e789655b9755eedb813052ae37096c04d212ea1676",
+            "table_sha256": "4bc4e16333c3920adf5e486738f0bbec7da147d3979e429464b66012c4b57002",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20863979496061802,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1652111,
+          "backend_with_key_registry_bytes": 1856059,
+          "backend_with_datrie_key_index_bytes": 1760703,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999343570082099,
+            "mean_cosine": 0.9999791548061561,
+            "p05_cosine": 0.9999695758894899,
+            "relative_l2_mean": 0.006434222600084341,
+            "relative_l2_p95": 0.007831241239552863,
+            "relative_l2_max": 0.01149384799161637,
+            "weighted_relative_l2_mean": 0.006429317675511283,
+            "weighted_relative_frobenius": 0.006447832497899354,
+            "weighted_mean_cosine": 0.9999791906665058,
+            "max_relative_norm_change": 0.002474475834241514
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.087396,
+            "warm_p50_ms": 0.132245,
+            "warm_p95_ms": 0.1377069,
+            "warm_p99_ms": 0.15133132,
+            "samples_ms": [
+              0.13682,
+              0.135353,
+              0.132908,
+              0.132489,
+              0.131511,
+              0.132001,
+              0.132978,
+              0.133397,
+              0.131512,
+              0.133397,
+              0.133397,
+              0.133397,
+              0.132489,
+              0.133467,
+              0.159448,
+              0.137658,
+              0.133467,
+              0.131511,
+              0.133397,
+              0.133397,
+              0.131092,
+              0.131511,
+              0.138636,
+              0.131511,
+              0.131092,
+              0.131581,
+              0.131092,
+              0.130114,
+              0.131511,
+              0.131511,
+              0.132489,
+              0.132908,
+              0.131022,
+              0.131092,
+              0.131092,
+              0.132001,
+              0.131512,
+              0.135283,
+              0.131512,
+              0.131023
+            ],
+            "warm_rows_per_second": 3871601.9509244207
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1650858,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "936ada1dd32ce053f2eae8e789655b9755eedb813052ae37096c04d212ea1676",
+            "table_sha256": "4bc4e16333c3920adf5e486738f0bbec7da147d3979e429464b66012c4b57002",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24100860790349543,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1652110,
+          "backend_with_key_registry_bytes": 1856058,
+          "backend_with_datrie_key_index_bytes": 1760702,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999343570082099,
+            "mean_cosine": 0.9999791548061561,
+            "p05_cosine": 0.9999695758894899,
+            "relative_l2_mean": 0.006434222600084341,
+            "relative_l2_p95": 0.007831241239552863,
+            "relative_l2_max": 0.01149384799161637,
+            "weighted_relative_l2_mean": 0.006429317675511283,
+            "weighted_relative_frobenius": 0.006447832497899354,
+            "weighted_mean_cosine": 0.9999791906665058,
+            "max_relative_norm_change": 0.002474475834241514
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.986545,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.18123789999999998,
+            "warm_p99_ms": 0.20799994999999996,
+            "samples_ms": [
+              0.182566,
+              0.224261,
+              0.181168,
+              0.153231,
+              0.138076,
+              0.135282,
+              0.133466,
+              0.132978,
+              0.131511,
+              0.133397,
+              0.131511,
+              0.131511,
+              0.130185,
+              0.132001,
+              0.131023,
+              0.132489,
+              0.131511,
+              0.131581,
+              0.131023,
+              0.131512,
+              0.131023,
+              0.131511,
+              0.130533,
+              0.131581,
+              0.130533,
+              0.131512,
+              0.130185,
+              0.130115,
+              0.130115,
+              0.130534,
+              0.147505,
+              0.132,
+              0.132,
+              0.129137,
+              0.130603,
+              0.132419,
+              0.131511,
+              0.131092,
+              0.128718,
+              0.129696
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1650858,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "936ada1dd32ce053f2eae8e789655b9755eedb813052ae37096c04d212ea1676",
+            "table_sha256": "4bc4e16333c3920adf5e486738f0bbec7da147d3979e429464b66012c4b57002",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20534768304787576,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1652110,
+          "backend_with_key_registry_bytes": 1856058,
+          "backend_with_datrie_key_index_bytes": 1760702,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999343570082099,
+            "mean_cosine": 0.9999791548061561,
+            "p05_cosine": 0.9999695758894899,
+            "relative_l2_mean": 0.006434222600084341,
+            "relative_l2_p95": 0.007831241239552863,
+            "relative_l2_max": 0.01149384799161637,
+            "weighted_relative_l2_mean": 0.006429317675511283,
+            "weighted_relative_frobenius": 0.006447832497899354,
+            "weighted_mean_cosine": 0.9999791906665058,
+            "max_relative_norm_change": 0.002474475834241514
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.005053,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.13691669999999997,
+            "warm_p99_ms": 0.16284735,
+            "samples_ms": [
+              0.13633,
+              0.132489,
+              0.132978,
+              0.132,
+              0.132,
+              0.133397,
+              0.172299,
+              0.132419,
+              0.130114,
+              0.131092,
+              0.130044,
+              0.131511,
+              0.130604,
+              0.130115,
+              0.131511,
+              0.130604,
+              0.131023,
+              0.130604,
+              0.131092,
+              0.130603,
+              0.131511,
+              0.131022,
+              0.132909,
+              0.132489,
+              0.131022,
+              0.132001,
+              0.131581,
+              0.131022,
+              0.131511,
+              0.130603,
+              0.131092,
+              0.131022,
+              0.130603,
+              0.132489,
+              0.130604,
+              0.148064,
+              0.134375,
+              0.13249,
+              0.131511,
+              0.131022
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1121086,
+              "unique_rows": 8260,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 134,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 134,
+              "zlib_blocks": 1,
+              "xor_blocks": 133,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8260
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "7558a424db6b844640af2a6a58ef15709a4b584e7c283baeed479d4527cbf50c",
+            "table_sha256": "d36e52ecb6d3234742426ee269924770d3b4c6fafcbf202d37619a482b2f5f38",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15218486497178674,
+          "representatives_sha256": "82be164cdf157468610b6db2e2257f1d76bdca0c4b9d182a4e2251863e483cb8",
+          "structurally_merged_rows": 5164,
+          "backend_artifact_bytes": 1122335,
+          "backend_with_key_registry_bytes": 1326283,
+          "backend_with_datrie_key_index_bytes": 1230927,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9899331977747489,
+            "mean_cosine": 0.9985628673427508,
+            "p05_cosine": 0.9930390796651419,
+            "relative_l2_mean": 0.035194847701975375,
+            "relative_l2_p95": 0.11802303300346849,
+            "relative_l2_max": 0.14274862236861094,
+            "weighted_relative_l2_mean": 0.022594762018323916,
+            "weighted_relative_frobenius": 0.011437149201513133,
+            "weighted_mean_cosine": 0.9992194986549326,
+            "max_relative_norm_change": 0.012096284539880018
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900021916904238,
+            "mean_cosine": 0.9985678118846913,
+            "p05_cosine": 0.9929912011373572,
+            "relative_l2_mean": 0.031355825466672094,
+            "relative_l2_p95": 0.11840375444857451,
+            "relative_l2_max": 0.14238893298141875,
+            "weighted_relative_l2_mean": 0.017772480241204428,
+            "weighted_relative_frobenius": 0.00957913732749358,
+            "weighted_mean_cosine": 0.999230502642842,
+            "max_relative_norm_change": 0.010095610896274757
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.333831,
+            "warm_p50_ms": 0.131092,
+            "warm_p95_ms": 0.13349479999999997,
+            "warm_p99_ms": 0.1431488,
+            "samples_ms": [
+              0.135353,
+              0.132489,
+              0.131511,
+              0.131022,
+              0.131581,
+              0.133397,
+              0.131511,
+              0.133397,
+              0.131023,
+              0.132,
+              0.129696,
+              0.131512,
+              0.130603,
+              0.130534,
+              0.129556,
+              0.130115,
+              0.131022,
+              0.131092,
+              0.131511,
+              0.131511,
+              0.131093,
+              0.130604,
+              0.131023,
+              0.131511,
+              0.131581,
+              0.130534,
+              0.148133,
+              0.131022,
+              0.131512,
+              0.129695,
+              0.129695,
+              0.131092,
+              0.130603,
+              0.131511,
+              0.131512,
+              0.132,
+              0.131092,
+              0.131022,
+              0.129556,
+              0.130045
+            ],
+            "warm_rows_per_second": 3905654.0444878405
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1069332,
+              "unique_rows": 7792,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 126,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 126,
+              "zlib_blocks": 5,
+              "xor_blocks": 121,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7792
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "d62cc5cf74e9c9ccfd174102ce2f797db91c447b8042585a4516071187695b7b",
+            "table_sha256": "f80324fd8e95234685d7aa8ebd715103196c78f0d609974442d47c6578c302a9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13925827806815505,
+          "representatives_sha256": "40292b9de8f011ee9a8b8e640083fd1644dfcbe48e80d8ab318bede6a89016e1",
+          "structurally_merged_rows": 5632,
+          "backend_artifact_bytes": 1070581,
+          "backend_with_key_registry_bytes": 1274529,
+          "backend_with_datrie_key_index_bytes": 1179173,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.980040324320278,
+            "mean_cosine": 0.9980752713199419,
+            "p05_cosine": 0.99092569986586,
+            "relative_l2_mean": 0.040799656727808845,
+            "relative_l2_p95": 0.13498458310318215,
+            "relative_l2_max": 0.19976252785204607,
+            "weighted_relative_l2_mean": 0.0254422516054999,
+            "weighted_relative_frobenius": 0.012937681127503741,
+            "weighted_mean_cosine": 0.9989719276880858,
+            "max_relative_norm_change": 0.012096284539880018
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.980047817712512,
+            "mean_cosine": 0.9980789571770594,
+            "p05_cosine": 0.9909136406377175,
+            "relative_l2_mean": 0.037184530421651284,
+            "relative_l2_p95": 0.13508435168474658,
+            "relative_l2_max": 0.19974615358554437,
+            "weighted_relative_l2_mean": 0.020733881045874192,
+            "weighted_relative_frobenius": 0.011336531353083762,
+            "weighted_mean_cosine": 0.9989822505369915,
+            "max_relative_norm_change": 0.010097003474836263
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.865894,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.1367954,
+            "warm_p99_ms": 0.15384678999999998,
+            "samples_ms": [
+              0.137658,
+              0.132978,
+              0.132,
+              0.132419,
+              0.132489,
+              0.132489,
+              0.132,
+              0.13675,
+              0.132001,
+              0.131511,
+              0.132,
+              0.131022,
+              0.133397,
+              0.132001,
+              0.131511,
+              0.132489,
+              0.132,
+              0.134864,
+              0.132419,
+              0.132489,
+              0.131023,
+              0.130114,
+              0.135772,
+              0.130045,
+              0.131511,
+              0.131022,
+              0.130603,
+              0.130115,
+              0.129626,
+              0.164197,
+              0.133956,
+              0.131023,
+              0.131512,
+              0.131023,
+              0.131511,
+              0.132,
+              0.130114,
+              0.129625,
+              0.130603,
+              0.129696
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1062058,
+              "unique_rows": 7730,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 6,
+              "xor_blocks": 119,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7730
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "92ab7de0cff1ab49c6ea19a747212090b80dcecab1ad6f1f938946ee156a61a0",
+            "table_sha256": "482ddd7ed4605d56276772585d97c49ab8bd69597c2b341199ad38d55afc0ee1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1396121650468558,
+          "representatives_sha256": "a557e466cb97ea8c833dc4804e7e0d3aca9eba6052a9c3fc074c3ee0f0407a67",
+          "structurally_merged_rows": 5694,
+          "backend_artifact_bytes": 1063307,
+          "backend_with_key_registry_bytes": 1267255,
+          "backend_with_datrie_key_index_bytes": 1171899,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9710328465263668,
+            "mean_cosine": 0.997964249255204,
+            "p05_cosine": 0.9904656762202363,
+            "relative_l2_mean": 0.04178345412339522,
+            "relative_l2_p95": 0.13827300739605883,
+            "relative_l2_max": 0.24130476390305955,
+            "weighted_relative_l2_mean": 0.025917083383386188,
+            "weighted_relative_frobenius": 0.012971974081592072,
+            "weighted_mean_cosine": 0.9989183426667994,
+            "max_relative_norm_change": 0.012096284539880018
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9708969263450682,
+            "mean_cosine": 0.9979676724494986,
+            "p05_cosine": 0.9904378721927583,
+            "relative_l2_mean": 0.03819809588165435,
+            "relative_l2_p95": 0.13873252170292694,
+            "relative_l2_max": 0.24185314366647992,
+            "weighted_relative_l2_mean": 0.021223080439505985,
+            "weighted_relative_frobenius": 0.011375745984991156,
+            "weighted_mean_cosine": 0.9989285387409689,
+            "max_relative_norm_change": 0.010097003474836263
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.825735,
+            "warm_p50_ms": 0.13130199999999997,
+            "warm_p95_ms": 0.14043964999999997,
+            "warm_p99_ms": 0.16221437,
+            "samples_ms": [
+              0.156165,
+              0.132978,
+              0.132419,
+              0.131022,
+              0.130533,
+              0.131512,
+              0.135283,
+              0.139612,
+              0.131092,
+              0.132,
+              0.130114,
+              0.131511,
+              0.132419,
+              0.129207,
+              0.130114,
+              0.130114,
+              0.131581,
+              0.131022,
+              0.130044,
+              0.132489,
+              0.131512,
+              0.131023,
+              0.130115,
+              0.130534,
+              0.131511,
+              0.131511,
+              0.131022,
+              0.130603,
+              0.130533,
+              0.166082,
+              0.135772,
+              0.132489,
+              0.132489,
+              0.131092,
+              0.132489,
+              0.131093,
+              0.131092,
+              0.135353,
+              0.128718,
+              0.128717
+            ],
+            "warm_rows_per_second": 3899407.472848853
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1060585,
+              "unique_rows": 7717,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 3,
+              "xor_blocks": 122,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7717
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "200c592a890fd684e07b59c2c9a0be13bb0f9807ab7a1905f4e9ced4dd7086fa",
+            "table_sha256": "059214151aadee08a67e05a4ad3d998b746e1c7974053c942998857019117e0a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13991869892925024,
+          "representatives_sha256": "16b9a587b67664f168f9a062331119e5f8260ff15708ccef58ddafbab9fc0666",
+          "structurally_merged_rows": 5707,
+          "backend_artifact_bytes": 1061834,
+          "backend_with_key_registry_bytes": 1265782,
+          "backend_with_datrie_key_index_bytes": 1170426,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9540329222020274,
+            "mean_cosine": 0.9978945228003459,
+            "p05_cosine": 0.9902540884725967,
+            "relative_l2_mean": 0.042250876563899045,
+            "relative_l2_p95": 0.13958307447372006,
+            "relative_l2_max": 0.3026913308363412,
+            "weighted_relative_l2_mean": 0.026152889877607343,
+            "weighted_relative_frobenius": 0.013574974339733748,
+            "weighted_mean_cosine": 0.9988831872819481,
+            "max_relative_norm_change": 0.012096284539880018
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9542004255230913,
+            "mean_cosine": 0.9978979280638607,
+            "p05_cosine": 0.990223481380006,
+            "relative_l2_mean": 0.03867101870432088,
+            "relative_l2_p95": 0.1398390536487522,
+            "relative_l2_max": 0.3021072149731349,
+            "weighted_relative_l2_mean": 0.021461805067035492,
+            "weighted_relative_frobenius": 0.012059187754506493,
+            "weighted_mean_cosine": 0.9988933665180764,
+            "max_relative_norm_change": 0.010097003474836263
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.945303,
+            "warm_p50_ms": 0.1327335,
+            "warm_p95_ms": 0.15203059999999996,
+            "warm_p99_ms": 0.17440129999999998,
+            "samples_ms": [
+              0.163708,
+              0.137238,
+              0.134375,
+              0.132978,
+              0.131511,
+              0.133397,
+              0.133397,
+              0.132,
+              0.131511,
+              0.132419,
+              0.131512,
+              0.130604,
+              0.130185,
+              0.131512,
+              0.134375,
+              0.133886,
+              0.130534,
+              0.131511,
+              0.131022,
+              0.132,
+              0.130045,
+              0.130114,
+              0.13626,
+              0.131022,
+              0.131022,
+              0.129556,
+              0.135212,
+              0.133467,
+              0.13668,
+              0.181238,
+              0.151416,
+              0.135283,
+              0.133956,
+              0.132489,
+              0.132978,
+              0.131511,
+              0.135352,
+              0.134794,
+              0.133467,
+              0.132
+            ],
+            "warm_rows_per_second": 3857353.26801448
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1060362,
+              "unique_rows": 7715,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 2,
+              "xor_blocks": 123,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7715
+            },
+            "source_float32_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477",
+            "decoded_float32_sha256": "2aa75a12dbb5de141c033222ba01e64cbe02620fadea61b0c4eadfa20ca5d643",
+            "table_sha256": "8aa52b52fa923d903a16b186271dd820d75606a7d15a775bdea4630567d2d584",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13519413978792727,
+          "representatives_sha256": "211862e944b12fc74dd3ca1ef04f19d8d4160da3fcd52ea80b8f46235282d3df",
+          "structurally_merged_rows": 5709,
+          "backend_artifact_bytes": 1061611,
+          "backend_with_key_registry_bytes": 1265559,
+          "backend_with_datrie_key_index_bytes": 1170203,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9006502866041701,
+            "mean_cosine": 0.9978134194705304,
+            "p05_cosine": 0.9901880738674116,
+            "relative_l2_mean": 0.04262239373268259,
+            "relative_l2_p95": 0.13999205434236361,
+            "relative_l2_max": 0.44807027362231283,
+            "weighted_relative_l2_mean": 0.026471557711032132,
+            "weighted_relative_frobenius": 0.015273659929497222,
+            "weighted_mean_cosine": 0.9988181324204763,
+            "max_relative_norm_change": 0.012096284539880018
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9002741030671103,
+            "mean_cosine": 0.9978167763871402,
+            "p05_cosine": 0.9901294460632106,
+            "relative_l2_mean": 0.03904303577942174,
+            "relative_l2_p95": 0.14046688671681148,
+            "relative_l2_max": 0.4488711689341506,
+            "weighted_relative_l2_mean": 0.021783149111407735,
+            "weighted_relative_frobenius": 0.01394742787711847,
+            "weighted_mean_cosine": 0.9988282245388411,
+            "max_relative_norm_change": 0.010097003474836263
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.930706,
+            "warm_p50_ms": 0.131581,
+            "warm_p95_ms": 0.13542614999999997,
+            "warm_p99_ms": 0.14474985999999998,
+            "samples_ms": [
+              0.135283,
+              0.133397,
+              0.132978,
+              0.132419,
+              0.131092,
+              0.132978,
+              0.132,
+              0.132,
+              0.131511,
+              0.130534,
+              0.13249,
+              0.131581,
+              0.134375,
+              0.148972,
+              0.132978,
+              0.130533,
+              0.129626,
+              0.131093,
+              0.130114,
+              0.131022,
+              0.130044,
+              0.131581,
+              0.131511,
+              0.131093,
+              0.130604,
+              0.129137,
+              0.131581,
+              0.131511,
+              0.132489,
+              0.131092,
+              0.130604,
+              0.131093,
+              0.132978,
+              0.131511,
+              0.129695,
+              0.131581,
+              0.132489,
+              0.132489,
+              0.138146,
+              0.132977
+            ],
+            "warm_rows_per_second": 3891139.298226948
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "00284f971f805571271cde5339ddc057c00eb8e6117ce037be95c658a9f03477"
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "rows": 13424,
+      "dim": 128,
+      "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+      "source_float32_bytes": 6873088,
+      "key_registry_bytes": 203948,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 108592,
+      "query_rows": 512,
+      "query_ids_sha256": "80ab83de1ecc982405671e980d9e9a66070e51aead43121126faabb6b44a50cd",
+      "frequency_trace_sha256": "1a0389197253d049e85973cd9812529ea0dc3eae69dcdb62085a34b49c0d90b8",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 6873088,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "table_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.037072138860821724,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6873893,
+          "backend_with_key_registry_bytes": 7077841,
+          "backend_with_datrie_key_index_bytes": 6982485,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.386572,
+            "warm_p50_ms": 0.06289249999999999,
+            "warm_p95_ms": 0.06544169999999999,
+            "warm_p99_ms": 0.06813809,
+            "samples_ms": [
+              0.065302,
+              0.063905,
+              0.061949,
+              0.061949,
+              0.062857,
+              0.063346,
+              0.068096,
+              0.062997,
+              0.062927,
+              0.062928,
+              0.063346,
+              0.063416,
+              0.062858,
+              0.062368,
+              0.062857,
+              0.063416,
+              0.06153,
+              0.062997,
+              0.061041,
+              0.062368,
+              0.062928,
+              0.068165,
+              0.063486,
+              0.062508,
+              0.063416,
+              0.062438,
+              0.06146,
+              0.063346,
+              0.061112,
+              0.063416,
+              0.061041,
+              0.060971,
+              0.061111,
+              0.061041,
+              0.062997,
+              0.063416,
+              0.062019,
+              0.063276,
+              0.062858,
+              0.06146
+            ],
+            "warm_rows_per_second": 8140875.303096555
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6483016,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 49,
+              "xor_blocks": 790,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "table_sha256": "155a7eeaf0a3e1ce31e77710c5f910993a527b89c27a8e96445f611cb49c6061",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5773331308737397,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6484225,
+          "backend_with_key_registry_bytes": 6688173,
+          "backend_with_datrie_key_index_bytes": 6592817,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.384338,
+            "warm_p50_ms": 0.071937,
+            "warm_p95_ms": 0.07710485,
+            "warm_p99_ms": 0.08512064999999999,
+            "samples_ms": [
+              0.078432,
+              0.077035,
+              0.074242,
+              0.076127,
+              0.07473,
+              0.075219,
+              0.07522,
+              0.075219,
+              0.071937,
+              0.072356,
+              0.071937,
+              0.072425,
+              0.07054,
+              0.071378,
+              0.072355,
+              0.072355,
+              0.071867,
+              0.071937,
+              0.071517,
+              0.071378,
+              0.089397,
+              0.071447,
+              0.071518,
+              0.071448,
+              0.072844,
+              0.071028,
+              0.071448,
+              0.070889,
+              0.071867,
+              0.070889,
+              0.071377,
+              0.072845,
+              0.071867,
+              0.072286,
+              0.070959,
+              0.072356,
+              0.071867,
+              0.072356,
+              0.072355,
+              0.071867
+            ],
+            "warm_rows_per_second": 7117338.7825458385
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6483016,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 49,
+              "xor_blocks": 790,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "table_sha256": "155a7eeaf0a3e1ce31e77710c5f910993a527b89c27a8e96445f611cb49c6061",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.633567641954869,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6484224,
+          "backend_with_key_registry_bytes": 6688172,
+          "backend_with_datrie_key_index_bytes": 6592816,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.382941,
+            "warm_p50_ms": 0.072426,
+            "warm_p95_ms": 0.07584769999999999,
+            "warm_p99_ms": 0.07965185,
+            "samples_ms": [
+              0.080387,
+              0.078502,
+              0.075708,
+              0.0748,
+              0.073334,
+              0.073334,
+              0.073822,
+              0.073822,
+              0.073752,
+              0.073333,
+              0.072845,
+              0.071867,
+              0.074242,
+              0.071448,
+              0.072425,
+              0.072355,
+              0.071518,
+              0.072915,
+              0.072426,
+              0.071517,
+              0.072006,
+              0.073334,
+              0.072356,
+              0.071937,
+              0.071936,
+              0.074241,
+              0.071866,
+              0.073403,
+              0.072007,
+              0.071029,
+              0.072006,
+              0.071518,
+              0.072426,
+              0.071518,
+              0.071517,
+              0.071937,
+              0.073823,
+              0.071448,
+              0.074241,
+              0.072844
+            ],
+            "warm_rows_per_second": 7069284.511087178
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 6483016,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 839,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 839,
+              "zlib_blocks": 49,
+              "xor_blocks": 790,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "table_sha256": "155a7eeaf0a3e1ce31e77710c5f910993a527b89c27a8e96445f611cb49c6061",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5860995480325073,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6484224,
+          "backend_with_key_registry_bytes": 6688172,
+          "backend_with_datrie_key_index_bytes": 6592816,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.446357,
+            "warm_p50_ms": 0.072146,
+            "warm_p95_ms": 0.0762005,
+            "warm_p99_ms": 0.09407533999999998,
+            "samples_ms": [
+              0.076127,
+              0.075708,
+              0.075219,
+              0.076267,
+              0.076127,
+              0.073752,
+              0.073892,
+              0.076197,
+              0.075708,
+              0.074241,
+              0.075219,
+              0.073822,
+              0.074311,
+              0.073822,
+              0.071028,
+              0.073333,
+              0.072355,
+              0.073334,
+              0.071937,
+              0.071867,
+              0.071447,
+              0.070959,
+              0.071378,
+              0.071378,
+              0.071867,
+              0.105461,
+              0.075289,
+              0.071029,
+              0.0704,
+              0.069981,
+              0.07047,
+              0.072356,
+              0.071937,
+              0.070958,
+              0.071448,
+              0.071448,
+              0.071447,
+              0.071518,
+              0.071447,
+              0.071936
+            ],
+            "warm_rows_per_second": 7096720.538907216
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 4100169,
+              "unique_rows": 8312,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 520,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 520,
+              "zlib_blocks": 366,
+              "xor_blocks": 154,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8312
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "c4a16f41fcd1cfbf9ebcd3c7266344da7538a4ea7d782e8a916adae61b1781a8",
+            "table_sha256": "0dfd077b4a4269f591f06ad12cd2b429d287f401b93893aa11816fdce8750a62",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38464223803021014,
+          "representatives_sha256": "18ab6ecdeda144e906690d1f311cd7a0dd27c6372b04725bcf51dc68e687c52a",
+          "structurally_merged_rows": 5112,
+          "backend_artifact_bytes": 4101376,
+          "backend_with_key_registry_bytes": 4305324,
+          "backend_with_datrie_key_index_bytes": 4209968,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900007999373839,
+            "mean_cosine": 0.9985520656727839,
+            "p05_cosine": 0.9927879363822772,
+            "relative_l2_mean": 0.03130694531921343,
+            "relative_l2_p95": 0.12030419446706714,
+            "relative_l2_max": 0.14199628030247896,
+            "weighted_relative_l2_mean": 0.017763284845687673,
+            "weighted_relative_frobenius": 0.009517378602255747,
+            "weighted_mean_cosine": 0.99922030683484,
+            "max_relative_norm_change": 0.010085036488932409
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900007999373839,
+            "mean_cosine": 0.9985520656727839,
+            "p05_cosine": 0.9927879363822772,
+            "relative_l2_mean": 0.03130694531921343,
+            "relative_l2_p95": 0.12030419446706714,
+            "relative_l2_max": 0.14199628030247896,
+            "weighted_relative_l2_mean": 0.017763284845687673,
+            "weighted_relative_frobenius": 0.009517378602255747,
+            "weighted_mean_cosine": 0.99922030683484,
+            "max_relative_norm_change": 0.010085036488932409
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.42459,
+            "warm_p50_ms": 0.0710285,
+            "warm_p95_ms": 0.07528979999999999,
+            "warm_p99_ms": 0.09046238999999999,
+            "samples_ms": [
+              0.076616,
+              0.07522,
+              0.074242,
+              0.073334,
+              0.069143,
+              0.07047,
+              0.072426,
+              0.071028,
+              0.071867,
+              0.070959,
+              0.071378,
+              0.07047,
+              0.07005,
+              0.069632,
+              0.071936,
+              0.071518,
+              0.07054,
+              0.070889,
+              0.07047,
+              0.070958,
+              0.07047,
+              0.073822,
+              0.072844,
+              0.071866,
+              0.07047,
+              0.07054,
+              0.070121,
+              0.069561,
+              0.069911,
+              0.069981,
+              0.099315,
+              0.071378,
+              0.069492,
+              0.071029,
+              0.072425,
+              0.071867,
+              0.071518,
+              0.071937,
+              0.073333,
+              0.070051
+            ],
+            "warm_rows_per_second": 7208374.10335288
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3867621,
+              "unique_rows": 7825,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 490,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 489,
+              "zlib_blocks": 381,
+              "xor_blocks": 108,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7825
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "600628340ac03ca044a2356eeb0939c2e1e2e8e18a03812c73b9ee26160903ac",
+            "table_sha256": "de8f481b515cd6aa80d1cf98f94d892281aa416f689c956e4b4bc6effd266071",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3573845538776368,
+          "representatives_sha256": "271a9a65c6aaaa61087b3113578bbd5b1bad294312ebcea64e5ebf5639335631",
+          "structurally_merged_rows": 5599,
+          "backend_artifact_bytes": 3868828,
+          "backend_with_key_registry_bytes": 4072776,
+          "backend_with_datrie_key_index_bytes": 3977420,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.980013420759822,
+            "mean_cosine": 0.9980376825820849,
+            "p05_cosine": 0.9905574866144373,
+            "relative_l2_mean": 0.03740989477480981,
+            "relative_l2_p95": 0.1374463580229017,
+            "relative_l2_max": 0.2005315757131508,
+            "weighted_relative_l2_mean": 0.020754561070420903,
+            "weighted_relative_frobenius": 0.009974038075667295,
+            "weighted_mean_cosine": 0.9989679669083437,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.980013420759822,
+            "mean_cosine": 0.9980376825820849,
+            "p05_cosine": 0.9905574866144373,
+            "relative_l2_mean": 0.03740989477480981,
+            "relative_l2_p95": 0.1374463580229017,
+            "relative_l2_max": 0.2005315757131508,
+            "weighted_relative_l2_mean": 0.020754561070420903,
+            "weighted_relative_frobenius": 0.009974038075667295,
+            "weighted_mean_cosine": 0.9989679669083437,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.673505,
+            "warm_p50_ms": 0.07190150000000001,
+            "warm_p95_ms": 0.079081,
+            "warm_p99_ms": 0.09818259999999998,
+            "samples_ms": [
+              0.077105,
+              0.073752,
+              0.07906,
+              0.076267,
+              0.073823,
+              0.073823,
+              0.071448,
+              0.071447,
+              0.071867,
+              0.073823,
+              0.074311,
+              0.073822,
+              0.073333,
+              0.071448,
+              0.070959,
+              0.071936,
+              0.069981,
+              0.070051,
+              0.070959,
+              0.070959,
+              0.07047,
+              0.071378,
+              0.069981,
+              0.071029,
+              0.071028,
+              0.073334,
+              0.073822,
+              0.072356,
+              0.11014,
+              0.07948,
+              0.071937,
+              0.070469,
+              0.070121,
+              0.072495,
+              0.072844,
+              0.071937,
+              0.071448,
+              0.071029,
+              0.069562,
+              0.07047
+            ],
+            "warm_rows_per_second": 7120852.833390123
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3831029,
+              "unique_rows": 7749,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 485,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 485,
+              "zlib_blocks": 390,
+              "xor_blocks": 95,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7749
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "c105950686a590d7be61e232a22b493cf8e565d079b82606451c2b81261a94e4",
+            "table_sha256": "2caa89e573b6c7149199b782790adfbdf00a028785c9e0f0c809f10e7db1ec57",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.35861606686376035,
+          "representatives_sha256": "91ff7c6d1164808f5722c3a96b485407dddc8d89a3b412521267c4a84fe61875",
+          "structurally_merged_rows": 5675,
+          "backend_artifact_bytes": 3832235,
+          "backend_with_key_registry_bytes": 4036183,
+          "backend_with_datrie_key_index_bytes": 3940827,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9700304236899572,
+            "mean_cosine": 0.9978949631529862,
+            "p05_cosine": 0.990118823150752,
+            "relative_l2_mean": 0.038680935063680276,
+            "relative_l2_p95": 0.1406791364692246,
+            "relative_l2_max": 0.24400340561278033,
+            "weighted_relative_l2_mean": 0.02137579350598353,
+            "weighted_relative_frobenius": 0.010029759713921182,
+            "weighted_mean_cosine": 0.9988982596965421,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9700304236899572,
+            "mean_cosine": 0.9978949631529862,
+            "p05_cosine": 0.990118823150752,
+            "relative_l2_mean": 0.038680935063680276,
+            "relative_l2_p95": 0.1406791364692246,
+            "relative_l2_max": 0.24400340561278033,
+            "weighted_relative_l2_mean": 0.02137579350598353,
+            "weighted_relative_frobenius": 0.010029759713921182,
+            "weighted_mean_cosine": 0.9988982596965421,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.488564,
+            "warm_p50_ms": 0.07047,
+            "warm_p95_ms": 0.07344925,
+            "warm_p99_ms": 0.08952686999999998,
+            "samples_ms": [
+              0.075639,
+              0.072845,
+              0.071867,
+              0.072914,
+              0.071378,
+              0.072915,
+              0.073334,
+              0.072356,
+              0.072356,
+              0.072425,
+              0.071867,
+              0.070959,
+              0.098406,
+              0.07047,
+              0.07047,
+              0.068584,
+              0.069631,
+              0.070051,
+              0.069493,
+              0.068654,
+              0.069073,
+              0.068514,
+              0.070539,
+              0.070051,
+              0.069981,
+              0.068584,
+              0.068654,
+              0.067606,
+              0.070051,
+              0.068654,
+              0.068584,
+              0.073333,
+              0.071867,
+              0.070959,
+              0.07054,
+              0.07054,
+              0.070051,
+              0.069981,
+              0.069492,
+              0.069631
+            ],
+            "warm_rows_per_second": 7265503.050943663
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3826245,
+              "unique_rows": 7739,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 484,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 484,
+              "zlib_blocks": 380,
+              "xor_blocks": 104,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7739
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "b797fb274cf6bb97c40b3d056b8f4d9ffb1c804a020fa1bea81a8646f81fef31",
+            "table_sha256": "019ffd8ea9f10628cf8512c123802dd2e7c6719a4633964c982b5a9993c51fd5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3633699589408934,
+          "representatives_sha256": "8de86cd8bad44752d2a480c6a19c4591783910fde579a1fc75a12ab6053a1d99",
+          "structurally_merged_rows": 5685,
+          "backend_artifact_bytes": 3827452,
+          "backend_with_key_registry_bytes": 4031400,
+          "backend_with_datrie_key_index_bytes": 3936044,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9554024545296951,
+            "mean_cosine": 0.9978414687987155,
+            "p05_cosine": 0.9900514261641457,
+            "relative_l2_mean": 0.039044707758597454,
+            "relative_l2_p95": 0.14131631695138144,
+            "relative_l2_max": 0.2996513239956172,
+            "weighted_relative_l2_mean": 0.021809966406148944,
+            "weighted_relative_frobenius": 0.011785431782800239,
+            "weighted_mean_cosine": 0.9988329443899867,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9554024545296951,
+            "mean_cosine": 0.9978414687987155,
+            "p05_cosine": 0.9900514261641457,
+            "relative_l2_mean": 0.039044707758597454,
+            "relative_l2_p95": 0.14131631695138144,
+            "relative_l2_max": 0.2996513239956172,
+            "weighted_relative_l2_mean": 0.021809966406148944,
+            "weighted_relative_frobenius": 0.011785431782800239,
+            "weighted_mean_cosine": 0.9988329443899867,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.746838,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.077105,
+            "warm_p99_ms": 0.07829816,
+            "samples_ms": [
+              0.079061,
+              0.077105,
+              0.077105,
+              0.07473,
+              0.074241,
+              0.073822,
+              0.073892,
+              0.072425,
+              0.069981,
+              0.07012,
+              0.069981,
+              0.07047,
+              0.069562,
+              0.070051,
+              0.069982,
+              0.069911,
+              0.07047,
+              0.069562,
+              0.07054,
+              0.069981,
+              0.069981,
+              0.069562,
+              0.070051,
+              0.070051,
+              0.069911,
+              0.070051,
+              0.069632,
+              0.070051,
+              0.069492,
+              0.0704,
+              0.069493,
+              0.070121,
+              0.069981,
+              0.069492,
+              0.070051,
+              0.07005,
+              0.069981,
+              0.069492,
+              0.07047,
+              0.070121
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 6873088,
+              "artifact_bytes": 3818870,
+              "unique_rows": 7724,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 483,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 483,
+              "zlib_blocks": 375,
+              "xor_blocks": 108,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7724
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "e77e143a51f97e5caed5f01557dcf297c0531b10cde88113dd8211d7f26a9943",
+            "table_sha256": "a2f43e4ff393c1da070ca13dabe4e22ee3ca4ac1b52af5014e2c20b5c28f1ddf",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.39088514586910605,
+          "representatives_sha256": "4d3e104b8903632adcc1ede238ca5305d344b0dfbebf0ee95a8e0b4b9c962cb4",
+          "structurally_merged_rows": 5700,
+          "backend_artifact_bytes": 3820077,
+          "backend_with_key_registry_bytes": 4024025,
+          "backend_with_datrie_key_index_bytes": 3928669,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9044079024947834,
+            "mean_cosine": 0.997713361814159,
+            "p05_cosine": 0.9898971286352017,
+            "relative_l2_mean": 0.03969745170571765,
+            "relative_l2_p95": 0.14202274798903222,
+            "relative_l2_max": 0.4376969589349435,
+            "weighted_relative_l2_mean": 0.022414481830018047,
+            "weighted_relative_frobenius": 0.014658876756557073,
+            "weighted_mean_cosine": 0.9987163314265392,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9044079024947834,
+            "mean_cosine": 0.997713361814159,
+            "p05_cosine": 0.9898971286352017,
+            "relative_l2_mean": 0.03969745170571765,
+            "relative_l2_p95": 0.14202274798903222,
+            "relative_l2_max": 0.4376969589349435,
+            "weighted_relative_l2_mean": 0.022414481830018047,
+            "weighted_relative_frobenius": 0.014658876756557073,
+            "weighted_mean_cosine": 0.9987163314265392,
+            "max_relative_norm_change": 0.010095772471192354
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.396304,
+            "warm_p50_ms": 0.0707845,
+            "warm_p95_ms": 0.0743564,
+            "warm_p99_ms": 0.07747722,
+            "samples_ms": [
+              0.078921,
+              0.075219,
+              0.073752,
+              0.072355,
+              0.071029,
+              0.072915,
+              0.071867,
+              0.071448,
+              0.071937,
+              0.069981,
+              0.072425,
+              0.071029,
+              0.069562,
+              0.071448,
+              0.071797,
+              0.071378,
+              0.069562,
+              0.069073,
+              0.069562,
+              0.069562,
+              0.069562,
+              0.069143,
+              0.07054,
+              0.069493,
+              0.069562,
+              0.069073,
+              0.069492,
+              0.069073,
+              0.069073,
+              0.069562,
+              0.069981,
+              0.074311,
+              0.074311,
+              0.072006,
+              0.071518,
+              0.071937,
+              0.071517,
+              0.069981,
+              0.07047,
+              0.069632
+            ],
+            "warm_rows_per_second": 7233221.962435279
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3436544,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "745262c69f54fbc70dbe6d692411472e46846937961b94d94883afac06df3fa3",
+            "table_sha256": "7181664941ce04822304ee6afc0b67f281d64784883f2bd11a965520e8851501",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.043027720879763365,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3437350,
+          "backend_with_key_registry_bytes": 3641298,
+          "backend_with_datrie_key_index_bytes": 3545942,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999612548297,
+            "mean_cosine": 0.9999999790165792,
+            "p05_cosine": 0.9999999730537448,
+            "relative_l2_mean": 0.00020669401864291777,
+            "relative_l2_p95": 0.00023473970210358965,
+            "relative_l2_max": 0.00027860911915048036,
+            "weighted_relative_l2_mean": 0.00020586591458364586,
+            "weighted_relative_frobenius": 0.00020520736570042996,
+            "weighted_mean_cosine": 0.9999999791988329,
+            "max_relative_norm_change": 0.0001331667263129161
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.481696,
+            "warm_p50_ms": 0.220559,
+            "warm_p95_ms": 0.22721464999999993,
+            "warm_p99_ms": 0.26642889,
+            "samples_ms": [
+              0.221886,
+              0.221048,
+              0.220489,
+              0.220978,
+              0.221398,
+              0.220978,
+              0.220908,
+              0.221397,
+              0.25548,
+              0.223771,
+              0.220489,
+              0.220489,
+              0.220559,
+              0.220978,
+              0.219581,
+              0.220559,
+              0.220978,
+              0.219162,
+              0.219581,
+              0.219092,
+              0.220559,
+              0.22,
+              0.22049,
+              0.220978,
+              0.219511,
+              0.220978,
+              0.273429,
+              0.225727,
+              0.221956,
+              0.220908,
+              0.220489,
+              0.220489,
+              0.219022,
+              0.221397,
+              0.219023,
+              0.219512,
+              0.219581,
+              0.22007,
+              0.219092,
+              0.219022
+            ],
+            "warm_rows_per_second": 2321374.3261440247
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3249576,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "745262c69f54fbc70dbe6d692411472e46846937961b94d94883afac06df3fa3",
+            "table_sha256": "a8c6941fc7172d12eb0e5479d247f94e791b50cd69d34b5ed0f9432d026bd57d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.32230694498866796,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3250785,
+          "backend_with_key_registry_bytes": 3454733,
+          "backend_with_datrie_key_index_bytes": 3359377,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999612548297,
+            "mean_cosine": 0.9999999790165792,
+            "p05_cosine": 0.9999999730537448,
+            "relative_l2_mean": 0.00020669401864291777,
+            "relative_l2_p95": 0.00023473970210358965,
+            "relative_l2_max": 0.00027860911915048036,
+            "weighted_relative_l2_mean": 0.00020586591458364586,
+            "weighted_relative_frobenius": 0.00020520736570042996,
+            "weighted_mean_cosine": 0.9999999791988329,
+            "max_relative_norm_change": 0.0001331667263129161
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.125798,
+            "warm_p50_ms": 0.229499,
+            "warm_p95_ms": 0.28088375,
+            "warm_p99_ms": 0.29063838000000003,
+            "samples_ms": [
+              0.292845,
+              0.230337,
+              0.230896,
+              0.232292,
+              0.231384,
+              0.22901,
+              0.22901,
+              0.229428,
+              0.229988,
+              0.230895,
+              0.229428,
+              0.230336,
+              0.229988,
+              0.22908,
+              0.229429,
+              0.229499,
+              0.280552,
+              0.232292,
+              0.22901,
+              0.229918,
+              0.229917,
+              0.22901,
+              0.230476,
+              0.229917,
+              0.229499,
+              0.22901,
+              0.22901,
+              0.228591,
+              0.228102,
+              0.229499,
+              0.229499,
+              0.22901,
+              0.229428,
+              0.24235,
+              0.230407,
+              0.22894,
+              0.22901,
+              0.22852,
+              0.228521,
+              0.287187
+            ],
+            "warm_rows_per_second": 2230946.54007207
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3249576,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "745262c69f54fbc70dbe6d692411472e46846937961b94d94883afac06df3fa3",
+            "table_sha256": "a8c6941fc7172d12eb0e5479d247f94e791b50cd69d34b5ed0f9432d026bd57d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3722030739299953,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3250784,
+          "backend_with_key_registry_bytes": 3454732,
+          "backend_with_datrie_key_index_bytes": 3359376,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999612548297,
+            "mean_cosine": 0.9999999790165792,
+            "p05_cosine": 0.9999999730537448,
+            "relative_l2_mean": 0.00020669401864291777,
+            "relative_l2_p95": 0.00023473970210358965,
+            "relative_l2_max": 0.00027860911915048036,
+            "weighted_relative_l2_mean": 0.00020586591458364586,
+            "weighted_relative_frobenius": 0.00020520736570042996,
+            "weighted_mean_cosine": 0.9999999791988329,
+            "max_relative_norm_change": 0.0001331667263129161
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.138648,
+            "warm_p50_ms": 0.230406,
+            "warm_p95_ms": 0.28818695,
+            "warm_p99_ms": 0.28952196,
+            "samples_ms": [
+              0.231315,
+              0.231803,
+              0.229429,
+              0.230896,
+              0.254991,
+              0.234667,
+              0.229918,
+              0.230476,
+              0.230826,
+              0.230407,
+              0.290121,
+              0.288166,
+              0.288585,
+              0.288166,
+              0.229918,
+              0.229009,
+              0.228591,
+              0.231314,
+              0.22901,
+              0.230896,
+              0.241721,
+              0.230406,
+              0.230476,
+              0.22894,
+              0.229498,
+              0.230407,
+              0.229918,
+              0.229917,
+              0.228521,
+              0.228521,
+              0.229918,
+              0.229359,
+              0.230406,
+              0.229498,
+              0.229499,
+              0.229428,
+              0.229429,
+              0.230407,
+              0.241721,
+              0.229988
+            ],
+            "warm_rows_per_second": 2222164.3533588536
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 3249576,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 420,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 420,
+              "zlib_blocks": 0,
+              "xor_blocks": 420,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "745262c69f54fbc70dbe6d692411472e46846937961b94d94883afac06df3fa3",
+            "table_sha256": "a8c6941fc7172d12eb0e5479d247f94e791b50cd69d34b5ed0f9432d026bd57d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3346426740754396,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3250784,
+          "backend_with_key_registry_bytes": 3454732,
+          "backend_with_datrie_key_index_bytes": 3359376,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999612548297,
+            "mean_cosine": 0.9999999790165792,
+            "p05_cosine": 0.9999999730537448,
+            "relative_l2_mean": 0.00020669401864291777,
+            "relative_l2_p95": 0.00023473970210358965,
+            "relative_l2_max": 0.00027860911915048036,
+            "weighted_relative_l2_mean": 0.00020586591458364586,
+            "weighted_relative_frobenius": 0.00020520736570042996,
+            "weighted_mean_cosine": 0.9999999791988329,
+            "max_relative_norm_change": 0.0001331667263129161
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.183556,
+            "warm_p50_ms": 0.229499,
+            "warm_p95_ms": 0.2674156499999999,
+            "warm_p99_ms": 0.28808287,
+            "samples_ms": [
+              0.231315,
+              0.229429,
+              0.25548,
+              0.232711,
+              0.230337,
+              0.229917,
+              0.229429,
+              0.22901,
+              0.22901,
+              0.230896,
+              0.229918,
+              0.229917,
+              0.229359,
+              0.229848,
+              0.22901,
+              0.22908,
+              0.229079,
+              0.229988,
+              0.22859,
+              0.242699,
+              0.288655,
+              0.287188,
+              0.229429,
+              0.229429,
+              0.229499,
+              0.266375,
+              0.236134,
+              0.230825,
+              0.229429,
+              0.228102,
+              0.228032,
+              0.229498,
+              0.22894,
+              0.227613,
+              0.229918,
+              0.228521,
+              0.239905,
+              0.229498,
+              0.229499,
+              0.229499
+            ],
+            "warm_rows_per_second": 2230946.54007207
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 2105028,
+              "unique_rows": 8311,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 260,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 260,
+              "zlib_blocks": 119,
+              "xor_blocks": 141,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8311
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "faca6fff0c110b03e63edd9d50b71c9d1c0c7d2b0742217c219c983386c75403",
+            "table_sha256": "b6745745bf9452dcedf4cc9a07775cec18e50b9734f765b69278759ec885d9aa",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2781077749095857,
+          "representatives_sha256": "0b04f4fca40a83c1d082ca4b51cd2ff6ce3a581e6c4a9cbcca8e95362052745e",
+          "structurally_merged_rows": 5113,
+          "backend_artifact_bytes": 2106235,
+          "backend_with_key_registry_bytes": 2310183,
+          "backend_with_datrie_key_index_bytes": 2214827,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9900077149362516,
+            "mean_cosine": 0.9985521257011059,
+            "p05_cosine": 0.9927844616386878,
+            "relative_l2_mean": 0.031438301030621084,
+            "relative_l2_p95": 0.12031554395198002,
+            "relative_l2_max": 0.14199922735932338,
+            "weighted_relative_l2_mean": 0.01792222597194396,
+            "weighted_relative_frobenius": 0.009520497179207372,
+            "weighted_mean_cosine": 0.9992203252964822,
+            "max_relative_norm_change": 0.010125723311944002
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.990009379823296,
+            "mean_cosine": 0.9985521112039947,
+            "p05_cosine": 0.9927839291169913,
+            "relative_l2_mean": 0.03131066276960376,
+            "relative_l2_p95": 0.12030417355944241,
+            "relative_l2_max": 0.14197100159414283,
+            "weighted_relative_l2_mean": 0.017765175325278264,
+            "weighted_relative_frobenius": 0.009518618838387841,
+            "weighted_mean_cosine": 0.9992203250344446,
+            "max_relative_norm_change": 0.01008796306532617
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.850156,
+            "warm_p50_ms": 0.22859049999999997,
+            "warm_p95_ms": 0.23193654999999996,
+            "warm_p99_ms": 0.24919940000000002,
+            "samples_ms": [
+              0.231315,
+              0.229988,
+              0.229079,
+              0.228591,
+              0.229079,
+              0.228102,
+              0.22859,
+              0.228591,
+              0.228591,
+              0.229499,
+              0.228101,
+              0.228102,
+              0.228591,
+              0.252686,
+              0.230825,
+              0.22901,
+              0.227543,
+              0.229918,
+              0.227543,
+              0.230407,
+              0.229429,
+              0.229009,
+              0.228521,
+              0.228521,
+              0.227543,
+              0.227962,
+              0.227055,
+              0.228521,
+              0.228032,
+              0.227543,
+              0.243746,
+              0.230407,
+              0.227124,
+              0.227543,
+              0.22852,
+              0.229429,
+              0.229429,
+              0.226635,
+              0.227613,
+              0.228102
+            ],
+            "warm_rows_per_second": 2239813.115593168
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1990400,
+              "unique_rows": 7824,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 245,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 245,
+              "zlib_blocks": 149,
+              "xor_blocks": 96,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7824
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "5df2d348bb831b82bc6213c26b6396afefa01092432d062ce8f75b2d020e60a3",
+            "table_sha256": "87fb565c05c180538a76ae6409591c2958ff83e7ff6d842c533c5585d7498b20",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21020766301080585,
+          "representatives_sha256": "4a440ed6fd489e7e7935c570841a7840ed7290964d5fcf2f4465e22a1e48c597",
+          "structurally_merged_rows": 5600,
+          "backend_artifact_bytes": 1991606,
+          "backend_with_key_registry_bytes": 2195554,
+          "backend_with_datrie_key_index_bytes": 2100198,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800137839059521,
+            "mean_cosine": 0.9980377116486364,
+            "p05_cosine": 0.9905560009410573,
+            "relative_l2_mean": 0.03753393260000457,
+            "relative_l2_p95": 0.13745740963301878,
+            "relative_l2_max": 0.20008525457545137,
+            "weighted_relative_l2_mean": 0.020909921191685353,
+            "weighted_relative_frobenius": 0.009976854081682007,
+            "weighted_mean_cosine": 0.998967970622337,
+            "max_relative_norm_change": 0.010125723311944002
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800163940067987,
+            "mean_cosine": 0.998037706994905,
+            "p05_cosine": 0.990556319900482,
+            "relative_l2_mean": 0.037413786078987626,
+            "relative_l2_p95": 0.13743524070760002,
+            "relative_l2_max": 0.2000961318971666,
+            "weighted_relative_l2_mean": 0.020756536232808258,
+            "weighted_relative_frobenius": 0.009975070344183962,
+            "weighted_mean_cosine": 0.998967974737777,
+            "max_relative_norm_change": 0.01008796306532617
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.306931,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.28265199999999996,
+            "warm_p99_ms": 0.28695459,
+            "samples_ms": [
+              0.232781,
+              0.265886,
+              0.232293,
+              0.229918,
+              0.22894,
+              0.229429,
+              0.229917,
+              0.228521,
+              0.22901,
+              0.22901,
+              0.22901,
+              0.228521,
+              0.226636,
+              0.228381,
+              0.228032,
+              0.228451,
+              0.228451,
+              0.22894,
+              0.241791,
+              0.231385,
+              0.228521,
+              0.228032,
+              0.22894,
+              0.233619,
+              0.22901,
+              0.22901,
+              0.229987,
+              0.286699,
+              0.287118,
+              0.233201,
+              0.227613,
+              0.227613,
+              0.227194,
+              0.228032,
+              0.228102,
+              0.229918,
+              0.242279,
+              0.282439,
+              0.240813,
+              0.230896
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1972568,
+              "unique_rows": 7748,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 243,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 243,
+              "zlib_blocks": 155,
+              "xor_blocks": 88,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7748
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "18dd991f3b1c8f2173d81198257f2501d390838c64e6578da9e5909796f1e886",
+            "table_sha256": "7c27ff22a9f60768c990701a6ae4aebbd3b3f61b3bc153ce9ca4ab12865aec7b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23467504396103323,
+          "representatives_sha256": "6028a6047a0ea9de9c4b2b7403abbc402a30d37ff4299deace29d310622f18a2",
+          "structurally_merged_rows": 5676,
+          "backend_artifact_bytes": 1973774,
+          "backend_with_key_registry_bytes": 2177722,
+          "backend_with_datrie_key_index_bytes": 2082366,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9700314079851591,
+            "mean_cosine": 0.9978949938076623,
+            "p05_cosine": 0.9901183891582513,
+            "relative_l2_mean": 0.038803787130537434,
+            "relative_l2_p95": 0.14068049744242087,
+            "relative_l2_max": 0.2439915857988374,
+            "weighted_relative_l2_mean": 0.02153057473686633,
+            "weighted_relative_frobenius": 0.010032559648566038,
+            "weighted_mean_cosine": 0.9988982640629619,
+            "max_relative_norm_change": 0.010125723311944002
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9700309212986293,
+            "mean_cosine": 0.9978949885233197,
+            "p05_cosine": 0.990119777173615,
+            "relative_l2_mean": 0.038684829313671856,
+            "relative_l2_p95": 0.1406630418933251,
+            "relative_l2_max": 0.24399958599152996,
+            "weighted_relative_l2_mean": 0.021377770680033402,
+            "weighted_relative_frobenius": 0.010030786695295522,
+            "weighted_mean_cosine": 0.9988982678307401,
+            "max_relative_norm_change": 0.01008796306532617
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.688823,
+            "warm_p50_ms": 0.2289745,
+            "warm_p95_ms": 0.2428109,
+            "warm_p99_ms": 0.25174378999999997,
+            "samples_ms": [
+              0.230896,
+              0.229499,
+              0.22901,
+              0.243607,
+              0.229498,
+              0.22894,
+              0.227543,
+              0.228032,
+              0.227543,
+              0.228451,
+              0.228032,
+              0.22894,
+              0.228521,
+              0.227963,
+              0.226635,
+              0.236134,
+              0.24221,
+              0.230407,
+              0.229009,
+              0.227194,
+              0.240813,
+              0.229499,
+              0.227962,
+              0.228521,
+              0.227962,
+              0.226705,
+              0.22859,
+              0.229429,
+              0.228521,
+              0.233829,
+              0.230895,
+              0.231873,
+              0.242769,
+              0.229988,
+              0.22901,
+              0.228521,
+              0.227544,
+              0.256946,
+              0.231315,
+              0.228521
+            ],
+            "warm_rows_per_second": 2236056.8534924197
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1969970,
+              "unique_rows": 7738,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 151,
+              "xor_blocks": 91,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7738
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "206eb3c30678730cd57a9b65ae4f9c502f6deb02acc5e5ad5cabc6613dadcb55",
+            "table_sha256": "4ed3d64b6c20f54fa506a70a344028c235d62354f6854b3658ba556c8eb15344",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21138525917194784,
+          "representatives_sha256": "a277c4ddcc764481205e42ec0dc39d62704a14287db2966b15c819a1145c7898",
+          "structurally_merged_rows": 5686,
+          "backend_artifact_bytes": 1971176,
+          "backend_with_key_registry_bytes": 2175124,
+          "backend_with_datrie_key_index_bytes": 2079768,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9554112304718978,
+            "mean_cosine": 0.997841501751493,
+            "p05_cosine": 0.9900522530297954,
+            "relative_l2_mean": 0.039167393131070684,
+            "relative_l2_p95": 0.14129570340293618,
+            "relative_l2_max": 0.29962859056383023,
+            "weighted_relative_l2_mean": 0.021964581487790142,
+            "weighted_relative_frobenius": 0.011787515632833112,
+            "weighted_mean_cosine": 0.998832956953083,
+            "max_relative_norm_change": 0.010125723311944002
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9554183376699096,
+            "mean_cosine": 0.9978414956615338,
+            "p05_cosine": 0.9900537656880667,
+            "relative_l2_mean": 0.03904859538817834,
+            "relative_l2_p95": 0.14128987318352873,
+            "relative_l2_max": 0.2996102536492556,
+            "weighted_relative_l2_mean": 0.02181190485627813,
+            "weighted_relative_frobenius": 0.011786082613841144,
+            "weighted_mean_cosine": 0.9988329595639267,
+            "max_relative_norm_change": 0.01008796306532617
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.690639,
+            "warm_p50_ms": 0.22928900000000002,
+            "warm_p95_ms": 0.28870035,
+            "warm_p99_ms": 0.30425995,
+            "samples_ms": [
+              0.231803,
+              0.235575,
+              0.23327,
+              0.231873,
+              0.229917,
+              0.289562,
+              0.287188,
+              0.288655,
+              0.287188,
+              0.287606,
+              0.313657,
+              0.232292,
+              0.22901,
+              0.230407,
+              0.230406,
+              0.229987,
+              0.229499,
+              0.229498,
+              0.228591,
+              0.227613,
+              0.227194,
+              0.229079,
+              0.22908,
+              0.287187,
+              0.227613,
+              0.227613,
+              0.228521,
+              0.241232,
+              0.228032,
+              0.227613,
+              0.227124,
+              0.229009,
+              0.228591,
+              0.22859,
+              0.287188,
+              0.228521,
+              0.226635,
+              0.227054,
+              0.228939,
+              0.22894
+            ],
+            "warm_rows_per_second": 2232989.807622694
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3436544,
+              "artifact_bytes": 1966232,
+              "unique_rows": 7723,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 242,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 242,
+              "zlib_blocks": 150,
+              "xor_blocks": 92,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7723
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "5a274c0aa20e3c70495c29c4432d3ad33f4fbfa7a7cf7a415418ffb07642bc37",
+            "table_sha256": "923968a09633745982eb0a1e9950eb882e896a9cc32404ebe57aaae23db8421b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2159291368443519,
+          "representatives_sha256": "57b2b6c1ab7ed4773e1775a97b909dbfacb6519463048d213d565efb187c80c9",
+          "structurally_merged_rows": 5701,
+          "backend_artifact_bytes": 1967438,
+          "backend_with_key_registry_bytes": 2171386,
+          "backend_with_datrie_key_index_bytes": 2076030,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.904412617018626,
+            "mean_cosine": 0.9977202774797137,
+            "p05_cosine": 0.9898974661899778,
+            "relative_l2_mean": 0.03979067732544779,
+            "relative_l2_p95": 0.14200537379054382,
+            "relative_l2_max": 0.4376919153864184,
+            "weighted_relative_l2_mean": 0.022554738165779152,
+            "weighted_relative_frobenius": 0.014593319661202971,
+            "weighted_mean_cosine": 0.9987196662683778,
+            "max_relative_norm_change": 0.010125723311944002
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9044076837305283,
+            "mean_cosine": 0.997720269099691,
+            "p05_cosine": 0.9899000698085584,
+            "relative_l2_mean": 0.03967211665200063,
+            "relative_l2_p95": 0.142004485756289,
+            "relative_l2_max": 0.4377167106420038,
+            "weighted_relative_l2_mean": 0.022402312863921987,
+            "weighted_relative_frobenius": 0.014592223061960206,
+            "weighted_mean_cosine": 0.9987196673359467,
+            "max_relative_norm_change": 0.01008796306532617
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.49208,
+            "warm_p50_ms": 0.2285555,
+            "warm_p95_ms": 0.2530909,
+            "warm_p99_ms": 0.26441492,
+            "samples_ms": [
+              0.231385,
+              0.229499,
+              0.229917,
+              0.22901,
+              0.227544,
+              0.228591,
+              0.229009,
+              0.227613,
+              0.227124,
+              0.252616,
+              0.232362,
+              0.228591,
+              0.22859,
+              0.228591,
+              0.227124,
+              0.265886,
+              0.234667,
+              0.22859,
+              0.228591,
+              0.228101,
+              0.227124,
+              0.227613,
+              0.228521,
+              0.227054,
+              0.227962,
+              0.228032,
+              0.241372,
+              0.229498,
+              0.227613,
+              0.227543,
+              0.227544,
+              0.227054,
+              0.227473,
+              0.227055,
+              0.227613,
+              0.226705,
+              0.231314,
+              0.262114,
+              0.231803,
+              0.228521
+            ],
+            "warm_rows_per_second": 2240156.110878977
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1771968,
+              "unique_rows": 13424,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "ed5fe2646195c36093dae73b4e27ecb710aaf4493c4643375246e406ec0f1dfd",
+            "table_sha256": "145179f5873a93b683607b1475e5ff91182ff4d09cf914774cef2ef32c002ed1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03684794786386192,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1772818,
+          "backend_with_key_registry_bytes": 1976766,
+          "backend_with_datrie_key_index_bytes": 1881410,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999429184170107,
+            "mean_cosine": 0.9999772888320042,
+            "p05_cosine": 0.9999629801925154,
+            "relative_l2_mean": 0.006690927009116968,
+            "relative_l2_p95": 0.00863155067483264,
+            "relative_l2_max": 0.010732325702084305,
+            "weighted_relative_l2_mean": 0.006846066546862484,
+            "weighted_relative_frobenius": 0.007427315453576613,
+            "weighted_mean_cosine": 0.9999762114726573,
+            "max_relative_norm_change": 0.002874768094226643
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.394604,
+            "warm_p50_ms": 0.122502,
+            "warm_p95_ms": 0.12723345,
+            "warm_p99_ms": 0.13708587,
+            "samples_ms": [
+              0.124458,
+              0.122642,
+              0.122083,
+              0.12306,
+              0.122991,
+              0.121594,
+              0.124457,
+              0.12306,
+              0.121663,
+              0.122991,
+              0.122083,
+              0.121594,
+              0.122013,
+              0.137658,
+              0.122502,
+              0.122991,
+              0.122501,
+              0.122502,
+              0.122083,
+              0.122083,
+              0.122083,
+              0.122571,
+              0.126762,
+              0.122572,
+              0.121593,
+              0.122083,
+              0.122502,
+              0.122572,
+              0.122152,
+              0.12348,
+              0.121664,
+              0.122502,
+              0.122572,
+              0.136191,
+              0.123969,
+              0.122572,
+              0.120197,
+              0.121594,
+              0.121036,
+              0.122013
+            ],
+            "warm_rows_per_second": 4179523.5996147003
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1644481,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "ed5fe2646195c36093dae73b4e27ecb710aaf4493c4643375246e406ec0f1dfd",
+            "table_sha256": "976970440e84e9144ffbc9b2e88d574df0db406d5d107b5c4899f9635b081a4e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.19422474992461503,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1645734,
+          "backend_with_key_registry_bytes": 1849682,
+          "backend_with_datrie_key_index_bytes": 1754326,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999429184170107,
+            "mean_cosine": 0.9999772888320042,
+            "p05_cosine": 0.9999629801925154,
+            "relative_l2_mean": 0.006690927009116968,
+            "relative_l2_p95": 0.00863155067483264,
+            "relative_l2_max": 0.010732325702084305,
+            "weighted_relative_l2_mean": 0.006846066546862484,
+            "weighted_relative_frobenius": 0.007427315453576613,
+            "weighted_mean_cosine": 0.9999762114726573,
+            "max_relative_norm_change": 0.002874768094226643
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.106742,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13870819999999998,
+            "warm_p99_ms": 0.14407029999999998,
+            "samples_ms": [
+              0.135283,
+              0.135423,
+              0.13242,
+              0.131581,
+              0.138565,
+              0.131511,
+              0.134304,
+              0.132,
+              0.131511,
+              0.132978,
+              0.131581,
+              0.131511,
+              0.131511,
+              0.132,
+              0.132,
+              0.132,
+              0.131511,
+              0.141429,
+              0.138076,
+              0.132489,
+              0.131092,
+              0.132978,
+              0.130534,
+              0.132,
+              0.131092,
+              0.145759,
+              0.131512,
+              0.132001,
+              0.130534,
+              0.133397,
+              0.135841,
+              0.133886,
+              0.133467,
+              0.132,
+              0.131511,
+              0.131023,
+              0.134794,
+              0.133467,
+              0.132001,
+              0.131092
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1644481,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "ed5fe2646195c36093dae73b4e27ecb710aaf4493c4643375246e406ec0f1dfd",
+            "table_sha256": "976970440e84e9144ffbc9b2e88d574df0db406d5d107b5c4899f9635b081a4e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24700916791334748,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1645733,
+          "backend_with_key_registry_bytes": 1849681,
+          "backend_with_datrie_key_index_bytes": 1754325,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999429184170107,
+            "mean_cosine": 0.9999772888320042,
+            "p05_cosine": 0.9999629801925154,
+            "relative_l2_mean": 0.006690927009116968,
+            "relative_l2_p95": 0.00863155067483264,
+            "relative_l2_max": 0.010732325702084305,
+            "weighted_relative_l2_mean": 0.006846066546862484,
+            "weighted_relative_frobenius": 0.007427315453576613,
+            "weighted_mean_cosine": 0.9999762114726573,
+            "max_relative_norm_change": 0.002874768094226643
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.020209,
+            "warm_p50_ms": 0.1315465,
+            "warm_p95_ms": 0.13810509999999998,
+            "warm_p99_ms": 0.15621889,
+            "samples_ms": [
+              0.135283,
+              0.133397,
+              0.137727,
+              0.132978,
+              0.132977,
+              0.132978,
+              0.133467,
+              0.130604,
+              0.163219,
+              0.134864,
+              0.133397,
+              0.131022,
+              0.131022,
+              0.131022,
+              0.130603,
+              0.131511,
+              0.132489,
+              0.131023,
+              0.131511,
+              0.132489,
+              0.132,
+              0.131022,
+              0.131511,
+              0.131023,
+              0.137728,
+              0.131093,
+              0.131512,
+              0.132489,
+              0.131511,
+              0.132978,
+              0.132,
+              0.131511,
+              0.131581,
+              0.130534,
+              0.131511,
+              0.131022,
+              0.130603,
+              0.14527,
+              0.133397,
+              0.131511
+            ],
+            "warm_rows_per_second": 3892159.8066083095
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1644481,
+              "unique_rows": 13424,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 217,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 217,
+              "zlib_blocks": 0,
+              "xor_blocks": 217,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 13424
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "ed5fe2646195c36093dae73b4e27ecb710aaf4493c4643375246e406ec0f1dfd",
+            "table_sha256": "976970440e84e9144ffbc9b2e88d574df0db406d5d107b5c4899f9635b081a4e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1931517068296671,
+          "representatives_sha256": "35888549e73e40bba1ad2e09fd530343fb49575b458c9b6a5a8768f1715dc97d",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1645733,
+          "backend_with_key_registry_bytes": 1849681,
+          "backend_with_datrie_key_index_bytes": 1754325,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999429184170107,
+            "mean_cosine": 0.9999772888320042,
+            "p05_cosine": 0.9999629801925154,
+            "relative_l2_mean": 0.006690927009116968,
+            "relative_l2_p95": 0.00863155067483264,
+            "relative_l2_max": 0.010732325702084305,
+            "weighted_relative_l2_mean": 0.006846066546862484,
+            "weighted_relative_frobenius": 0.007427315453576613,
+            "weighted_mean_cosine": 0.9999762114726573,
+            "max_relative_norm_change": 0.002874768094226643
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.021187,
+            "warm_p50_ms": 0.132489,
+            "warm_p95_ms": 0.13897454999999995,
+            "warm_p99_ms": 0.16134456,
+            "samples_ms": [
+              0.154698,
+              0.138146,
+              0.138147,
+              0.134375,
+              0.134933,
+              0.132908,
+              0.135771,
+              0.134864,
+              0.132489,
+              0.132978,
+              0.132,
+              0.132,
+              0.132,
+              0.133467,
+              0.132,
+              0.132,
+              0.132489,
+              0.131512,
+              0.131511,
+              0.132489,
+              0.131511,
+              0.132489,
+              0.132,
+              0.131511,
+              0.13633,
+              0.134305,
+              0.132489,
+              0.131511,
+              0.132489,
+              0.165594,
+              0.137728,
+              0.132489,
+              0.131022,
+              0.133466,
+              0.132489,
+              0.131092,
+              0.132909,
+              0.132489,
+              0.132419,
+              0.131582
+            ],
+            "warm_rows_per_second": 3864471.7674674885
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1125117,
+              "unique_rows": 8330,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 135,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 135,
+              "zlib_blocks": 2,
+              "xor_blocks": 133,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8330
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "293b129e64a0605a67cbee86bf34bb8c806922eec637179b615339f130b75f4c",
+            "table_sha256": "7e051a24117fe0bcb7af7955f511dd060d4492a461d42a2dbd060d0f0b8cddbe",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1461592318955809,
+          "representatives_sha256": "ef38bd0185746b6eb3c08beb73f5bf4a7f67137414b83e830db9c591f11444b1",
+          "structurally_merged_rows": 5094,
+          "backend_artifact_bytes": 1126366,
+          "backend_with_key_registry_bytes": 1330314,
+          "backend_with_datrie_key_index_bytes": 1234958,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.989883376131355,
+            "mean_cosine": 0.9985366108160204,
+            "p05_cosine": 0.9927796835663705,
+            "relative_l2_mean": 0.03544035891840036,
+            "relative_l2_p95": 0.12031219140066435,
+            "relative_l2_max": 0.14283478277746048,
+            "weighted_relative_l2_mean": 0.02304568387445217,
+            "weighted_relative_frobenius": 0.012055645188533535,
+            "weighted_mean_cosine": 0.9992004261084678,
+            "max_relative_norm_change": 0.0111298361935299
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.990003104072174,
+            "mean_cosine": 0.998541844251837,
+            "p05_cosine": 0.9927626218423953,
+            "relative_l2_mean": 0.03141726644040223,
+            "relative_l2_p95": 0.120413714532134,
+            "relative_l2_max": 0.14209593221613123,
+            "weighted_relative_l2_mean": 0.01785312916105629,
+            "weighted_relative_frobenius": 0.00963143524074153,
+            "weighted_mean_cosine": 0.9992135642014484,
+            "max_relative_norm_change": 0.010090093026292535
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.325799,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.1375416499999999,
+            "warm_p99_ms": 0.22353399999999995,
+            "samples_ms": [
+              0.135841,
+              0.135282,
+              0.132978,
+              0.132,
+              0.132908,
+              0.132,
+              0.169854,
+              0.132489,
+              0.131093,
+              0.132489,
+              0.132489,
+              0.131581,
+              0.130114,
+              0.131511,
+              0.131092,
+              0.131023,
+              0.131093,
+              0.130604,
+              0.131023,
+              0.131023,
+              0.132,
+              0.131511,
+              0.131511,
+              0.130114,
+              0.129206,
+              0.131581,
+              0.130533,
+              0.131023,
+              0.130604,
+              0.129695,
+              0.131092,
+              0.130603,
+              0.132,
+              0.131023,
+              0.132,
+              0.257854,
+              0.135282,
+              0.131022,
+              0.130533,
+              0.131581
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1070533,
+              "unique_rows": 7840,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 127,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 127,
+              "zlib_blocks": 4,
+              "xor_blocks": 123,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7840
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "4cc2cacc4cffc29cd28bfffb6a2063fb80cd75890cf3332cef620e01f9109e23",
+            "table_sha256": "ddada4dbadb5027d32efee0d25463c834ce4d3f5aaa51b44bd467ad2128fa03d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14123639510944486,
+          "representatives_sha256": "a85e9a37532ae7d133b949e4603535ed993b0ecc14edcc8aedca7bc771fe2cc7",
+          "structurally_merged_rows": 5584,
+          "backend_artifact_bytes": 1071782,
+          "backend_with_key_registry_bytes": 1275730,
+          "backend_with_datrie_key_index_bytes": 1180374,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9799888216619596,
+            "mean_cosine": 0.9980203268379337,
+            "p05_cosine": 0.990537724069153,
+            "relative_l2_mean": 0.04134452123811339,
+            "relative_l2_p95": 0.13755965810914922,
+            "relative_l2_max": 0.20010886707252595,
+            "weighted_relative_l2_mean": 0.025939585992463807,
+            "weighted_relative_frobenius": 0.012420949562250233,
+            "weighted_mean_cosine": 0.9989471847191407,
+            "max_relative_norm_change": 0.0111298361935299
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9800645740292964,
+            "mean_cosine": 0.9980241146613112,
+            "p05_cosine": 0.9905119624083044,
+            "relative_l2_mean": 0.03756072155684393,
+            "relative_l2_p95": 0.13782818640777994,
+            "relative_l2_max": 0.19984363334867963,
+            "weighted_relative_l2_mean": 0.02086386226008907,
+            "weighted_relative_frobenius": 0.010086130604784648,
+            "weighted_mean_cosine": 0.9989596191879863,
+            "max_relative_norm_change": 0.010096948723578298
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.875463,
+            "warm_p50_ms": 0.13130199999999997,
+            "warm_p95_ms": 0.1354228,
+            "warm_p99_ms": 0.14160643,
+            "samples_ms": [
+              0.136749,
+              0.133955,
+              0.135353,
+              0.134863,
+              0.132978,
+              0.131023,
+              0.132,
+              0.131511,
+              0.131511,
+              0.132,
+              0.131022,
+              0.131511,
+              0.132,
+              0.129207,
+              0.131092,
+              0.130045,
+              0.144712,
+              0.130533,
+              0.131581,
+              0.131092,
+              0.130603,
+              0.131022,
+              0.131511,
+              0.131023,
+              0.131093,
+              0.129626,
+              0.131023,
+              0.131023,
+              0.131511,
+              0.131092,
+              0.131092,
+              0.131581,
+              0.130603,
+              0.131511,
+              0.131582,
+              0.131023,
+              0.130604,
+              0.129626,
+              0.131581,
+              0.131512
+            ],
+            "warm_rows_per_second": 3899407.472848853
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1061596,
+              "unique_rows": 7764,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 126,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 126,
+              "zlib_blocks": 7,
+              "xor_blocks": 119,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7764
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "85acf75e956064d2922765527a96fd0f836c41a857cd6e98ebb3e438ca2d458e",
+            "table_sha256": "e3edb7720c73fa1f64d600770d4b6d66c9cfad69023e468c5c40378163a8fc5a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13075865502469242,
+          "representatives_sha256": "599101fdb6931287ef5564ea38c95caea41b60d7d1d429146ae354c4a7952ecc",
+          "structurally_merged_rows": 5660,
+          "backend_artifact_bytes": 1062845,
+          "backend_with_key_registry_bytes": 1266793,
+          "backend_with_datrie_key_index_bytes": 1171437,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9700998667021034,
+            "mean_cosine": 0.9978769785585703,
+            "p05_cosine": 0.9901246605818729,
+            "relative_l2_mean": 0.04258538715461437,
+            "relative_l2_p95": 0.14088813718565277,
+            "relative_l2_max": 0.24497508276344912,
+            "weighted_relative_l2_mean": 0.026546119474474904,
+            "weighted_relative_frobenius": 0.01246643812514673,
+            "weighted_mean_cosine": 0.9988771576024272,
+            "max_relative_norm_change": 0.0111298361935299
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9701794907300444,
+            "mean_cosine": 0.9978806276363834,
+            "p05_cosine": 0.9901037209797523,
+            "relative_l2_mean": 0.038836266683763034,
+            "relative_l2_p95": 0.14105104167974752,
+            "relative_l2_max": 0.24412266774317654,
+            "weighted_relative_l2_mean": 0.021487302568305788,
+            "weighted_relative_frobenius": 0.010142155276340896,
+            "weighted_mean_cosine": 0.9988895351383342,
+            "max_relative_norm_change": 0.010096948723578298
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.029113,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13725895,
+            "warm_p99_ms": 0.14545402,
+            "samples_ms": [
+              0.137657,
+              0.134794,
+              0.137238,
+              0.134863,
+              0.133886,
+              0.133467,
+              0.132,
+              0.131022,
+              0.131511,
+              0.13249,
+              0.132001,
+              0.131581,
+              0.132489,
+              0.150439,
+              0.132978,
+              0.129626,
+              0.131511,
+              0.132908,
+              0.129626,
+              0.132001,
+              0.131023,
+              0.131511,
+              0.132419,
+              0.131022,
+              0.132489,
+              0.132419,
+              0.131092,
+              0.131511,
+              0.130533,
+              0.131022,
+              0.130603,
+              0.132908,
+              0.132,
+              0.130533,
+              0.132419,
+              0.131511,
+              0.132,
+              0.130534,
+              0.130604,
+              0.132908
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1060741,
+              "unique_rows": 7755,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 126,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 125,
+              "zlib_blocks": 7,
+              "xor_blocks": 118,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7755
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "e9a7984a19c4b069f4a9392f4ec1ae2fa47e05bd66dccd4a007f06f7de49f95e",
+            "table_sha256": "50f729d92051e4fe5eb1dcfd3110097fcd3ca04b2166d6fbc721ae9860db91f4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13268425199203193,
+          "representatives_sha256": "ab965745e290e733ba2e090edcc95679f8c068f19cf0fd16716985e6c65e2e04",
+          "structurally_merged_rows": 5669,
+          "backend_artifact_bytes": 1061990,
+          "backend_with_key_registry_bytes": 1265938,
+          "backend_with_datrie_key_index_bytes": 1170582,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9557065263986815,
+            "mean_cosine": 0.9978268548710147,
+            "p05_cosine": 0.9900065748645731,
+            "relative_l2_mean": 0.04292268929545207,
+            "relative_l2_p95": 0.1414940391005668,
+            "relative_l2_max": 0.2965704847402198,
+            "weighted_relative_l2_mean": 0.026965828093723367,
+            "weighted_relative_frobenius": 0.013918167697519409,
+            "weighted_mean_cosine": 0.9988134998170167,
+            "max_relative_norm_change": 0.0111298361935299
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9557439075746106,
+            "mean_cosine": 0.9978304961514793,
+            "p05_cosine": 0.9899764394161308,
+            "relative_l2_mean": 0.039177046495271935,
+            "relative_l2_p95": 0.1415856539324187,
+            "relative_l2_max": 0.2964602215300839,
+            "weighted_relative_l2_mean": 0.021909437042092,
+            "weighted_relative_frobenius": 0.011874855595628387,
+            "weighted_mean_cosine": 0.9988260130853636,
+            "max_relative_norm_change": 0.010096948723578298
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.154479,
+            "warm_p50_ms": 0.13008,
+            "warm_p95_ms": 0.14809529999999999,
+            "warm_p99_ms": 0.17825984,
+            "samples_ms": [
+              0.134863,
+              0.131511,
+              0.133397,
+              0.132489,
+              0.131022,
+              0.132419,
+              0.132001,
+              0.131022,
+              0.129695,
+              0.130044,
+              0.157981,
+              0.191225,
+              0.135282,
+              0.130045,
+              0.134375,
+              0.130115,
+              0.132489,
+              0.132908,
+              0.130603,
+              0.129625,
+              0.147575,
+              0.130534,
+              0.130045,
+              0.129556,
+              0.129067,
+              0.128648,
+              0.128718,
+              0.129626,
+              0.12774,
+              0.130603,
+              0.12781,
+              0.128718,
+              0.129695,
+              0.129695,
+              0.131581,
+              0.128717,
+              0.128299,
+              0.12781,
+              0.129206,
+              0.128648
+            ],
+            "warm_rows_per_second": 3936039.360393604
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              13424,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1771968,
+              "artifact_bytes": 1059135,
+              "unique_rows": 7742,
+              "row_map_bytes": 107392,
+              "n_rows": 13424,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 125,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 125,
+              "zlib_blocks": 6,
+              "xor_blocks": 119,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 7742
+            },
+            "source_float32_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05",
+            "decoded_float32_sha256": "0605382b46ed5748b8909f990c0419e8f45a4efa95ef7efebd85e0421392f8c7",
+            "table_sha256": "e1819522091ce34dc9daea36f0974bad0d1515c2e17b2a7f05325010841aa629",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13126444700174034,
+          "representatives_sha256": "f5f06c36d66192dec9d070f1b57787a8e3bd3df3a24b66630891d204b692d048",
+          "structurally_merged_rows": 5682,
+          "backend_artifact_bytes": 1060384,
+          "backend_with_key_registry_bytes": 1264332,
+          "backend_with_datrie_key_index_bytes": 1168976,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 13424,
+            "minimum_cosine": 0.9046011955085531,
+            "mean_cosine": 0.99771373339742,
+            "p05_cosine": 0.9898863383879815,
+            "relative_l2_mean": 0.043498349017067534,
+            "relative_l2_p95": 0.14221283141432034,
+            "relative_l2_max": 0.4373025064573066,
+            "weighted_relative_l2_mean": 0.02747763035423054,
+            "weighted_relative_frobenius": 0.016280209324312445,
+            "weighted_mean_cosine": 0.9987135768531176,
+            "max_relative_norm_change": 0.0111298361935299
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 13424,
+            "minimum_cosine": 0.9049461656915113,
+            "mean_cosine": 0.9977174368184777,
+            "p05_cosine": 0.9898406733669267,
+            "relative_l2_mean": 0.039758301746644985,
+            "relative_l2_p95": 0.1425129598986701,
+            "relative_l2_max": 0.4364542837019542,
+            "weighted_relative_l2_mean": 0.02242761496627819,
+            "weighted_relative_frobenius": 0.014570493521539054,
+            "weighted_mean_cosine": 0.9987261497009806,
+            "max_relative_norm_change": 0.010096948723578298
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.086383,
+            "warm_p50_ms": 0.1313015,
+            "warm_p95_ms": 0.13734249999999995,
+            "warm_p99_ms": 0.15659556,
+            "samples_ms": [
+              0.149949,
+              0.134375,
+              0.133885,
+              0.132489,
+              0.132489,
+              0.133466,
+              0.132419,
+              0.130603,
+              0.132908,
+              0.131511,
+              0.132489,
+              0.132489,
+              0.132,
+              0.131581,
+              0.131511,
+              0.130533,
+              0.136679,
+              0.130533,
+              0.131092,
+              0.129206,
+              0.130673,
+              0.130603,
+              0.130114,
+              0.130533,
+              0.134445,
+              0.129207,
+              0.130604,
+              0.130115,
+              0.132,
+              0.160845,
+              0.134934,
+              0.132489,
+              0.130604,
+              0.130115,
+              0.131023,
+              0.129626,
+              0.130115,
+              0.128648,
+              0.128159,
+              0.130534
+            ],
+            "warm_rows_per_second": 3899422.3219079752
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "2c882b270b22669d0de174b3941a1445e2f0dada1c2c346d1e5e0ee8d8063d05"
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "rows": 14132,
+      "dim": 128,
+      "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+      "source_float32_bytes": 7235584,
+      "key_registry_bytes": 218478,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 113712,
+      "query_rows": 512,
+      "query_ids_sha256": "48cdbdeffaad5c50239fec7524368c85bd12fc21eefeb42effaa6c7c5ff0c323",
+      "frequency_trace_sha256": "fc8afe9c1f9a53dfd826267bdad324151b311d81a4be4e4834bd129ccf363886",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 7235584,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "table_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03851464297622442,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 7236389,
+          "backend_with_key_registry_bytes": 7454867,
+          "backend_with_datrie_key_index_bytes": 7350101,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.377073,
+            "warm_p50_ms": 0.0603425,
+            "warm_p95_ms": 0.061981249999999995,
+            "warm_p99_ms": 0.06475656,
+            "samples_ms": [
+              0.06188,
+              0.060972,
+              0.061531,
+              0.059086,
+              0.06146,
+              0.059086,
+              0.060552,
+              0.059644,
+              0.060552,
+              0.06146,
+              0.060133,
+              0.060552,
+              0.060623,
+              0.0616,
+              0.059505,
+              0.059715,
+              0.059574,
+              0.065301,
+              0.059575,
+              0.060553,
+              0.060972,
+              0.061042,
+              0.060064,
+              0.059086,
+              0.059644,
+              0.060971,
+              0.059156,
+              0.059645,
+              0.060552,
+              0.059644,
+              0.059644,
+              0.060064,
+              0.061111,
+              0.063905,
+              0.061111,
+              0.059993,
+              0.061111,
+              0.059156,
+              0.058667,
+              0.059085
+            ],
+            "warm_rows_per_second": 8484898.703235697
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6810278,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 57,
+              "xor_blocks": 827,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "table_sha256": "f7683077057a2241d3358ae7b97510fae0590048137d3eadaf5ffc35c2e690ea",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6136417649686337,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6811487,
+          "backend_with_key_registry_bytes": 7029965,
+          "backend_with_datrie_key_index_bytes": 6925199,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.077025,
+            "warm_p50_ms": 0.07239100000000001,
+            "warm_p95_ms": 0.07666835,
+            "warm_p99_ms": 0.08426685999999999,
+            "samples_ms": [
+              0.077663,
+              0.076616,
+              0.076547,
+              0.075708,
+              0.074311,
+              0.0748,
+              0.073822,
+              0.075289,
+              0.074242,
+              0.074311,
+              0.07466,
+              0.074311,
+              0.075149,
+              0.072844,
+              0.071377,
+              0.070959,
+              0.071378,
+              0.071378,
+              0.071937,
+              0.071936,
+              0.071447,
+              0.070959,
+              0.070959,
+              0.070959,
+              0.072426,
+              0.071937,
+              0.074311,
+              0.071867,
+              0.070051,
+              0.069632,
+              0.071936,
+              0.072007,
+              0.072426,
+              0.071936,
+              0.072356,
+              0.072426,
+              0.071937,
+              0.088489,
+              0.073334,
+              0.072356
+            ],
+            "warm_rows_per_second": 7072702.40775787
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6810278,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 57,
+              "xor_blocks": 827,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "table_sha256": "f7683077057a2241d3358ae7b97510fae0590048137d3eadaf5ffc35c2e690ea",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6651246889960021,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6811486,
+          "backend_with_key_registry_bytes": 7029964,
+          "backend_with_datrie_key_index_bytes": 6925198,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.019336,
+            "warm_p50_ms": 0.07190150000000001,
+            "warm_p95_ms": 0.07951124999999999,
+            "warm_p99_ms": 0.08629181999999999,
+            "samples_ms": [
+              0.07941,
+              0.076616,
+              0.075708,
+              0.075219,
+              0.075708,
+              0.076616,
+              0.081435,
+              0.074242,
+              0.072356,
+              0.071867,
+              0.071866,
+              0.07047,
+              0.071378,
+              0.071447,
+              0.071937,
+              0.07047,
+              0.070121,
+              0.070121,
+              0.070959,
+              0.07047,
+              0.076686,
+              0.071029,
+              0.070539,
+              0.071518,
+              0.074731,
+              0.072426,
+              0.071866,
+              0.071936,
+              0.070959,
+              0.071517,
+              0.089397,
+              0.072425,
+              0.073752,
+              0.071866,
+              0.072915,
+              0.073334,
+              0.071867,
+              0.072355,
+              0.071377,
+              0.070889
+            ],
+            "warm_rows_per_second": 7120852.833390123
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6810278,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 57,
+              "xor_blocks": 827,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "table_sha256": "f7683077057a2241d3358ae7b97510fae0590048137d3eadaf5ffc35c2e690ea",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6406189650297165,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6811486,
+          "backend_with_key_registry_bytes": 7029964,
+          "backend_with_datrie_key_index_bytes": 6925198,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.988117,
+            "warm_p50_ms": 0.071448,
+            "warm_p95_ms": 0.07633319999999999,
+            "warm_p99_ms": 0.08820885999999999,
+            "samples_ms": [
+              0.078921,
+              0.094147,
+              0.076197,
+              0.075219,
+              0.0748,
+              0.072426,
+              0.072355,
+              0.072285,
+              0.071867,
+              0.071378,
+              0.069912,
+              0.070051,
+              0.070051,
+              0.07047,
+              0.070889,
+              0.071867,
+              0.069912,
+              0.072426,
+              0.07047,
+              0.071448,
+              0.070959,
+              0.071448,
+              0.071937,
+              0.071518,
+              0.070121,
+              0.072425,
+              0.070051,
+              0.071866,
+              0.071378,
+              0.071448,
+              0.071866,
+              0.070889,
+              0.07047,
+              0.071029,
+              0.071937,
+              0.072355,
+              0.07054,
+              0.070959,
+              0.071936,
+              0.070051
+            ],
+            "warm_rows_per_second": 7166050.834173105
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4307441,
+              "unique_rows": 8746,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 547,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 547,
+              "zlib_blocks": 326,
+              "xor_blocks": 221,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8746
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "667b8a6710c6beda63d49ba2caf0940536a5ad9e4edfa886a69c48c44c1b5a70",
+            "table_sha256": "153c0767c1982d9c87738e408eaf929f362d1fa24add1856f83418b62c849e68",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.40754929301328957,
+          "representatives_sha256": "bd1c7e95e0c55d05a3530176d1829d47bb1dda86fb4b52fa4bad88bcee35ef87",
+          "structurally_merged_rows": 5386,
+          "backend_artifact_bytes": 4308648,
+          "backend_with_key_registry_bytes": 4527126,
+          "backend_with_datrie_key_index_bytes": 4422360,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900015337324976,
+            "mean_cosine": 0.9985769339166507,
+            "p05_cosine": 0.9927441288359597,
+            "relative_l2_mean": 0.031006401826595625,
+            "relative_l2_p95": 0.12056503533434654,
+            "relative_l2_max": 0.14213808847272216,
+            "weighted_relative_l2_mean": 0.0178832102708785,
+            "weighted_relative_frobenius": 0.009597568466419546,
+            "weighted_mean_cosine": 0.9992198977556092,
+            "max_relative_norm_change": 0.010083232692545538
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900015337324976,
+            "mean_cosine": 0.9985769339166507,
+            "p05_cosine": 0.9927441288359597,
+            "relative_l2_mean": 0.031006401826595625,
+            "relative_l2_p95": 0.12056503533434654,
+            "relative_l2_max": 0.14213808847272216,
+            "weighted_relative_l2_mean": 0.0178832102708785,
+            "weighted_relative_frobenius": 0.009597568466419546,
+            "weighted_mean_cosine": 0.9992198977556092,
+            "max_relative_norm_change": 0.010083232692545538
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.767232,
+            "warm_p50_ms": 0.070889,
+            "warm_p95_ms": 0.0752225,
+            "warm_p99_ms": 0.07899596999999998,
+            "samples_ms": [
+              0.081366,
+              0.073822,
+              0.072845,
+              0.07054,
+              0.070051,
+              0.069493,
+              0.070051,
+              0.07473,
+              0.073683,
+              0.071378,
+              0.070889,
+              0.071378,
+              0.07047,
+              0.07054,
+              0.07005,
+              0.07054,
+              0.075289,
+              0.071029,
+              0.073333,
+              0.072844,
+              0.072356,
+              0.070889,
+              0.07012,
+              0.070051,
+              0.068584,
+              0.069981,
+              0.069562,
+              0.068584,
+              0.0704,
+              0.071867,
+              0.072356,
+              0.070889,
+              0.073263,
+              0.075219,
+              0.071936,
+              0.071029,
+              0.070959,
+              0.069073,
+              0.068654,
+              0.069073
+            ],
+            "warm_rows_per_second": 7222559.212289637
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4080103,
+              "unique_rows": 8266,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 517,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 517,
+              "zlib_blocks": 347,
+              "xor_blocks": 170,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8266
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "502e9617f8fa2ab8d43108fe433e21c326a22ebd963d22937cce03503b847a1e",
+            "table_sha256": "eda23ee1c368d0df35235856b12dcc5e4821ea26f6db92e1186b0cb901d0ffbd",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37877186201512814,
+          "representatives_sha256": "a7907d8deeaa847a4f7a0cca2eaaf5fd223458d3742a31ada2d2ba00926153c6",
+          "structurally_merged_rows": 5866,
+          "backend_artifact_bytes": 4081310,
+          "backend_with_key_registry_bytes": 4299788,
+          "backend_with_datrie_key_index_bytes": 4195022,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800370872506456,
+            "mean_cosine": 0.9981046556900883,
+            "p05_cosine": 0.9907898956835881,
+            "relative_l2_mean": 0.03665354715979584,
+            "relative_l2_p95": 0.1358853294819434,
+            "relative_l2_max": 0.20056834471285476,
+            "weighted_relative_l2_mean": 0.02082327130666535,
+            "weighted_relative_frobenius": 0.011449487051204693,
+            "weighted_mean_cosine": 0.9989732798840621,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800370872506456,
+            "mean_cosine": 0.9981046556900883,
+            "p05_cosine": 0.9907898956835881,
+            "relative_l2_mean": 0.03665354715979584,
+            "relative_l2_p95": 0.1358853294819434,
+            "relative_l2_max": 0.20056834471285476,
+            "weighted_relative_l2_mean": 0.02082327130666535,
+            "weighted_relative_frobenius": 0.011449487051204693,
+            "weighted_mean_cosine": 0.9989732798840621,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.947074,
+            "warm_p50_ms": 0.0707145,
+            "warm_p95_ms": 0.0771574,
+            "warm_p99_ms": 0.09250995999999999,
+            "samples_ms": [
+              0.078153,
+              0.077105,
+              0.07473,
+              0.073892,
+              0.072914,
+              0.072844,
+              0.072356,
+              0.073334,
+              0.072356,
+              0.071378,
+              0.072844,
+              0.071866,
+              0.070959,
+              0.073334,
+              0.069981,
+              0.070889,
+              0.069142,
+              0.07054,
+              0.069073,
+              0.069492,
+              0.073822,
+              0.073822,
+              0.101689,
+              0.072356,
+              0.070958,
+              0.07047,
+              0.07054,
+              0.069143,
+              0.070051,
+              0.068515,
+              0.069632,
+              0.069073,
+              0.069493,
+              0.069073,
+              0.069492,
+              0.069981,
+              0.069632,
+              0.069073,
+              0.07047,
+              0.069003
+            ],
+            "warm_rows_per_second": 7240382.099852223
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4045652,
+              "unique_rows": 8196,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 513,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 513,
+              "zlib_blocks": 351,
+              "xor_blocks": 162,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8196
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "6f80a541f40d8ddb31b97b8b5e34e996b3e5047745dbf2e053efb92dacebcbf2",
+            "table_sha256": "627595a6e7ded85684f853b79726edbe749601f5c0b17efd194fdddd1cd62e02",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4442353490740061,
+          "representatives_sha256": "e1a1ae7ddfddf044ffde352196fc3347d86678c07064681ca6a053413eb30d0c",
+          "structurally_merged_rows": 5936,
+          "backend_artifact_bytes": 4046859,
+          "backend_with_key_registry_bytes": 4265337,
+          "backend_with_datrie_key_index_bytes": 4160571,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9705909970636375,
+            "mean_cosine": 0.9979711391605847,
+            "p05_cosine": 0.9903802210783794,
+            "relative_l2_mean": 0.03784439763998729,
+            "relative_l2_p95": 0.13865994162687642,
+            "relative_l2_max": 0.24349894495101002,
+            "weighted_relative_l2_mean": 0.021413248484090965,
+            "weighted_relative_frobenius": 0.011589934801130889,
+            "weighted_mean_cosine": 0.9989071324486565,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9705909970636375,
+            "mean_cosine": 0.9979711391605847,
+            "p05_cosine": 0.9903802210783794,
+            "relative_l2_mean": 0.03784439763998729,
+            "relative_l2_p95": 0.13865994162687642,
+            "relative_l2_max": 0.24349894495101002,
+            "weighted_relative_l2_mean": 0.021413248484090965,
+            "weighted_relative_frobenius": 0.011589934801130889,
+            "weighted_mean_cosine": 0.9989071324486565,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.804038,
+            "warm_p50_ms": 0.0709585,
+            "warm_p95_ms": 0.0790389,
+            "warm_p99_ms": 0.08312109,
+            "samples_ms": [
+              0.079968,
+              0.076267,
+              0.074312,
+              0.073334,
+              0.071867,
+              0.07899,
+              0.07054,
+              0.07054,
+              0.069003,
+              0.069074,
+              0.069143,
+              0.07054,
+              0.068585,
+              0.069562,
+              0.069143,
+              0.069982,
+              0.069981,
+              0.070051,
+              0.069003,
+              0.069492,
+              0.070051,
+              0.072845,
+              0.072426,
+              0.071448,
+              0.070959,
+              0.071378,
+              0.075289,
+              0.073823,
+              0.085137,
+              0.072845,
+              0.070958,
+              0.070959,
+              0.07047,
+              0.070051,
+              0.071518,
+              0.071448,
+              0.072495,
+              0.071518,
+              0.069981,
+              0.069073
+            ],
+            "warm_rows_per_second": 7215485.107492409
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4035247,
+              "unique_rows": 8175,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 511,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 511,
+              "zlib_blocks": 354,
+              "xor_blocks": 157,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8175
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "9950c39558a2e16ecd8020319f22b7f21053f15dfb4ac94a30135d35b19449a3",
+            "table_sha256": "f88164237644c70a9fb4052c30ede88c597be801cc1bc4bdf7aa70cc73749f44",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38341121398843825,
+          "representatives_sha256": "49ba1ef3554d37429d76dea99b128bc135acf26008bcac1c3810e3a3bbacc4f0",
+          "structurally_merged_rows": 5957,
+          "backend_artifact_bytes": 4036454,
+          "backend_with_key_registry_bytes": 4254932,
+          "backend_with_datrie_key_index_bytes": 4150166,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9519201373230705,
+            "mean_cosine": 0.9979023065652721,
+            "p05_cosine": 0.9902684251190589,
+            "relative_l2_mean": 0.03833110127692099,
+            "relative_l2_p95": 0.1396269426984356,
+            "relative_l2_max": 0.3099892446519552,
+            "weighted_relative_l2_mean": 0.021686112527658816,
+            "weighted_relative_frobenius": 0.011889347328295592,
+            "weighted_mean_cosine": 0.9988684579740494,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9519201373230705,
+            "mean_cosine": 0.9979023065652721,
+            "p05_cosine": 0.9902684251190589,
+            "relative_l2_mean": 0.03833110127692099,
+            "relative_l2_p95": 0.1396269426984356,
+            "relative_l2_max": 0.3099892446519552,
+            "weighted_relative_l2_mean": 0.021686112527658816,
+            "weighted_relative_frobenius": 0.011889347328295592,
+            "weighted_mean_cosine": 0.9988684579740494,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.631879,
+            "warm_p50_ms": 0.07050500000000001,
+            "warm_p95_ms": 0.0775975,
+            "warm_p99_ms": 0.09001833,
+            "samples_ms": [
+              0.076197,
+              0.077594,
+              0.077664,
+              0.073822,
+              0.073822,
+              0.074241,
+              0.071866,
+              0.071866,
+              0.070959,
+              0.071867,
+              0.0704,
+              0.070959,
+              0.069143,
+              0.07047,
+              0.069073,
+              0.07047,
+              0.097917,
+              0.073333,
+              0.069073,
+              0.069562,
+              0.069632,
+              0.07047,
+              0.070469,
+              0.071378,
+              0.069003,
+              0.071029,
+              0.07054,
+              0.069073,
+              0.069074,
+              0.069073,
+              0.069562,
+              0.070958,
+              0.071378,
+              0.070959,
+              0.07047,
+              0.069143,
+              0.069073,
+              0.069004,
+              0.070959,
+              0.070121
+            ],
+            "warm_rows_per_second": 7261896.319409969
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4027967,
+              "unique_rows": 8159,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 510,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 510,
+              "zlib_blocks": 348,
+              "xor_blocks": 162,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8159
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "6034934eff3b90eca02d80e44a5d9cd2e9e5c08b5c10e88e8912fdd4cb496cb0",
+            "table_sha256": "93d8683f589c380bf7e4c6361dceec90d113c9aec7cdab841b2721d4ed7640b7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4235941560473293,
+          "representatives_sha256": "24ea241cf3e96037e0e4faf4f1b2273c0896e9a063a205b714b24f3ec65497cf",
+          "structurally_merged_rows": 5973,
+          "backend_artifact_bytes": 4029174,
+          "backend_with_key_registry_bytes": 4247652,
+          "backend_with_datrie_key_index_bytes": 4142886,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9069112665063119,
+            "mean_cosine": 0.9977733189647556,
+            "p05_cosine": 0.9900972903136396,
+            "relative_l2_mean": 0.03896459512890429,
+            "relative_l2_p95": 0.14063370589982319,
+            "relative_l2_max": 0.4315442500650112,
+            "weighted_relative_l2_mean": 0.02236025039160826,
+            "weighted_relative_frobenius": 0.015609319162613444,
+            "weighted_mean_cosine": 0.9987317415365643,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9069112665063119,
+            "mean_cosine": 0.9977733189647556,
+            "p05_cosine": 0.9900972903136396,
+            "relative_l2_mean": 0.03896459512890429,
+            "relative_l2_p95": 0.14063370589982319,
+            "relative_l2_max": 0.4315442500650112,
+            "weighted_relative_l2_mean": 0.02236025039160826,
+            "weighted_relative_frobenius": 0.015609319162613444,
+            "weighted_mean_cosine": 0.9987317415365643,
+            "max_relative_norm_change": 0.010097242954185409
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.623009,
+            "warm_p50_ms": 0.07047,
+            "warm_p95_ms": 0.07622145,
+            "warm_p99_ms": 0.08299096,
+            "samples_ms": [
+              0.076686,
+              0.072426,
+              0.074311,
+              0.073823,
+              0.072356,
+              0.073333,
+              0.072356,
+              0.076127,
+              0.076197,
+              0.072914,
+              0.071518,
+              0.069981,
+              0.069492,
+              0.070051,
+              0.070121,
+              0.070051,
+              0.069493,
+              0.070051,
+              0.072355,
+              0.072356,
+              0.071937,
+              0.070051,
+              0.069562,
+              0.072425,
+              0.071517,
+              0.07047,
+              0.07047,
+              0.068165,
+              0.068584,
+              0.070051,
+              0.070051,
+              0.069073,
+              0.087022,
+              0.072007,
+              0.071937,
+              0.069492,
+              0.068096,
+              0.070121,
+              0.069981,
+              0.069492
+            ],
+            "warm_rows_per_second": 7265503.050943663
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3617792,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "965e67427fd2f63b0379f2c343356af421d0b17cd7971cffda2236625ac6d2b2",
+            "table_sha256": "f398ae975042657c209fa7ae6041b7bf9b9ad537f36366d974ec5992fba17f9b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.045753000071272254,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3618598,
+          "backend_with_key_registry_bytes": 3837076,
+          "backend_with_datrie_key_index_bytes": 3732310,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999614942229,
+            "mean_cosine": 0.9999999789582108,
+            "p05_cosine": 0.9999999733717188,
+            "relative_l2_mean": 0.00020684625216337265,
+            "relative_l2_p95": 0.00023325418518764534,
+            "relative_l2_max": 0.0002805592168150135,
+            "weighted_relative_l2_mean": 0.0002068157332193522,
+            "weighted_relative_frobenius": 0.00020571840501630532,
+            "weighted_mean_cosine": 0.9999999789659619,
+            "max_relative_norm_change": 0.00012469551075047655
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.545042,
+            "warm_p50_ms": 0.22007,
+            "warm_p95_ms": 0.22245169999999997,
+            "warm_p99_ms": 0.23490434,
+            "samples_ms": [
+              0.221886,
+              0.221886,
+              0.220978,
+              0.22007,
+              0.22049,
+              0.22007,
+              0.220978,
+              0.219511,
+              0.219511,
+              0.219022,
+              0.22,
+              0.220978,
+              0.221398,
+              0.235994,
+              0.221397,
+              0.219512,
+              0.220489,
+              0.219022,
+              0.220908,
+              0.218603,
+              0.219511,
+              0.219092,
+              0.221886,
+              0.219581,
+              0.219581,
+              0.22049,
+              0.22007,
+              0.219092,
+              0.220419,
+              0.218952,
+              0.220419,
+              0.2332,
+              0.219093,
+              0.219581,
+              0.219581,
+              0.220489,
+              0.220908,
+              0.219931,
+              0.219931,
+              0.22
+            ],
+            "warm_rows_per_second": 2326532.4669423364
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406763,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "965e67427fd2f63b0379f2c343356af421d0b17cd7971cffda2236625ac6d2b2",
+            "table_sha256": "e7718e7ec3faaa2b3b85f43fd8f38dd8e523f5dbb78b0d66b41877199263ae44",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.34386564302258193,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407972,
+          "backend_with_key_registry_bytes": 3626450,
+          "backend_with_datrie_key_index_bytes": 3521684,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999614942229,
+            "mean_cosine": 0.9999999789582108,
+            "p05_cosine": 0.9999999733717188,
+            "relative_l2_mean": 0.00020684625216337265,
+            "relative_l2_p95": 0.00023325418518764534,
+            "relative_l2_max": 0.0002805592168150135,
+            "weighted_relative_l2_mean": 0.0002068157332193522,
+            "weighted_relative_frobenius": 0.00020571840501630532,
+            "weighted_mean_cosine": 0.9999999789659619,
+            "max_relative_norm_change": 0.00012469551075047655
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.826585,
+            "warm_p50_ms": 0.2285555,
+            "warm_p95_ms": 0.23616084999999995,
+            "warm_p99_ms": 0.25177478,
+            "samples_ms": [
+              0.233759,
+              0.230407,
+              0.229429,
+              0.227613,
+              0.235644,
+              0.229429,
+              0.230406,
+              0.228032,
+              0.229918,
+              0.229847,
+              0.22901,
+              0.22901,
+              0.255479,
+              0.229429,
+              0.227613,
+              0.228521,
+              0.228102,
+              0.228032,
+              0.227124,
+              0.227543,
+              0.227613,
+              0.22859,
+              0.229429,
+              0.228101,
+              0.227054,
+              0.228451,
+              0.22887,
+              0.228032,
+              0.22894,
+              0.245981,
+              0.230895,
+              0.22901,
+              0.227962,
+              0.227124,
+              0.22901,
+              0.228102,
+              0.227613,
+              0.228521,
+              0.228032,
+              0.228521
+            ],
+            "warm_rows_per_second": 2240156.110878977
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406763,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "965e67427fd2f63b0379f2c343356af421d0b17cd7971cffda2236625ac6d2b2",
+            "table_sha256": "e7718e7ec3faaa2b3b85f43fd8f38dd8e523f5dbb78b0d66b41877199263ae44",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.44691041205078363,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407971,
+          "backend_with_key_registry_bytes": 3626449,
+          "backend_with_datrie_key_index_bytes": 3521683,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999614942229,
+            "mean_cosine": 0.9999999789582108,
+            "p05_cosine": 0.9999999733717188,
+            "relative_l2_mean": 0.00020684625216337265,
+            "relative_l2_p95": 0.00023325418518764534,
+            "relative_l2_max": 0.0002805592168150135,
+            "weighted_relative_l2_mean": 0.0002068157332193522,
+            "weighted_relative_frobenius": 0.00020571840501630532,
+            "weighted_mean_cosine": 0.9999999789659619,
+            "max_relative_norm_change": 0.00012469551075047655
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.836992,
+            "warm_p50_ms": 0.22897499999999998,
+            "warm_p95_ms": 0.23543884999999998,
+            "warm_p99_ms": 0.24771515,
+            "samples_ms": [
+              0.234178,
+              0.230896,
+              0.22894,
+              0.22901,
+              0.22901,
+              0.229917,
+              0.228521,
+              0.22901,
+              0.228032,
+              0.228521,
+              0.231804,
+              0.228521,
+              0.22901,
+              0.252128,
+              0.235156,
+              0.229848,
+              0.22894,
+              0.228451,
+              0.228521,
+              0.22894,
+              0.228032,
+              0.228451,
+              0.22894,
+              0.22894,
+              0.228521,
+              0.22901,
+              0.22901,
+              0.22894,
+              0.229079,
+              0.22901,
+              0.240813,
+              0.230826,
+              0.22901,
+              0.227613,
+              0.22901,
+              0.229079,
+              0.227613,
+              0.227613,
+              0.22859,
+              0.228032
+            ],
+            "warm_rows_per_second": 2236051.970739164
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406763,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "965e67427fd2f63b0379f2c343356af421d0b17cd7971cffda2236625ac6d2b2",
+            "table_sha256": "e7718e7ec3faaa2b3b85f43fd8f38dd8e523f5dbb78b0d66b41877199263ae44",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.34564261697232723,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407971,
+          "backend_with_key_registry_bytes": 3626449,
+          "backend_with_datrie_key_index_bytes": 3521683,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999614942229,
+            "mean_cosine": 0.9999999789582108,
+            "p05_cosine": 0.9999999733717188,
+            "relative_l2_mean": 0.00020684625216337265,
+            "relative_l2_p95": 0.00023325418518764534,
+            "relative_l2_max": 0.0002805592168150135,
+            "weighted_relative_l2_mean": 0.0002068157332193522,
+            "weighted_relative_frobenius": 0.00020571840501630532,
+            "weighted_mean_cosine": 0.9999999789659619,
+            "max_relative_norm_change": 0.00012469551075047655
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.869678,
+            "warm_p50_ms": 0.22900949999999998,
+            "warm_p95_ms": 0.23279234999999998,
+            "warm_p99_ms": 0.25237672,
+            "samples_ms": [
+              0.232293,
+              0.230337,
+              0.230406,
+              0.22901,
+              0.22908,
+              0.229499,
+              0.22894,
+              0.22901,
+              0.227683,
+              0.229429,
+              0.22901,
+              0.229009,
+              0.24228,
+              0.231314,
+              0.229428,
+              0.230337,
+              0.228451,
+              0.228521,
+              0.22894,
+              0.22894,
+              0.228032,
+              0.228032,
+              0.228451,
+              0.227962,
+              0.229009,
+              0.22901,
+              0.228451,
+              0.228381,
+              0.22894,
+              0.258832,
+              0.232292,
+              0.22894,
+              0.229429,
+              0.228451,
+              0.228521,
+              0.229498,
+              0.229988,
+              0.229499,
+              0.228521,
+              0.228521
+            ],
+            "warm_rows_per_second": 2235715.1122551686
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2208336,
+              "unique_rows": 8746,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 274,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 274,
+              "zlib_blocks": 89,
+              "xor_blocks": 185,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8746
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "6b6c28446000c3faa7f71c67269342ba9a31273cb6cca044dce1932a6c008f60",
+            "table_sha256": "7a840443c32a6e758971b6a8e21ad75ea5a2829494c699881e228f20d756fa13",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2349200490862131,
+          "representatives_sha256": "388497d9f767962dcf6fcfa9c748f8aaf8235df91625d576f5c28cc15aa8d59d",
+          "structurally_merged_rows": 5386,
+          "backend_artifact_bytes": 2209542,
+          "backend_with_key_registry_bytes": 2428020,
+          "backend_with_datrie_key_index_bytes": 2323254,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900081908684233,
+            "mean_cosine": 0.9985776215363579,
+            "p05_cosine": 0.9927595161626462,
+            "relative_l2_mean": 0.031127708198948993,
+            "relative_l2_p95": 0.12041610625178735,
+            "relative_l2_max": 0.14217809684457094,
+            "weighted_relative_l2_mean": 0.018037095789352302,
+            "weighted_relative_frobenius": 0.009600233959965716,
+            "weighted_mean_cosine": 0.9992202466134478,
+            "max_relative_norm_change": 0.01008429606092528
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900063056169309,
+            "mean_cosine": 0.9985776202179737,
+            "p05_cosine": 0.9927590619696117,
+            "relative_l2_mean": 0.030999892838835974,
+            "relative_l2_p95": 0.12044711814496074,
+            "relative_l2_max": 0.1421703389032944,
+            "weighted_relative_l2_mean": 0.017879802244459758,
+            "weighted_relative_frobenius": 0.009598270767519452,
+            "weighted_mean_cosine": 0.9992202531533373,
+            "max_relative_norm_change": 0.010089724453680103
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.133572,
+            "warm_p50_ms": 0.2280665,
+            "warm_p95_ms": 0.23551899999999998,
+            "warm_p99_ms": 0.25090313,
+            "samples_ms": [
+              0.235086,
+              0.229988,
+              0.228101,
+              0.232293,
+              0.230477,
+              0.231385,
+              0.231315,
+              0.228032,
+              0.22908,
+              0.228102,
+              0.227124,
+              0.230896,
+              0.229499,
+              0.231384,
+              0.23362,
+              0.243746,
+              0.232292,
+              0.231384,
+              0.228032,
+              0.227962,
+              0.227054,
+              0.227124,
+              0.227543,
+              0.227613,
+              0.227613,
+              0.227544,
+              0.227543,
+              0.225657,
+              0.227194,
+              0.228102,
+              0.227543,
+              0.226635,
+              0.226076,
+              0.255479,
+              0.230896,
+              0.229918,
+              0.228032,
+              0.227054,
+              0.227543,
+              0.227054
+            ],
+            "warm_rows_per_second": 2244959.255304922
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2096994,
+              "unique_rows": 8265,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 259,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 259,
+              "zlib_blocks": 127,
+              "xor_blocks": 132,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8265
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "3b0e0f6ec11e3df889b0bc8e1af1d5360039f6d5417d8c252e86d654544c5c58",
+            "table_sha256": "6a2b12f7c64f809e1fe69791247c692f725f61a10222e638bf8b2b0fafdfe0bd",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22290237713605165,
+          "representatives_sha256": "feffcce9b3c698f4da826db68af8e6ef29a638f659a8b3af5889bbb80fa528eb",
+          "structurally_merged_rows": 5867,
+          "backend_artifact_bytes": 2098201,
+          "backend_with_key_registry_bytes": 2316679,
+          "backend_with_datrie_key_index_bytes": 2211913,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800421398034684,
+            "mean_cosine": 0.9981047704915305,
+            "p05_cosine": 0.9907985880247167,
+            "relative_l2_mean": 0.03677686713143057,
+            "relative_l2_p95": 0.13584521041237388,
+            "relative_l2_max": 0.20054694321241362,
+            "weighted_relative_l2_mean": 0.02097795549079116,
+            "weighted_relative_frobenius": 0.011451663323190498,
+            "weighted_mean_cosine": 0.998973349064148,
+            "max_relative_norm_change": 0.010093588270012993
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800401520236893,
+            "mean_cosine": 0.9981047640986421,
+            "p05_cosine": 0.9907991999638034,
+            "relative_l2_mean": 0.03665613588618342,
+            "relative_l2_p95": 0.13583220356511932,
+            "relative_l2_max": 0.20055616801789974,
+            "weighted_relative_l2_mean": 0.02082433902623526,
+            "weighted_relative_frobenius": 0.01144982086855333,
+            "weighted_mean_cosine": 0.9989733547391864,
+            "max_relative_norm_change": 0.010100504012249704
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.084404,
+            "warm_p50_ms": 0.22897499999999998,
+            "warm_p95_ms": 0.24273029999999998,
+            "warm_p99_ms": 0.25551289,
+            "samples_ms": [
+              0.232851,
+              0.230826,
+              0.229918,
+              0.252616,
+              0.236623,
+              0.234736,
+              0.231804,
+              0.230407,
+              0.229429,
+              0.228939,
+              0.228451,
+              0.232292,
+              0.231384,
+              0.230406,
+              0.230895,
+              0.229499,
+              0.228521,
+              0.227613,
+              0.229498,
+              0.227124,
+              0.257365,
+              0.231803,
+              0.22901,
+              0.228521,
+              0.227543,
+              0.22894,
+              0.227124,
+              0.227054,
+              0.22852,
+              0.228521,
+              0.228521,
+              0.228521,
+              0.226216,
+              0.227682,
+              0.226636,
+              0.227962,
+              0.227543,
+              0.24221,
+              0.229429,
+              0.228102
+            ],
+            "warm_rows_per_second": 2236051.970739164
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2079846,
+              "unique_rows": 8195,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 257,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 256,
+              "zlib_blocks": 118,
+              "xor_blocks": 138,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8195
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "1cbd7860e9ec4d28e8fb5160419d8b7999362e0852d68370160995df52a01449",
+            "table_sha256": "f350383ebdb9829a2c1a8d98d0044bf47932367442eeb900c412e56ea04da56f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22908319695852697,
+          "representatives_sha256": "e0ebbe2f8b9ec11acf0083be0cadc18da4efa8c4bd62ac90eda390a69035149b",
+          "structurally_merged_rows": 5937,
+          "backend_artifact_bytes": 2081053,
+          "backend_with_key_registry_bytes": 2299531,
+          "backend_with_datrie_key_index_bytes": 2194765,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.970585578118649,
+            "mean_cosine": 0.9979712542989172,
+            "p05_cosine": 0.990390049273828,
+            "relative_l2_mean": 0.037966665140841765,
+            "relative_l2_p95": 0.13859286993259123,
+            "relative_l2_max": 0.24352684348208944,
+            "weighted_relative_l2_mean": 0.02156741124781128,
+            "weighted_relative_frobenius": 0.011592084095370938,
+            "weighted_mean_cosine": 0.9989072017956463,
+            "max_relative_norm_change": 0.010093588270012993
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9705884310415499,
+            "mean_cosine": 0.9979712447439355,
+            "p05_cosine": 0.990390953577697,
+            "relative_l2_mean": 0.03784700510746191,
+            "relative_l2_p95": 0.1385812581912458,
+            "relative_l2_max": 0.24350950083384507,
+            "weighted_relative_l2_mean": 0.021414325488465155,
+            "weighted_relative_frobenius": 0.011590271896844764,
+            "weighted_mean_cosine": 0.9989072059041043,
+            "max_relative_norm_change": 0.010100504012249704
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.150963,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.28583990000000004,
+            "warm_p99_ms": 0.28847273,
+            "samples_ms": [
+              0.231873,
+              0.229009,
+              0.229429,
+              0.229429,
+              0.229429,
+              0.229918,
+              0.229498,
+              0.240324,
+              0.289562,
+              0.286769,
+              0.285791,
+              0.228032,
+              0.22901,
+              0.228451,
+              0.22901,
+              0.228521,
+              0.228032,
+              0.232223,
+              0.228521,
+              0.228102,
+              0.229079,
+              0.233689,
+              0.228032,
+              0.227543,
+              0.263022,
+              0.231314,
+              0.230896,
+              0.228521,
+              0.227474,
+              0.227543,
+              0.228032,
+              0.22901,
+              0.226635,
+              0.228032,
+              0.230407,
+              0.229428,
+              0.228451,
+              0.228032,
+              0.227124,
+              0.227613
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2074878,
+              "unique_rows": 8174,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 256,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 256,
+              "zlib_blocks": 124,
+              "xor_blocks": 132,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8174
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "8c15ce75b7083992f68e04ddec4b68dc6c61e1013303ddaad47dda9656d689d3",
+            "table_sha256": "33c103d9a26b56b7945dcb400146290041cadc977a92c452ccb373a89f89a409",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22787759499624372,
+          "representatives_sha256": "117f503a7b9ba36569800ce516775efd7241f0e7d79707430cb64300952ac9f8",
+          "structurally_merged_rows": 5958,
+          "backend_artifact_bytes": 2076085,
+          "backend_with_key_registry_bytes": 2294563,
+          "backend_with_datrie_key_index_bytes": 2189797,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9519140491379375,
+            "mean_cosine": 0.9979024186868628,
+            "p05_cosine": 0.9902829300193834,
+            "relative_l2_mean": 0.0384530659329802,
+            "relative_l2_p95": 0.1395751234873996,
+            "relative_l2_max": 0.31000986075714415,
+            "weighted_relative_l2_mean": 0.021840116887272,
+            "weighted_relative_frobenius": 0.011891428298117412,
+            "weighted_mean_cosine": 0.9988685261740616,
+            "max_relative_norm_change": 0.010093588270012993
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9519135406106861,
+            "mean_cosine": 0.9979024112977994,
+            "p05_cosine": 0.9902785476081027,
+            "relative_l2_mean": 0.03833370890301321,
+            "relative_l2_p95": 0.13956606440344563,
+            "relative_l2_max": 0.31001166950115155,
+            "weighted_relative_l2_mean": 0.02168718814151804,
+            "weighted_relative_frobenius": 0.011889664115582324,
+            "weighted_mean_cosine": 0.9988685313492044,
+            "max_relative_norm_change": 0.010100504012249704
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.922093,
+            "warm_p50_ms": 0.2292545,
+            "warm_p95_ms": 0.23645164999999996,
+            "warm_p99_ms": 0.25948901,
+            "samples_ms": [
+              0.235645,
+              0.234178,
+              0.264419,
+              0.232292,
+              0.229499,
+              0.231385,
+              0.231804,
+              0.231804,
+              0.231804,
+              0.230896,
+              0.228521,
+              0.228521,
+              0.23327,
+              0.232781,
+              0.22894,
+              0.228101,
+              0.22894,
+              0.229917,
+              0.226705,
+              0.251778,
+              0.229499,
+              0.227613,
+              0.227543,
+              0.22901,
+              0.226635,
+              0.228871,
+              0.22894,
+              0.229009,
+              0.229987,
+              0.228032,
+              0.229429,
+              0.230407,
+              0.227613,
+              0.226635,
+              0.228102,
+              0.228591,
+              0.22908,
+              0.229429,
+              0.229499,
+              0.228102
+            ],
+            "warm_rows_per_second": 2233325.8452942036
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2070983,
+              "unique_rows": 8158,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 255,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 255,
+              "zlib_blocks": 124,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8158
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "dc2312b22728a2665d920a5ec2a3e1acbb0d31cdf8a55690286ff5fa8920e668",
+            "table_sha256": "034383ffcb0d1a5e2a49f2486b82698ed00ff6d58c53f602d2c123f020ecc832",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22084003197960556,
+          "representatives_sha256": "f381bf6fdd18467318b6364e1ef6cbb5bc5dfb715055742acff2694626a03b18",
+          "structurally_merged_rows": 5974,
+          "backend_artifact_bytes": 2072190,
+          "backend_with_key_registry_bytes": 2290668,
+          "backend_with_datrie_key_index_bytes": 2185902,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9069161678324782,
+            "mean_cosine": 0.9977734249342971,
+            "p05_cosine": 0.9901206520914708,
+            "relative_l2_mean": 0.03908632558061861,
+            "relative_l2_p95": 0.14059008562937259,
+            "relative_l2_max": 0.4315264679104603,
+            "weighted_relative_l2_mean": 0.02251396925269012,
+            "weighted_relative_frobenius": 0.015610929943765554,
+            "weighted_mean_cosine": 0.9987318073693344,
+            "max_relative_norm_change": 0.010093588270012993
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9069171665107606,
+            "mean_cosine": 0.997773420022632,
+            "p05_cosine": 0.9901177184637575,
+            "relative_l2_mean": 0.03896720916489434,
+            "relative_l2_p95": 0.1405727746847956,
+            "relative_l2_max": 0.43152819830688083,
+            "weighted_relative_l2_mean": 0.022361326989332794,
+            "weighted_relative_frobenius": 0.015609563474743491,
+            "weighted_mean_cosine": 0.9987318146454679,
+            "max_relative_norm_change": 0.010100504012249704
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.005414,
+            "warm_p50_ms": 0.229429,
+            "warm_p95_ms": 0.2876559,
+            "warm_p99_ms": 0.29062972,
+            "samples_ms": [
+              0.232851,
+              0.230895,
+              0.230895,
+              0.229429,
+              0.22901,
+              0.22894,
+              0.229429,
+              0.229429,
+              0.228451,
+              0.228521,
+              0.228451,
+              0.228032,
+              0.231315,
+              0.232293,
+              0.231804,
+              0.260648,
+              0.291937,
+              0.288585,
+              0.287187,
+              0.28621,
+              0.287607,
+              0.22894,
+              0.231384,
+              0.230895,
+              0.230896,
+              0.230896,
+              0.227613,
+              0.229429,
+              0.22901,
+              0.228591,
+              0.226636,
+              0.250172,
+              0.229499,
+              0.226565,
+              0.226705,
+              0.228521,
+              0.228521,
+              0.228102,
+              0.227613,
+              0.228451
+            ],
+            "warm_rows_per_second": 2231627.2136477954
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1865424,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "d37754bf9356e1c82806b733d2f09d6fcd41d5b2725b70c407328b1a5c7fe149",
+            "table_sha256": "4bdc5394076e8f3096248d2b1217897e6d6f7716cf114cd367d91f7100a27c2d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03702052589505911,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1866274,
+          "backend_with_key_registry_bytes": 2084752,
+          "backend_with_datrie_key_index_bytes": 1979986,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999509431920363,
+            "mean_cosine": 0.9999804481517602,
+            "p05_cosine": 0.9999710753229143,
+            "relative_l2_mean": 0.006229599497413254,
+            "relative_l2_p95": 0.0076318861968173845,
+            "relative_l2_max": 0.009914014821093008,
+            "weighted_relative_l2_mean": 0.006165011200244576,
+            "weighted_relative_frobenius": 0.005943315937829566,
+            "weighted_mean_cosine": 0.9999808428943063,
+            "max_relative_norm_change": 0.002319510056391344
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.373232,
+            "warm_p50_ms": 0.1215585,
+            "warm_p95_ms": 0.12658379999999997,
+            "warm_p99_ms": 0.13713232,
+            "samples_ms": [
+              0.124876,
+              0.122502,
+              0.122013,
+              0.121524,
+              0.121593,
+              0.121175,
+              0.132489,
+              0.121105,
+              0.121593,
+              0.121594,
+              0.121663,
+              0.121594,
+              0.122013,
+              0.121663,
+              0.121594,
+              0.121593,
+              0.122013,
+              0.140101,
+              0.122013,
+              0.121524,
+              0.121524,
+              0.121524,
+              0.121524,
+              0.120616,
+              0.122082,
+              0.121594,
+              0.121105,
+              0.121105,
+              0.121524,
+              0.121035,
+              0.121524,
+              0.120127,
+              0.121524,
+              0.120057,
+              0.120685,
+              0.122083,
+              0.126273,
+              0.119778,
+              0.121174,
+              0.121105
+            ],
+            "warm_rows_per_second": 4211963.786983222
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1733494,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "d37754bf9356e1c82806b733d2f09d6fcd41d5b2725b70c407328b1a5c7fe149",
+            "table_sha256": "c0da2a861a0f3abfe145d9554c6788224135e25d085a74fa3b44f9ae9c3956c4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2033181639853865,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1734747,
+          "backend_with_key_registry_bytes": 1953225,
+          "backend_with_datrie_key_index_bytes": 1848459,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999509431920363,
+            "mean_cosine": 0.9999804481517602,
+            "p05_cosine": 0.9999710753229143,
+            "relative_l2_mean": 0.006229599497413254,
+            "relative_l2_p95": 0.0076318861968173845,
+            "relative_l2_max": 0.009914014821093008,
+            "weighted_relative_l2_mean": 0.006165011200244576,
+            "weighted_relative_frobenius": 0.005943315937829566,
+            "weighted_mean_cosine": 0.9999808428943063,
+            "max_relative_norm_change": 0.002319510056391344
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.004983,
+            "warm_p50_ms": 0.131512,
+            "warm_p95_ms": 0.13451814999999998,
+            "warm_p99_ms": 0.14703703999999998,
+            "samples_ms": [
+              0.137238,
+              0.134375,
+              0.133816,
+              0.131511,
+              0.132,
+              0.132419,
+              0.132909,
+              0.132489,
+              0.131092,
+              0.131511,
+              0.130603,
+              0.130603,
+              0.132,
+              0.131512,
+              0.131512,
+              0.131511,
+              0.153302,
+              0.132978,
+              0.132,
+              0.131511,
+              0.131511,
+              0.131512,
+              0.132,
+              0.131511,
+              0.131581,
+              0.131511,
+              0.132,
+              0.131512,
+              0.131023,
+              0.132,
+              0.131511,
+              0.131092,
+              0.131581,
+              0.131023,
+              0.131512,
+              0.130604,
+              0.130604,
+              0.132001,
+              0.132489,
+              0.131022
+            ],
+            "warm_rows_per_second": 3893180.850416692
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1733494,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "d37754bf9356e1c82806b733d2f09d6fcd41d5b2725b70c407328b1a5c7fe149",
+            "table_sha256": "c0da2a861a0f3abfe145d9554c6788224135e25d085a74fa3b44f9ae9c3956c4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2549184209201485,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1734746,
+          "backend_with_key_registry_bytes": 1953224,
+          "backend_with_datrie_key_index_bytes": 1848458,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999509431920363,
+            "mean_cosine": 0.9999804481517602,
+            "p05_cosine": 0.9999710753229143,
+            "relative_l2_mean": 0.006229599497413254,
+            "relative_l2_p95": 0.0076318861968173845,
+            "relative_l2_max": 0.009914014821093008,
+            "weighted_relative_l2_mean": 0.006165011200244576,
+            "weighted_relative_frobenius": 0.005943315937829566,
+            "weighted_mean_cosine": 0.9999808428943063,
+            "max_relative_norm_change": 0.002319510056391344
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.943523,
+            "warm_p50_ms": 0.130603,
+            "warm_p95_ms": 0.13261119999999998,
+            "warm_p99_ms": 0.14869398999999997,
+            "samples_ms": [
+              0.134933,
+              0.131022,
+              0.131511,
+              0.132489,
+              0.130603,
+              0.132419,
+              0.132489,
+              0.130604,
+              0.128788,
+              0.129626,
+              0.131022,
+              0.130114,
+              0.132489,
+              0.131511,
+              0.130603,
+              0.131092,
+              0.130533,
+              0.131022,
+              0.131022,
+              0.129136,
+              0.129625,
+              0.130603,
+              0.131092,
+              0.130603,
+              0.128299,
+              0.131512,
+              0.130603,
+              0.129137,
+              0.131023,
+              0.157492,
+              0.131511,
+              0.130184,
+              0.128718,
+              0.130533,
+              0.130533,
+              0.129066,
+              0.129067,
+              0.130045,
+              0.130534,
+              0.130604
+            ],
+            "warm_rows_per_second": 3920277.4821405327
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1733494,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "d37754bf9356e1c82806b733d2f09d6fcd41d5b2725b70c407328b1a5c7fe149",
+            "table_sha256": "c0da2a861a0f3abfe145d9554c6788224135e25d085a74fa3b44f9ae9c3956c4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22678576596081257,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1734746,
+          "backend_with_key_registry_bytes": 1953224,
+          "backend_with_datrie_key_index_bytes": 1848458,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999509431920363,
+            "mean_cosine": 0.9999804481517602,
+            "p05_cosine": 0.9999710753229143,
+            "relative_l2_mean": 0.006229599497413254,
+            "relative_l2_p95": 0.0076318861968173845,
+            "relative_l2_max": 0.009914014821093008,
+            "weighted_relative_l2_mean": 0.006165011200244576,
+            "weighted_relative_frobenius": 0.005943315937829566,
+            "weighted_mean_cosine": 0.9999808428943063,
+            "max_relative_norm_change": 0.002319510056391344
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.908043,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.1340536,
+            "warm_p99_ms": 0.15713437,
+            "samples_ms": [
+              0.137238,
+              0.133886,
+              0.131023,
+              0.131092,
+              0.130673,
+              0.130603,
+              0.132489,
+              0.131581,
+              0.131023,
+              0.132,
+              0.131022,
+              0.131092,
+              0.131511,
+              0.131022,
+              0.131092,
+              0.131581,
+              0.169855,
+              0.132908,
+              0.131511,
+              0.131023,
+              0.131511,
+              0.130184,
+              0.130604,
+              0.131511,
+              0.130533,
+              0.132489,
+              0.130114,
+              0.130115,
+              0.131581,
+              0.131511,
+              0.130534,
+              0.132978,
+              0.131511,
+              0.132489,
+              0.132909,
+              0.132908,
+              0.132489,
+              0.133397,
+              0.131511,
+              0.131022
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1185695,
+              "unique_rows": 8773,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 142,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 142,
+              "zlib_blocks": 1,
+              "xor_blocks": 141,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8773
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "e3e907c384b71e729a0aebd53e8aa9533b143e6799234253559671bd06448b98",
+            "table_sha256": "5415c8d5a573c4e941775705e851a7fda8a767b0dc3ec02bbf486f86878b986e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15289068198762834,
+          "representatives_sha256": "3f27486158efe3a45eeba191fb9fb8aa19da7dd6c9f103e6cb9c27f8bdd505d3",
+          "structurally_merged_rows": 5359,
+          "backend_artifact_bytes": 1186944,
+          "backend_with_key_registry_bytes": 1405422,
+          "backend_with_datrie_key_index_bytes": 1300656,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9898991758915479,
+            "mean_cosine": 0.9985624306039453,
+            "p05_cosine": 0.9927117436485267,
+            "relative_l2_mean": 0.034843087947229484,
+            "relative_l2_p95": 0.1208930519539888,
+            "relative_l2_max": 0.14267755652829675,
+            "weighted_relative_l2_mean": 0.022564555339120232,
+            "weighted_relative_frobenius": 0.011273324565210031,
+            "weighted_mean_cosine": 0.9992034365758994,
+            "max_relative_norm_change": 0.011073758177466862
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900036368177192,
+            "mean_cosine": 0.9985675330928376,
+            "p05_cosine": 0.9926988551751524,
+            "relative_l2_mean": 0.031079395593628233,
+            "relative_l2_p95": 0.12095334734357205,
+            "relative_l2_max": 0.14178901201605482,
+            "weighted_relative_l2_mean": 0.017956041919640616,
+            "weighted_relative_frobenius": 0.009708818886474999,
+            "weighted_mean_cosine": 0.9992134804590077,
+            "max_relative_norm_change": 0.010098292410539783
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.498517,
+            "warm_p50_ms": 0.1310225,
+            "warm_p95_ms": 0.13397345,
+            "warm_p99_ms": 0.1611877,
+            "samples_ms": [
+              0.133956,
+              0.131022,
+              0.132489,
+              0.132,
+              0.131092,
+              0.131022,
+              0.130603,
+              0.131022,
+              0.131582,
+              0.130604,
+              0.132001,
+              0.131022,
+              0.131511,
+              0.131022,
+              0.130603,
+              0.131022,
+              0.131022,
+              0.131022,
+              0.131023,
+              0.131023,
+              0.131092,
+              0.131023,
+              0.130115,
+              0.130184,
+              0.131092,
+              0.131512,
+              0.130115,
+              0.178375,
+              0.134305,
+              0.131093,
+              0.130604,
+              0.128718,
+              0.131092,
+              0.131023,
+              0.131093,
+              0.131582,
+              0.130534,
+              0.129626,
+              0.130115,
+              0.129626
+            ],
+            "warm_rows_per_second": 3907725.772291019
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1132000,
+              "unique_rows": 8284,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 134,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 134,
+              "zlib_blocks": 2,
+              "xor_blocks": 132,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8284
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "39abe9e020e0fa36b42308058b67c647fcb32b21d834148ef6c13acdb7c9e16a",
+            "table_sha256": "f5f5f8f557e088dbbaf135b2e41557587a0dc9ec9b112622b3781dd14c48e1de",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.16384774213656783,
+          "representatives_sha256": "a53571cebfc88234b2ccaf0e36f5d95fe432e78310acd13043d4bbb7b0a87159",
+          "structurally_merged_rows": 5848,
+          "backend_artifact_bytes": 1133249,
+          "backend_with_key_registry_bytes": 1351727,
+          "backend_with_datrie_key_index_bytes": 1246961,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800609363681603,
+            "mean_cosine": 0.9980835864851856,
+            "p05_cosine": 0.9907192079250814,
+            "relative_l2_mean": 0.040370998729445585,
+            "relative_l2_p95": 0.13648493463487885,
+            "relative_l2_max": 0.20040302515574998,
+            "weighted_relative_l2_mean": 0.025439388941910904,
+            "weighted_relative_frobenius": 0.012882211183388767,
+            "weighted_mean_cosine": 0.9989536429345286,
+            "max_relative_norm_change": 0.011073758177466862
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9801845112059807,
+            "mean_cosine": 0.9980874938018807,
+            "p05_cosine": 0.9906959908080297,
+            "relative_l2_mean": 0.036826332511338385,
+            "relative_l2_p95": 0.13654300595165328,
+            "relative_l2_max": 0.19979866428782744,
+            "weighted_relative_l2_mean": 0.020946080485034813,
+            "weighted_relative_frobenius": 0.011561476750624822,
+            "weighted_mean_cosine": 0.9989629229526767,
+            "max_relative_norm_change": 0.010098292410539783
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.51451,
+            "warm_p50_ms": 0.1315115,
+            "warm_p95_ms": 0.134794,
+            "warm_p99_ms": 0.15733105999999997,
+            "samples_ms": [
+              0.134794,
+              0.134794,
+              0.132978,
+              0.131022,
+              0.132419,
+              0.131581,
+              0.130604,
+              0.132001,
+              0.132978,
+              0.131022,
+              0.132489,
+              0.131093,
+              0.132489,
+              0.132,
+              0.130603,
+              0.130603,
+              0.130114,
+              0.132,
+              0.132001,
+              0.131093,
+              0.130115,
+              0.131093,
+              0.132,
+              0.132908,
+              0.131022,
+              0.17174,
+              0.131511,
+              0.132,
+              0.130604,
+              0.131512,
+              0.131023,
+              0.130534,
+              0.129626,
+              0.131511,
+              0.131022,
+              0.132419,
+              0.130603,
+              0.132,
+              0.132001,
+              0.130534
+            ],
+            "warm_rows_per_second": 3893195.6520912615
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1123444,
+              "unique_rows": 8212,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 133,
+              "zlib_blocks": 2,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8212
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "3b62dd395678f17f8a18c39bbcc08a79b7f779d435de694eb18ed31f8a82b284",
+            "table_sha256": "60cfc36ef9a1234b18bd362da8210f476392bbb9a93d239adcbd71adf575f34f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14480039989575744,
+          "representatives_sha256": "2056b5595db4696ab7f357cc3c183ee0db15737e8ff61829f7970ec4b4b78509",
+          "structurally_merged_rows": 5920,
+          "backend_artifact_bytes": 1124693,
+          "backend_with_key_registry_bytes": 1343171,
+          "backend_with_datrie_key_index_bytes": 1238405,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.970533398984063,
+            "mean_cosine": 0.9979517868279669,
+            "p05_cosine": 0.9903524458799131,
+            "relative_l2_mean": 0.04152405653797273,
+            "relative_l2_p95": 0.1389526598971901,
+            "relative_l2_max": 0.24293060424031895,
+            "weighted_relative_l2_mean": 0.02601064268249304,
+            "weighted_relative_frobenius": 0.01299657603660586,
+            "weighted_mean_cosine": 0.9988883460806876,
+            "max_relative_norm_change": 0.011073758177466862
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9706767662198073,
+            "mean_cosine": 0.9979554209545061,
+            "p05_cosine": 0.9903252160808494,
+            "relative_l2_mean": 0.03801150163211964,
+            "relative_l2_p95": 0.1392648222596999,
+            "relative_l2_max": 0.24320645540282654,
+            "weighted_relative_l2_mean": 0.02153324297460118,
+            "weighted_relative_frobenius": 0.01168888666741782,
+            "weighted_mean_cosine": 0.9988974907535848,
+            "max_relative_norm_change": 0.010098292410539783
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.394802,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.137595,
+            "warm_p99_ms": 0.16243227999999998,
+            "samples_ms": [
+              0.135702,
+              0.133885,
+              0.173137,
+              0.137169,
+              0.132489,
+              0.131162,
+              0.131511,
+              0.132,
+              0.132,
+              0.131092,
+              0.136749,
+              0.132489,
+              0.132,
+              0.131512,
+              0.132978,
+              0.131512,
+              0.131092,
+              0.132489,
+              0.132,
+              0.131582,
+              0.131022,
+              0.132,
+              0.130603,
+              0.130603,
+              0.132001,
+              0.132489,
+              0.132908,
+              0.130604,
+              0.130534,
+              0.131511,
+              0.131511,
+              0.132,
+              0.145689,
+              0.131022,
+              0.132,
+              0.130114,
+              0.131022,
+              0.132489,
+              0.131092,
+              0.133467
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1121274,
+              "unique_rows": 8192,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 132,
+              "zlib_blocks": 3,
+              "xor_blocks": 129,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8192
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "4347d36d220d562717012c8dc4185b21cde760ad2e4dceb8e1551a527efb99fd",
+            "table_sha256": "b407aa718cdc94b129f0ed927230512af321dc1c7441189ef0fcff6e9852e3f2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14451132505200803,
+          "representatives_sha256": "4295e5aa8792a9f176f49ca4cc2d2bd875799074b16a719944247ad4144fbf98",
+          "structurally_merged_rows": 5940,
+          "backend_artifact_bytes": 1122523,
+          "backend_with_key_registry_bytes": 1341001,
+          "backend_with_datrie_key_index_bytes": 1236235,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9516396125089167,
+            "mean_cosine": 0.9978860315050953,
+            "p05_cosine": 0.9902062405450521,
+            "relative_l2_mean": 0.0419809939042737,
+            "relative_l2_p95": 0.13987874549353838,
+            "relative_l2_max": 0.31107273743945374,
+            "weighted_relative_l2_mean": 0.026268627807504365,
+            "weighted_relative_frobenius": 0.013264231963570525,
+            "weighted_mean_cosine": 0.9988511739345237,
+            "max_relative_norm_change": 0.011073758177466862
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9515900745539979,
+            "mean_cosine": 0.997889624367305,
+            "p05_cosine": 0.9901928744310519,
+            "relative_l2_mean": 0.038477430801658524,
+            "relative_l2_p95": 0.14004325529443465,
+            "relative_l2_max": 0.31121001199064846,
+            "weighted_relative_l2_mean": 0.021795814636628608,
+            "weighted_relative_frobenius": 0.011985214831303536,
+            "weighted_mean_cosine": 0.9988603101202684,
+            "max_relative_norm_change": 0.010098292410539783
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.26378,
+            "warm_p50_ms": 0.132001,
+            "warm_p95_ms": 0.16930295,
+            "warm_p99_ms": 0.17228918999999998,
+            "samples_ms": [
+              0.136819,
+              0.131511,
+              0.132,
+              0.132908,
+              0.132001,
+              0.138635,
+              0.132489,
+              0.132908,
+              0.13242,
+              0.132489,
+              0.131511,
+              0.131581,
+              0.132,
+              0.131023,
+              0.132489,
+              0.130603,
+              0.132,
+              0.131022,
+              0.132001,
+              0.166572,
+              0.133467,
+              0.130115,
+              0.130185,
+              0.132001,
+              0.131093,
+              0.130045,
+              0.131022,
+              0.131581,
+              0.129625,
+              0.131022,
+              0.129625,
+              0.132489,
+              0.164686,
+              0.174114,
+              0.167409,
+              0.169435,
+              0.167479,
+              0.167968,
+              0.167898,
+              0.169296
+            ],
+            "warm_rows_per_second": 3878758.4942538314
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1119725,
+              "unique_rows": 8177,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 132,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 132,
+              "zlib_blocks": 3,
+              "xor_blocks": 129,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8177
+            },
+            "source_float32_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127",
+            "decoded_float32_sha256": "afc8defabf0539639b6ab778db34a0733084b808149cf4aad31bb6c119dcb051",
+            "table_sha256": "58f13c4ccf9ee34518a3d1139ffdae723e637f0e3aef368b40acb212c717c130",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.143010085914284,
+          "representatives_sha256": "75f0985092dacb57da3675dd32889a5eafa52457b1b4315ddd5aeffbad786241",
+          "structurally_merged_rows": 5955,
+          "backend_artifact_bytes": 1120974,
+          "backend_with_key_registry_bytes": 1339452,
+          "backend_with_datrie_key_index_bytes": 1234686,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9069200513135023,
+            "mean_cosine": 0.9977608335117717,
+            "p05_cosine": 0.9900603464531534,
+            "relative_l2_mean": 0.042584448685336854,
+            "relative_l2_p95": 0.14098517608415817,
+            "relative_l2_max": 0.4313462450471783,
+            "weighted_relative_l2_mean": 0.026923009724454265,
+            "weighted_relative_frobenius": 0.016679475285300137,
+            "weighted_mean_cosine": 0.9987163534494873,
+            "max_relative_norm_change": 0.011073758177466862
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.906865860939273,
+            "mean_cosine": 0.9977643453812376,
+            "p05_cosine": 0.99007159701529,
+            "relative_l2_mean": 0.039087591362981705,
+            "relative_l2_p95": 0.14104134847131763,
+            "relative_l2_max": 0.43140187157121745,
+            "weighted_relative_l2_mean": 0.022458199434176405,
+            "weighted_relative_frobenius": 0.015683609464981013,
+            "weighted_mean_cosine": 0.9987253930745409,
+            "max_relative_norm_change": 0.010098292410539783
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.134154,
+            "warm_p50_ms": 0.13318750000000001,
+            "warm_p95_ms": 0.1732557,
+            "warm_p99_ms": 0.17811021,
+            "samples_ms": [
+              0.135283,
+              0.134375,
+              0.132908,
+              0.132001,
+              0.133397,
+              0.132978,
+              0.132,
+              0.132489,
+              0.135422,
+              0.131581,
+              0.131511,
+              0.131511,
+              0.130045,
+              0.131023,
+              0.131512,
+              0.132001,
+              0.132489,
+              0.132,
+              0.150927,
+              0.130603,
+              0.130603,
+              0.131511,
+              0.130603,
+              0.132978,
+              0.131581,
+              0.172718,
+              0.179772,
+              0.161823,
+              0.175511,
+              0.168388,
+              0.158051,
+              0.169855,
+              0.162731,
+              0.173137,
+              0.161333,
+              0.159937,
+              0.160845,
+              0.168387,
+              0.170343,
+              0.170762
+            ],
+            "warm_rows_per_second": 3844204.5987799154
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "f52f97f6be5a5c643586efdc377a6b8e236e245f915abcc4e9dbfbb0558cd127"
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "rows": 14132,
+      "dim": 128,
+      "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+      "source_float32_bytes": 7235584,
+      "key_registry_bytes": 218478,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 113712,
+      "query_rows": 512,
+      "query_ids_sha256": "48cdbdeffaad5c50239fec7524368c85bd12fc21eefeb42effaa6c7c5ff0c323",
+      "frequency_trace_sha256": "fc8afe9c1f9a53dfd826267bdad324151b311d81a4be4e4834bd129ccf363886",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 7235584,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "table_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.041674753185361624,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 7236389,
+          "backend_with_key_registry_bytes": 7454867,
+          "backend_with_datrie_key_index_bytes": 7350101,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.376166,
+            "warm_p50_ms": 0.0600635,
+            "warm_p95_ms": 0.06112845,
+            "warm_p99_ms": 0.0615027,
+            "samples_ms": [
+              0.061041,
+              0.06146,
+              0.06153,
+              0.060553,
+              0.059574,
+              0.061041,
+              0.060552,
+              0.060552,
+              0.059086,
+              0.060623,
+              0.058667,
+              0.059644,
+              0.060552,
+              0.060552,
+              0.060552,
+              0.058667,
+              0.060902,
+              0.058736,
+              0.059574,
+              0.059226,
+              0.060064,
+              0.059645,
+              0.059155,
+              0.058666,
+              0.060064,
+              0.059645,
+              0.061041,
+              0.059994,
+              0.060133,
+              0.060063,
+              0.059645,
+              0.059575,
+              0.061111,
+              0.060064,
+              0.060133,
+              0.059574,
+              0.059155,
+              0.059575,
+              0.058667,
+              0.060622
+            ],
+            "warm_rows_per_second": 8524311.770043371
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6811178,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 50,
+              "xor_blocks": 834,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "table_sha256": "060c766f7a8ee8758960728799dc557117c3f4f33b659a2ea00bdf54a1a81e46",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6181737699080259,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6812387,
+          "backend_with_key_registry_bytes": 7030865,
+          "backend_with_datrie_key_index_bytes": 6926099,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.007952,
+            "warm_p50_ms": 0.071937,
+            "warm_p95_ms": 0.07675585,
+            "warm_p99_ms": 0.08362119,
+            "samples_ms": [
+              0.078083,
+              0.074801,
+              0.0748,
+              0.074311,
+              0.0748,
+              0.07473,
+              0.074241,
+              0.072426,
+              0.072425,
+              0.071866,
+              0.076686,
+              0.074312,
+              0.072845,
+              0.071936,
+              0.070958,
+              0.070959,
+              0.072355,
+              0.071517,
+              0.071448,
+              0.071447,
+              0.072425,
+              0.071937,
+              0.071448,
+              0.072844,
+              0.071028,
+              0.070889,
+              0.070959,
+              0.070539,
+              0.087162,
+              0.071448,
+              0.071518,
+              0.072426,
+              0.071866,
+              0.071448,
+              0.071937,
+              0.071378,
+              0.071448,
+              0.071448,
+              0.073264,
+              0.073822
+            ],
+            "warm_rows_per_second": 7117338.7825458385
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6811178,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 50,
+              "xor_blocks": 834,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "table_sha256": "060c766f7a8ee8758960728799dc557117c3f4f33b659a2ea00bdf54a1a81e46",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6556007731705904,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6812386,
+          "backend_with_key_registry_bytes": 7030864,
+          "backend_with_datrie_key_index_bytes": 6926098,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.043362,
+            "warm_p50_ms": 0.071448,
+            "warm_p95_ms": 0.07643004999999999,
+            "warm_p99_ms": 0.09962168999999998,
+            "samples_ms": [
+              0.076196,
+              0.075708,
+              0.074311,
+              0.074311,
+              0.074311,
+              0.070469,
+              0.071378,
+              0.072356,
+              0.071937,
+              0.071378,
+              0.071448,
+              0.071448,
+              0.071867,
+              0.111606,
+              0.080877,
+              0.071937,
+              0.071866,
+              0.071936,
+              0.07054,
+              0.071377,
+              0.071378,
+              0.069981,
+              0.071378,
+              0.071937,
+              0.071517,
+              0.071029,
+              0.071448,
+              0.07054,
+              0.071029,
+              0.071029,
+              0.071517,
+              0.071448,
+              0.070469,
+              0.071378,
+              0.071378,
+              0.071378,
+              0.069492,
+              0.071447,
+              0.071448,
+              0.071029
+            ],
+            "warm_rows_per_second": 7166050.834173105
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6811178,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 50,
+              "xor_blocks": 834,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "table_sha256": "060c766f7a8ee8758960728799dc557117c3f4f33b659a2ea00bdf54a1a81e46",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6131828369107097,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6812386,
+          "backend_with_key_registry_bytes": 7030864,
+          "backend_with_datrie_key_index_bytes": 6926098,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.974847,
+            "warm_p50_ms": 0.0720065,
+            "warm_p95_ms": 0.0767549,
+            "warm_p99_ms": 0.09333482999999998,
+            "samples_ms": [
+              0.076127,
+              0.075219,
+              0.076127,
+              0.072845,
+              0.073823,
+              0.073823,
+              0.078083,
+              0.076685,
+              0.076197,
+              0.075219,
+              0.075289,
+              0.0748,
+              0.073333,
+              0.071448,
+              0.071937,
+              0.071028,
+              0.071448,
+              0.07054,
+              0.072006,
+              0.071867,
+              0.103086,
+              0.071866,
+              0.071448,
+              0.069492,
+              0.073333,
+              0.073752,
+              0.073892,
+              0.072495,
+              0.071029,
+              0.072007,
+              0.071028,
+              0.071378,
+              0.070889,
+              0.071447,
+              0.0704,
+              0.071447,
+              0.071448,
+              0.071867,
+              0.073333,
+              0.071447
+            ],
+            "warm_rows_per_second": 7110469.193753342
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4292179,
+              "unique_rows": 8713,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 545,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 545,
+              "zlib_blocks": 323,
+              "xor_blocks": 222,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8713
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "2d03ab5abc18e43848f97f0c1fae076c613a04b95b258ddfaa1a91582c6e0853",
+            "table_sha256": "23201c1783f77c2e154234ee08dba949bdb115fe2e1e576121c728114f63ef07",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.43180519505403936,
+          "representatives_sha256": "1d7f2f8f770c4e64c61188f000dff74864d006900e9d8b82d4e1fe53ca787c27",
+          "structurally_merged_rows": 5419,
+          "backend_artifact_bytes": 4293386,
+          "backend_with_key_registry_bytes": 4511864,
+          "backend_with_datrie_key_index_bytes": 4407098,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900073902714597,
+            "mean_cosine": 0.9986074490701802,
+            "p05_cosine": 0.9931238826886435,
+            "relative_l2_mean": 0.03078177462642599,
+            "relative_l2_p95": 0.11744627815304662,
+            "relative_l2_max": 0.1422066988799605,
+            "weighted_relative_l2_mean": 0.017772639499589293,
+            "weighted_relative_frobenius": 0.009467831744684692,
+            "weighted_mean_cosine": 0.9992362196570699,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900073902714597,
+            "mean_cosine": 0.9986074490701802,
+            "p05_cosine": 0.9931238826886435,
+            "relative_l2_mean": 0.03078177462642599,
+            "relative_l2_p95": 0.11744627815304662,
+            "relative_l2_max": 0.1422066988799605,
+            "weighted_relative_l2_mean": 0.017772639499589293,
+            "weighted_relative_frobenius": 0.009467831744684692,
+            "weighted_mean_cosine": 0.9992362196570699,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.992051,
+            "warm_p50_ms": 0.070051,
+            "warm_p95_ms": 0.07428989999999999,
+            "warm_p99_ms": 0.08880918999999998,
+            "samples_ms": [
+              0.075219,
+              0.072426,
+              0.071448,
+              0.073333,
+              0.071936,
+              0.073333,
+              0.071937,
+              0.069562,
+              0.070051,
+              0.069562,
+              0.069492,
+              0.068584,
+              0.069073,
+              0.069003,
+              0.097498,
+              0.072356,
+              0.069562,
+              0.073333,
+              0.070959,
+              0.07047,
+              0.070051,
+              0.070889,
+              0.069981,
+              0.069562,
+              0.070051,
+              0.07005,
+              0.069562,
+              0.073682,
+              0.074241,
+              0.071936,
+              0.070051,
+              0.069981,
+              0.069073,
+              0.069562,
+              0.071518,
+              0.072006,
+              0.07047,
+              0.069562,
+              0.069981,
+              0.069562
+            ],
+            "warm_rows_per_second": 7308960.614409502
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4084875,
+              "unique_rows": 8276,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 518,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 518,
+              "zlib_blocks": 349,
+              "xor_blocks": 169,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8276
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "5916738c9930feda7070e45357cb7ba053200fced3550e1ca30fe371e1c697d4",
+            "table_sha256": "09df40dfc6fbab1b1e4094cf6d88f9cf35be5684fda4745ef9231c6a7c961073",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3878235809970647,
+          "representatives_sha256": "72bd69c0991c8f59ba0fea41d746a21d07d320e00e85dbf4053e970b62972166",
+          "structurally_merged_rows": 5856,
+          "backend_artifact_bytes": 4086082,
+          "backend_with_key_registry_bytes": 4304560,
+          "backend_with_datrie_key_index_bytes": 4199794,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800632074662583,
+            "mean_cosine": 0.9981682497466008,
+            "p05_cosine": 0.9912024672313878,
+            "relative_l2_mean": 0.03598248125019667,
+            "relative_l2_p95": 0.13290198548669502,
+            "relative_l2_max": 0.2008804026085917,
+            "weighted_relative_l2_mean": 0.020372717570488277,
+            "weighted_relative_frobenius": 0.009890047376844057,
+            "weighted_mean_cosine": 0.9990166368590908,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800632074662583,
+            "mean_cosine": 0.9981682497466008,
+            "p05_cosine": 0.9912024672313878,
+            "relative_l2_mean": 0.03598248125019667,
+            "relative_l2_p95": 0.13290198548669502,
+            "relative_l2_max": 0.2008804026085917,
+            "weighted_relative_l2_mean": 0.020372717570488277,
+            "weighted_relative_frobenius": 0.009890047376844057,
+            "weighted_mean_cosine": 0.9990166368590908,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.509378,
+            "warm_p50_ms": 0.071867,
+            "warm_p95_ms": 0.0748908,
+            "warm_p99_ms": 0.09685213999999998,
+            "samples_ms": [
+              0.0748,
+              0.072356,
+              0.076616,
+              0.073822,
+              0.073752,
+              0.073403,
+              0.072495,
+              0.071937,
+              0.072356,
+              0.074242,
+              0.070889,
+              0.070889,
+              0.070959,
+              0.071448,
+              0.071029,
+              0.068654,
+              0.072845,
+              0.10979,
+              0.070959,
+              0.069143,
+              0.071448,
+              0.072495,
+              0.070121,
+              0.072356,
+              0.073753,
+              0.073823,
+              0.071867,
+              0.07047,
+              0.072844,
+              0.069492,
+              0.07005,
+              0.073404,
+              0.069562,
+              0.07054,
+              0.073334,
+              0.071517,
+              0.071378,
+              0.071867,
+              0.068654,
+              0.070959
+            ],
+            "warm_rows_per_second": 7124271.223231804
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4048616,
+              "unique_rows": 8201,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 513,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 513,
+              "zlib_blocks": 347,
+              "xor_blocks": 166,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8201
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "5f22f7b5a51b64103430e36ba1d0bd54077ea2f16d3d4bb871f51692d993995b",
+            "table_sha256": "30cde4f7eec3681cc425eaa499f2a58de9ef5c1aba06a07878c0e60893e2474a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36942198988981545,
+          "representatives_sha256": "c3f844016d2aa27522f40276a4692138cf6475e2ba2a582770bdaa8120ca3584",
+          "structurally_merged_rows": 5931,
+          "backend_artifact_bytes": 4049823,
+          "backend_with_key_registry_bytes": 4268301,
+          "backend_with_datrie_key_index_bytes": 4163535,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9702642593028836,
+            "mean_cosine": 0.9980366950229913,
+            "p05_cosine": 0.9907400526112273,
+            "relative_l2_mean": 0.03717392426551632,
+            "relative_l2_p95": 0.13639079380091268,
+            "relative_l2_max": 0.24371533510351767,
+            "weighted_relative_l2_mean": 0.021110074541361344,
+            "weighted_relative_frobenius": 0.011079169105965923,
+            "weighted_mean_cosine": 0.9989359764157608,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9702642593028836,
+            "mean_cosine": 0.9980366950229913,
+            "p05_cosine": 0.9907400526112273,
+            "relative_l2_mean": 0.03717392426551632,
+            "relative_l2_p95": 0.13639079380091268,
+            "relative_l2_max": 0.24371533510351767,
+            "weighted_relative_l2_mean": 0.021110074541361344,
+            "weighted_relative_frobenius": 0.011079169105965923,
+            "weighted_mean_cosine": 0.9989359764157608,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.472502,
+            "warm_p50_ms": 0.071238,
+            "warm_p95_ms": 0.0781109,
+            "warm_p99_ms": 0.09069825999999999,
+            "samples_ms": [
+              0.077664,
+              0.07515,
+              0.073822,
+              0.073822,
+              0.074311,
+              0.074241,
+              0.078641,
+              0.078083,
+              0.076616,
+              0.075708,
+              0.073334,
+              0.073333,
+              0.073333,
+              0.073333,
+              0.070958,
+              0.070959,
+              0.069143,
+              0.071099,
+              0.070958,
+              0.069003,
+              0.071377,
+              0.0704,
+              0.070958,
+              0.069143,
+              0.069003,
+              0.069073,
+              0.069073,
+              0.069492,
+              0.070889,
+              0.069981,
+              0.07047,
+              0.068654,
+              0.071377,
+              0.071448,
+              0.098407,
+              0.076127,
+              0.071029,
+              0.071448,
+              0.069562,
+              0.07047
+            ],
+            "warm_rows_per_second": 7187175.38392431
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4040206,
+              "unique_rows": 8184,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 512,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 512,
+              "zlib_blocks": 347,
+              "xor_blocks": 165,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8184
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "0a25021ff9755d6ad9e840fc6b37e339f7a014b5c331461e8c1dcf795e1e6faa",
+            "table_sha256": "d72869d2e1b2e4da739889e6b88f84e95469d18ea8870256037ff8ab9036f8c1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3716650858987123,
+          "representatives_sha256": "f3d6c5e68e2b580f8aad1c18eb930cf5258ab8e22f7c62d2c60eef9f4fade95b",
+          "structurally_merged_rows": 5948,
+          "backend_artifact_bytes": 4041413,
+          "backend_with_key_registry_bytes": 4259891,
+          "backend_with_datrie_key_index_bytes": 4155125,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9525588782396796,
+            "mean_cosine": 0.9979672603102632,
+            "p05_cosine": 0.9905287290957443,
+            "relative_l2_mean": 0.03764276506627799,
+            "relative_l2_p95": 0.13752160879166392,
+            "relative_l2_max": 0.30795876807260114,
+            "weighted_relative_l2_mean": 0.02143238962795817,
+            "weighted_relative_frobenius": 0.011613642395987852,
+            "weighted_mean_cosine": 0.998888214039435,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9525588782396796,
+            "mean_cosine": 0.9979672603102632,
+            "p05_cosine": 0.9905287290957443,
+            "relative_l2_mean": 0.03764276506627799,
+            "relative_l2_p95": 0.13752160879166392,
+            "relative_l2_max": 0.30795876807260114,
+            "weighted_relative_l2_mean": 0.02143238962795817,
+            "weighted_relative_frobenius": 0.011613642395987852,
+            "weighted_mean_cosine": 0.998888214039435,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.799847,
+            "warm_p50_ms": 0.069632,
+            "warm_p95_ms": 0.07457274999999998,
+            "warm_p99_ms": 0.09271976,
+            "samples_ms": [
+              0.080876,
+              0.074241,
+              0.073822,
+              0.073822,
+              0.071517,
+              0.071448,
+              0.071937,
+              0.071518,
+              0.071936,
+              0.071518,
+              0.071518,
+              0.073333,
+              0.071028,
+              0.071518,
+              0.068585,
+              0.068584,
+              0.070121,
+              0.068584,
+              0.069981,
+              0.069073,
+              0.069492,
+              0.100292,
+              0.070121,
+              0.069562,
+              0.067188,
+              0.069632,
+              0.071378,
+              0.068584,
+              0.069143,
+              0.067117,
+              0.069562,
+              0.069143,
+              0.068096,
+              0.069632,
+              0.069073,
+              0.068515,
+              0.068235,
+              0.067607,
+              0.069143,
+              0.068584
+            ],
+            "warm_rows_per_second": 7352941.176470588
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4041132,
+              "unique_rows": 8184,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 512,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 512,
+              "zlib_blocks": 351,
+              "xor_blocks": 161,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8184
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "98ea4d2f169a39f18f9b142b2ee0f1c3d79c8f9e3707ae76cac857f39ff8023b",
+            "table_sha256": "781e5ddb46a92bd848dc486bfb3d94d6eef253f1674f0a87584e114cd9483b9a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3834197339601815,
+          "representatives_sha256": "a9165656a314128de8ba2f8a95e95db533045e89eeda35bd848291a47b1ac5ab",
+          "structurally_merged_rows": 5948,
+          "backend_artifact_bytes": 4042339,
+          "backend_with_key_registry_bytes": 4260817,
+          "backend_with_datrie_key_index_bytes": 4156051,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9013500902532418,
+            "mean_cosine": 0.9978668806757741,
+            "p05_cosine": 0.9904035009451494,
+            "relative_l2_mean": 0.03808442010560562,
+            "relative_l2_p95": 0.1386711610756497,
+            "relative_l2_max": 0.4454053094763166,
+            "weighted_relative_l2_mean": 0.021717454181962366,
+            "weighted_relative_frobenius": 0.012749720608418173,
+            "weighted_mean_cosine": 0.9988267853378323,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9013500902532418,
+            "mean_cosine": 0.9978668806757741,
+            "p05_cosine": 0.9904035009451494,
+            "relative_l2_mean": 0.03808442010560562,
+            "relative_l2_p95": 0.1386711610756497,
+            "relative_l2_max": 0.4454053094763166,
+            "weighted_relative_l2_mean": 0.021717454181962366,
+            "weighted_relative_frobenius": 0.012749720608418173,
+            "weighted_mean_cosine": 0.9988267853378323,
+            "max_relative_norm_change": 0.010097972516154134
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.586971,
+            "warm_p50_ms": 0.0695965,
+            "warm_p95_ms": 0.07293929999999998,
+            "warm_p99_ms": 0.07592355,
+            "samples_ms": [
+              0.076686,
+              0.074731,
+              0.072845,
+              0.071937,
+              0.071447,
+              0.071867,
+              0.069562,
+              0.069632,
+              0.069981,
+              0.07054,
+              0.069143,
+              0.070051,
+              0.071447,
+              0.070051,
+              0.068515,
+              0.069632,
+              0.069562,
+              0.069492,
+              0.070051,
+              0.068584,
+              0.069073,
+              0.069631,
+              0.069562,
+              0.069073,
+              0.069074,
+              0.070051,
+              0.070051,
+              0.069911,
+              0.070959,
+              0.068723,
+              0.069492,
+              0.068584,
+              0.069143,
+              0.069562,
+              0.069562,
+              0.069143,
+              0.069562,
+              0.069562,
+              0.069562,
+              0.069632
+            ],
+            "warm_rows_per_second": 7356691.787661735
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3617792,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "a6f992eab989830921c022ff3d6f88caceeb1eeebe107b7ccc88caeb09e9ca68",
+            "table_sha256": "c09228c734adcadf26af9e437aa54e9dbbc0d275c3c2a829e871216873acebd6",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.04507679585367441,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3618598,
+          "backend_with_key_registry_bytes": 3837076,
+          "backend_with_datrie_key_index_bytes": 3732310,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999640630156,
+            "mean_cosine": 0.9999999789175185,
+            "p05_cosine": 0.9999999730721181,
+            "relative_l2_mean": 0.0002070676065899127,
+            "relative_l2_p95": 0.00023440921164902042,
+            "relative_l2_max": 0.00027016899099782454,
+            "weighted_relative_l2_mean": 0.0002072185978470986,
+            "weighted_relative_frobenius": 0.00020769691233671656,
+            "weighted_mean_cosine": 0.9999999788781782,
+            "max_relative_norm_change": 0.00012017913339375236
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.50195,
+            "warm_p50_ms": 0.22,
+            "warm_p95_ms": 0.22368454999999998,
+            "warm_p99_ms": 0.24720571999999996,
+            "samples_ms": [
+              0.223283,
+              0.222375,
+              0.22,
+              0.220489,
+              0.220908,
+              0.22049,
+              0.220978,
+              0.219511,
+              0.22,
+              0.257366,
+              0.223283,
+              0.22,
+              0.219511,
+              0.22007,
+              0.219582,
+              0.221467,
+              0.219581,
+              0.220419,
+              0.219581,
+              0.219162,
+              0.219511,
+              0.218533,
+              0.219511,
+              0.219511,
+              0.219581,
+              0.219022,
+              0.231314,
+              0.21993,
+              0.221327,
+              0.22042,
+              0.21993,
+              0.21993,
+              0.221397,
+              0.220839,
+              0.220489,
+              0.219023,
+              0.220419,
+              0.219022,
+              0.220978,
+              0.219511
+            ],
+            "warm_rows_per_second": 2327272.727272727
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406703,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "a6f992eab989830921c022ff3d6f88caceeb1eeebe107b7ccc88caeb09e9ca68",
+            "table_sha256": "bbaaa5100062ad8592fd8c4f376ec4ec38424253a6c1bee0d0f21c18ec923b04",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36845126608386636,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407912,
+          "backend_with_key_registry_bytes": 3626390,
+          "backend_with_datrie_key_index_bytes": 3521624,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999640630156,
+            "mean_cosine": 0.9999999789175185,
+            "p05_cosine": 0.9999999730721181,
+            "relative_l2_mean": 0.0002070676065899127,
+            "relative_l2_p95": 0.00023440921164902042,
+            "relative_l2_max": 0.00027016899099782454,
+            "weighted_relative_l2_mean": 0.0002072185978470986,
+            "weighted_relative_frobenius": 0.00020769691233671656,
+            "weighted_mean_cosine": 0.9999999788781782,
+            "max_relative_norm_change": 0.00012017913339375236
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.788172,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.24352324999999997,
+            "warm_p99_ms": 0.26475615,
+            "samples_ms": [
+              0.232292,
+              0.229498,
+              0.229429,
+              0.229988,
+              0.230406,
+              0.22901,
+              0.229918,
+              0.228521,
+              0.228521,
+              0.229499,
+              0.228521,
+              0.229079,
+              0.22901,
+              0.228032,
+              0.242769,
+              0.229918,
+              0.227613,
+              0.22859,
+              0.228102,
+              0.22894,
+              0.228521,
+              0.228032,
+              0.228521,
+              0.227962,
+              0.269169,
+              0.257854,
+              0.231384,
+              0.229499,
+              0.228102,
+              0.22901,
+              0.22859,
+              0.241721,
+              0.229848,
+              0.228521,
+              0.227054,
+              0.227473,
+              0.230825,
+              0.232781,
+              0.230476,
+              0.22901
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406703,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "a6f992eab989830921c022ff3d6f88caceeb1eeebe107b7ccc88caeb09e9ca68",
+            "table_sha256": "bbaaa5100062ad8592fd8c4f376ec4ec38424253a6c1bee0d0f21c18ec923b04",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4048690621275455,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407911,
+          "backend_with_key_registry_bytes": 3626389,
+          "backend_with_datrie_key_index_bytes": 3521623,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999640630156,
+            "mean_cosine": 0.9999999789175185,
+            "p05_cosine": 0.9999999730721181,
+            "relative_l2_mean": 0.0002070676065899127,
+            "relative_l2_p95": 0.00023440921164902042,
+            "relative_l2_max": 0.00027016899099782454,
+            "weighted_relative_l2_mean": 0.0002072185978470986,
+            "weighted_relative_frobenius": 0.00020769691233671656,
+            "weighted_mean_cosine": 0.9999999788781782,
+            "max_relative_norm_change": 0.00012017913339375236
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.780699,
+            "warm_p50_ms": 0.22901,
+            "warm_p95_ms": 0.23269805,
+            "warm_p99_ms": 0.240394,
+            "samples_ms": [
+              0.232293,
+              0.230896,
+              0.229429,
+              0.22894,
+              0.22894,
+              0.230406,
+              0.229918,
+              0.22901,
+              0.229079,
+              0.229429,
+              0.229009,
+              0.240394,
+              0.230337,
+              0.22901,
+              0.229499,
+              0.229429,
+              0.229918,
+              0.22852,
+              0.228521,
+              0.229428,
+              0.228521,
+              0.227055,
+              0.229499,
+              0.228032,
+              0.228102,
+              0.228521,
+              0.22894,
+              0.230406,
+              0.240394,
+              0.229987,
+              0.22901,
+              0.228102,
+              0.22901,
+              0.22901,
+              0.228102,
+              0.227544,
+              0.228102,
+              0.227613,
+              0.228032,
+              0.22901
+            ],
+            "warm_rows_per_second": 2235710.2309942795
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3406703,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "a6f992eab989830921c022ff3d6f88caceeb1eeebe107b7ccc88caeb09e9ca68",
+            "table_sha256": "bbaaa5100062ad8592fd8c4f376ec4ec38424253a6c1bee0d0f21c18ec923b04",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.355561135802418,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3407911,
+          "backend_with_key_registry_bytes": 3626389,
+          "backend_with_datrie_key_index_bytes": 3521623,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999640630156,
+            "mean_cosine": 0.9999999789175185,
+            "p05_cosine": 0.9999999730721181,
+            "relative_l2_mean": 0.0002070676065899127,
+            "relative_l2_p95": 0.00023440921164902042,
+            "relative_l2_max": 0.00027016899099782454,
+            "weighted_relative_l2_mean": 0.0002072185978470986,
+            "weighted_relative_frobenius": 0.00020769691233671656,
+            "weighted_mean_cosine": 0.9999999788781782,
+            "max_relative_norm_change": 0.00012017913339375236
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.768897,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.23302279999999997,
+            "warm_p99_ms": 0.25111152999999997,
+            "samples_ms": [
+              0.232292,
+              0.229918,
+              0.22894,
+              0.227613,
+              0.228451,
+              0.229918,
+              0.229987,
+              0.229499,
+              0.258901,
+              0.232712,
+              0.229499,
+              0.227543,
+              0.229499,
+              0.228451,
+              0.229918,
+              0.229428,
+              0.228451,
+              0.228451,
+              0.228032,
+              0.228521,
+              0.228521,
+              0.228032,
+              0.229917,
+              0.229429,
+              0.22894,
+              0.238928,
+              0.229499,
+              0.228521,
+              0.228102,
+              0.228102,
+              0.227613,
+              0.228032,
+              0.227543,
+              0.228032,
+              0.228521,
+              0.228521,
+              0.230337,
+              0.230407,
+              0.228032,
+              0.228032
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2200767,
+              "unique_rows": 8712,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 273,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 273,
+              "zlib_blocks": 94,
+              "xor_blocks": 179,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8712
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "5f413487c622272d106a2c2cab4f0e33aba0c3ac98cdd387f6108039590b87ab",
+            "table_sha256": "7f973406674ef8687231a08ac83888ca6646e820ad3ecc4feb20a5a423bfd705",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23608402512036264,
+          "representatives_sha256": "62dc9fb389433ccc5a4329644837c182debd5b33f93e5610c8fed98ee5ca79f3",
+          "structurally_merged_rows": 5420,
+          "backend_artifact_bytes": 2201973,
+          "backend_with_key_registry_bytes": 2420451,
+          "backend_with_datrie_key_index_bytes": 2315685,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900110734293337,
+            "mean_cosine": 0.9986071040782484,
+            "p05_cosine": 0.9931201421840856,
+            "relative_l2_mean": 0.030916340295123496,
+            "relative_l2_p95": 0.11753606067533086,
+            "relative_l2_max": 0.1422308437423335,
+            "weighted_relative_l2_mean": 0.01793043618905993,
+            "weighted_relative_frobenius": 0.009470324713106664,
+            "weighted_mean_cosine": 0.9992361701290867,
+            "max_relative_norm_change": 0.010145610590708034
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900126948932569,
+            "mean_cosine": 0.9986071142742591,
+            "p05_cosine": 0.9931205884476864,
+            "relative_l2_mean": 0.03078874727222894,
+            "relative_l2_p95": 0.11754071778511165,
+            "relative_l2_max": 0.14223837458838182,
+            "weighted_relative_l2_mean": 0.01777303897196514,
+            "weighted_relative_frobenius": 0.009468034050420173,
+            "weighted_mean_cosine": 0.9992361850915106,
+            "max_relative_norm_change": 0.010095191189280194
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.23149,
+            "warm_p50_ms": 0.227962,
+            "warm_p95_ms": 0.25880719999999996,
+            "warm_p99_ms": 0.29290325,
+            "samples_ms": [
+              0.231384,
+              0.230407,
+              0.22901,
+              0.228521,
+              0.227962,
+              0.22901,
+              0.232293,
+              0.228102,
+              0.245981,
+              0.230406,
+              0.227962,
+              0.226635,
+              0.227613,
+              0.228102,
+              0.226635,
+              0.226985,
+              0.227055,
+              0.227124,
+              0.227613,
+              0.226216,
+              0.226636,
+              0.228032,
+              0.226635,
+              0.228102,
+              0.226636,
+              0.228102,
+              0.257784,
+              0.226635,
+              0.227194,
+              0.227613,
+              0.227473,
+              0.227054,
+              0.226635,
+              0.227612,
+              0.226146,
+              0.302273,
+              0.278248,
+              0.234737,
+              0.228451,
+              0.22894
+            ],
+            "warm_rows_per_second": 2245988.366482133
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2099636,
+              "unique_rows": 8277,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 259,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 259,
+              "zlib_blocks": 110,
+              "xor_blocks": 149,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8277
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "bbf09843f09d773ec55ec2f2a8eb50bbbe9822cf7bd8768a38d0beebb8e76d63",
+            "table_sha256": "a3fc9dde46ac640d4297c0ae901ee7e9a64252dc41af16e982523e999d8412b3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22631070506758988,
+          "representatives_sha256": "1aa39d9c2a2cba69776ee123ef0a337f933d44e3a82a1a8d36ee472a12a47b61",
+          "structurally_merged_rows": 5855,
+          "backend_artifact_bytes": 2100843,
+          "backend_with_key_registry_bytes": 2319321,
+          "backend_with_datrie_key_index_bytes": 2214555,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800635154178402,
+            "mean_cosine": 0.9981698821459642,
+            "p05_cosine": 0.9912050222029035,
+            "relative_l2_mean": 0.03608720743827846,
+            "relative_l2_p95": 0.13281078096026844,
+            "relative_l2_max": 0.20087697063823262,
+            "weighted_relative_l2_mean": 0.020515703015552056,
+            "weighted_relative_frobenius": 0.009891052383337548,
+            "weighted_mean_cosine": 0.9990175669350744,
+            "max_relative_norm_change": 0.010145610590708034
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800675682083074,
+            "mean_cosine": 0.9981698900290342,
+            "p05_cosine": 0.9912022668645663,
+            "relative_l2_mean": 0.03596599927953503,
+            "relative_l2_p95": 0.13279856767887474,
+            "relative_l2_max": 0.20085791728800229,
+            "weighted_relative_l2_mean": 0.020361497298607506,
+            "weighted_relative_frobenius": 0.009888866721531615,
+            "weighted_mean_cosine": 0.9990175807324861,
+            "max_relative_norm_change": 0.010095191189280194
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.294417,
+            "warm_p50_ms": 0.22900949999999998,
+            "warm_p95_ms": 0.23516634999999997,
+            "warm_p99_ms": 0.25411205,
+            "samples_ms": [
+              0.234667,
+              0.231385,
+              0.231385,
+              0.22894,
+              0.228381,
+              0.231315,
+              0.244654,
+              0.229987,
+              0.230407,
+              0.228521,
+              0.229917,
+              0.228521,
+              0.229009,
+              0.228451,
+              0.22852,
+              0.228521,
+              0.228032,
+              0.22901,
+              0.22901,
+              0.229429,
+              0.228521,
+              0.228451,
+              0.22901,
+              0.260159,
+              0.232292,
+              0.229499,
+              0.229499,
+              0.229499,
+              0.22852,
+              0.230896,
+              0.22894,
+              0.228521,
+              0.228032,
+              0.22894,
+              0.22887,
+              0.228521,
+              0.228521,
+              0.228032,
+              0.233689,
+              0.23327
+            ],
+            "warm_rows_per_second": 2235715.1122551686
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2081919,
+              "unique_rows": 8202,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 257,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 257,
+              "zlib_blocks": 120,
+              "xor_blocks": 137,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8202
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "64effdba1d8d0a799adf2c143fa824c2282ee666d273bd20d4f6ce45b99d8f39",
+            "table_sha256": "eb149d4b44386cb212e5ec282c6ce92d914fe535222031a1cd0bdb868608aa12",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23895569099113345,
+          "representatives_sha256": "6bc853a79cffddff151595a7bcea1ed7bf384365d40cb19dbb15de973141547f",
+          "structurally_merged_rows": 5930,
+          "backend_artifact_bytes": 2083126,
+          "backend_with_key_registry_bytes": 2301604,
+          "backend_with_datrie_key_index_bytes": 2196838,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9702653636864929,
+            "mean_cosine": 0.9980383303992661,
+            "p05_cosine": 0.990743200733894,
+            "relative_l2_mean": 0.03727752367335026,
+            "relative_l2_p95": 0.13636840106871834,
+            "relative_l2_max": 0.24369412042518732,
+            "weighted_relative_l2_mean": 0.02125235802853126,
+            "weighted_relative_frobenius": 0.011080112730047647,
+            "weighted_mean_cosine": 0.9989369076135723,
+            "max_relative_norm_change": 0.010145610590708034
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9702650416300592,
+            "mean_cosine": 0.998038341143016,
+            "p05_cosine": 0.990743685168674,
+            "relative_l2_mean": 0.03715741640787692,
+            "relative_l2_p95": 0.13636450062101535,
+            "relative_l2_max": 0.24366716403651428,
+            "weighted_relative_l2_mean": 0.021098848735033624,
+            "weighted_relative_frobenius": 0.011078245050048044,
+            "weighted_mean_cosine": 0.9989369217639886,
+            "max_relative_norm_change": 0.010095191189280194
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.635814,
+            "warm_p50_ms": 0.228102,
+            "warm_p95_ms": 0.24332764999999998,
+            "warm_p99_ms": 0.25433129,
+            "samples_ms": [
+              0.232292,
+              0.22901,
+              0.229918,
+              0.243188,
+              0.231384,
+              0.229918,
+              0.227962,
+              0.22894,
+              0.227054,
+              0.228521,
+              0.229009,
+              0.228032,
+              0.228521,
+              0.228102,
+              0.227124,
+              0.227613,
+              0.228521,
+              0.228102,
+              0.228033,
+              0.228032,
+              0.227543,
+              0.25967,
+              0.231803,
+              0.229429,
+              0.228102,
+              0.228102,
+              0.227963,
+              0.226146,
+              0.228521,
+              0.228032,
+              0.227962,
+              0.228102,
+              0.226147,
+              0.227124,
+              0.228032,
+              0.226566,
+              0.228451,
+              0.227124,
+              0.245981,
+              0.229009
+            ],
+            "warm_rows_per_second": 2244609.86751541
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2077788,
+              "unique_rows": 8185,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 256,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 256,
+              "zlib_blocks": 125,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8185
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "288ae047d4a3ea025f53271f67a80e7c1a9c12fcf36187b3282ce05b4d951009",
+            "table_sha256": "b9fb0439ad88f608319495e30d8c80a65d401bd39dbb59060475c702110aa3db",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22219355800189078,
+          "representatives_sha256": "f037f27f7c62814c89f5cc44386f0e0757a3e83e41b2187d71bbab635d4cd0f1",
+          "structurally_merged_rows": 5947,
+          "backend_artifact_bytes": 2078995,
+          "backend_with_key_registry_bytes": 2297473,
+          "backend_with_datrie_key_index_bytes": 2192707,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9525649397506648,
+            "mean_cosine": 0.99796889285962,
+            "p05_cosine": 0.9905429346239615,
+            "relative_l2_mean": 0.037746117319474796,
+            "relative_l2_p95": 0.1374701495888191,
+            "relative_l2_max": 0.30793962720557705,
+            "weighted_relative_l2_mean": 0.02157451567575557,
+            "weighted_relative_frobenius": 0.01161458655939185,
+            "weighted_mean_cosine": 0.9988891428632327,
+            "max_relative_norm_change": 0.010145610590708034
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9525649504335991,
+            "mean_cosine": 0.9979689029929782,
+            "p05_cosine": 0.9905451002882296,
+            "relative_l2_mean": 0.03762625099845266,
+            "relative_l2_p95": 0.137479103212657,
+            "relative_l2_max": 0.3079354221985442,
+            "weighted_relative_l2_mean": 0.02142115707058293,
+            "weighted_relative_frobenius": 0.01161280946049565,
+            "weighted_mean_cosine": 0.9988891564634181,
+            "max_relative_norm_change": 0.010095191189280194
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.957991,
+            "warm_p50_ms": 0.22845149999999997,
+            "warm_p95_ms": 0.23942624999999998,
+            "warm_p99_ms": 0.25373486,
+            "samples_ms": [
+              0.250242,
+              0.232292,
+              0.229918,
+              0.22894,
+              0.22859,
+              0.22901,
+              0.22901,
+              0.227613,
+              0.228102,
+              0.226566,
+              0.22894,
+              0.228452,
+              0.228032,
+              0.228451,
+              0.228451,
+              0.22894,
+              0.228521,
+              0.238857,
+              0.22894,
+              0.22908,
+              0.227613,
+              0.227055,
+              0.227543,
+              0.22894,
+              0.227543,
+              0.228032,
+              0.228521,
+              0.227543,
+              0.228102,
+              0.227613,
+              0.228521,
+              0.228032,
+              0.228591,
+              0.227543,
+              0.255968,
+              0.23327,
+              0.228451,
+              0.227613,
+              0.226635,
+              0.227194
+            ],
+            "warm_rows_per_second": 2241175.9169889456
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2077748,
+              "unique_rows": 8185,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 256,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 256,
+              "zlib_blocks": 117,
+              "xor_blocks": 139,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8185
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "d782d297b88e05e492b1903221756f73f25f26fd7a54f257605ea56912bea425",
+            "table_sha256": "d216072fb926e7f2af7600afb31c08323f57ad2822306d0f0a4c2903061c3b87",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2176839008461684,
+          "representatives_sha256": "f52343d6608456aeae58f0697a7c8302e5f9edbd616cce35edc842bb80d63f3c",
+          "structurally_merged_rows": 5947,
+          "backend_artifact_bytes": 2078955,
+          "backend_with_key_registry_bytes": 2297433,
+          "backend_with_datrie_key_index_bytes": 2192667,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9013593202834985,
+            "mean_cosine": 0.9978685166873792,
+            "p05_cosine": 0.9904298560601507,
+            "relative_l2_mean": 0.03818776739965724,
+            "relative_l2_p95": 0.1385518535656877,
+            "relative_l2_max": 0.4453821744456762,
+            "weighted_relative_l2_mean": 0.021859553974485434,
+            "weighted_relative_frobenius": 0.012750560790134983,
+            "weighted_mean_cosine": 0.9988277159065638,
+            "max_relative_norm_change": 0.010145610590708034
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9013408026498358,
+            "mean_cosine": 0.9978685267190944,
+            "p05_cosine": 0.9904296759069757,
+            "relative_l2_mean": 0.03806790055133203,
+            "relative_l2_p95": 0.1385533654179914,
+            "relative_l2_max": 0.445427766006183,
+            "weighted_relative_l2_mean": 0.021706219190303095,
+            "weighted_relative_frobenius": 0.012748906955825902,
+            "weighted_mean_cosine": 0.9988277296235697,
+            "max_relative_norm_change": 0.010095191189280194
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.071623,
+            "warm_p50_ms": 0.228032,
+            "warm_p95_ms": 0.23221234999999996,
+            "warm_p99_ms": 0.24245207,
+            "samples_ms": [
+              0.231734,
+              0.230407,
+              0.228521,
+              0.228521,
+              0.227613,
+              0.228032,
+              0.229499,
+              0.228521,
+              0.22894,
+              0.227125,
+              0.228521,
+              0.227194,
+              0.241301,
+              0.228032,
+              0.227543,
+              0.228102,
+              0.228032,
+              0.227194,
+              0.227124,
+              0.227962,
+              0.228521,
+              0.228521,
+              0.227054,
+              0.228033,
+              0.228102,
+              0.227124,
+              0.227613,
+              0.228102,
+              0.227613,
+              0.227055,
+              0.243188,
+              0.228032,
+              0.228032,
+              0.227613,
+              0.228591,
+              0.228032,
+              0.22852,
+              0.226635,
+              0.226565,
+              0.227473
+            ],
+            "warm_rows_per_second": 2245298.9054167834
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1865424,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "f74165bb32ed3307f423ea4917e648ddb56eef15fa4521f69fd6f16fc3599f66",
+            "table_sha256": "0e2bdbfbc8dca09e94a85dd1f3349a0af8a377df57076f698fe6ceb081197dee",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.036789210978895426,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1866274,
+          "backend_with_key_registry_bytes": 2084752,
+          "backend_with_datrie_key_index_bytes": 1979986,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999471589781962,
+            "mean_cosine": 0.9999794823547403,
+            "p05_cosine": 0.9999697795998994,
+            "relative_l2_mean": 0.0063798520701271065,
+            "relative_l2_p95": 0.007798429717370971,
+            "relative_l2_max": 0.010301694004383433,
+            "weighted_relative_l2_mean": 0.006459010216051861,
+            "weighted_relative_frobenius": 0.0066886524797597335,
+            "weighted_mean_cosine": 0.9999789761503499,
+            "max_relative_norm_change": 0.002403168609907241
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.363315,
+            "warm_p50_ms": 0.121838,
+            "warm_p95_ms": 0.123968,
+            "warm_p99_ms": 0.13491749999999997,
+            "samples_ms": [
+              0.12341,
+              0.12348,
+              0.121244,
+              0.121245,
+              0.121663,
+              0.123968,
+              0.122502,
+              0.122502,
+              0.121035,
+              0.123549,
+              0.122642,
+              0.12348,
+              0.122502,
+              0.123968,
+              0.12299,
+              0.122502,
+              0.123061,
+              0.122571,
+              0.122571,
+              0.122013,
+              0.120616,
+              0.121035,
+              0.121035,
+              0.121524,
+              0.122013,
+              0.121105,
+              0.121105,
+              0.121105,
+              0.141918,
+              0.120266,
+              0.121105,
+              0.121524,
+              0.121524,
+              0.120686,
+              0.122152,
+              0.120267,
+              0.120616,
+              0.120616,
+              0.122571,
+              0.120756
+            ],
+            "warm_rows_per_second": 4202301.416635204
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1726950,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "f74165bb32ed3307f423ea4917e648ddb56eef15fa4521f69fd6f16fc3599f66",
+            "table_sha256": "e3c61a84ae42232b395b0aec70a7cd0bae29d2b67c4f706876b2204483fc318d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20328680495731533,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1728203,
+          "backend_with_key_registry_bytes": 1946681,
+          "backend_with_datrie_key_index_bytes": 1841915,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999471589781962,
+            "mean_cosine": 0.9999794823547403,
+            "p05_cosine": 0.9999697795998994,
+            "relative_l2_mean": 0.0063798520701271065,
+            "relative_l2_p95": 0.007798429717370971,
+            "relative_l2_max": 0.010301694004383433,
+            "weighted_relative_l2_mean": 0.006459010216051861,
+            "weighted_relative_frobenius": 0.0066886524797597335,
+            "weighted_mean_cosine": 0.9999789761503499,
+            "max_relative_norm_change": 0.002403168609907241
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.94925,
+            "warm_p50_ms": 0.1317905,
+            "warm_p95_ms": 0.13938575,
+            "warm_p99_ms": 0.14598729000000002,
+            "samples_ms": [
+              0.139054,
+              0.132978,
+              0.134933,
+              0.132489,
+              0.132489,
+              0.132978,
+              0.132419,
+              0.131023,
+              0.131512,
+              0.146178,
+              0.133955,
+              0.132908,
+              0.129625,
+              0.131022,
+              0.131092,
+              0.130114,
+              0.131022,
+              0.133397,
+              0.132,
+              0.132,
+              0.132,
+              0.130114,
+              0.130114,
+              0.132,
+              0.131581,
+              0.131512,
+              0.131512,
+              0.131023,
+              0.132,
+              0.131511,
+              0.132419,
+              0.130603,
+              0.130604,
+              0.132,
+              0.131581,
+              0.130533,
+              0.131092,
+              0.131022,
+              0.132001,
+              0.145689
+            ],
+            "warm_rows_per_second": 3884953.771326461
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1726950,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "f74165bb32ed3307f423ea4917e648ddb56eef15fa4521f69fd6f16fc3599f66",
+            "table_sha256": "e3c61a84ae42232b395b0aec70a7cd0bae29d2b67c4f706876b2204483fc318d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24753053300082684,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1728202,
+          "backend_with_key_registry_bytes": 1946680,
+          "backend_with_datrie_key_index_bytes": 1841914,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999471589781962,
+            "mean_cosine": 0.9999794823547403,
+            "p05_cosine": 0.9999697795998994,
+            "relative_l2_mean": 0.0063798520701271065,
+            "relative_l2_p95": 0.007798429717370971,
+            "relative_l2_max": 0.010301694004383433,
+            "weighted_relative_l2_mean": 0.006459010216051861,
+            "weighted_relative_frobenius": 0.0066886524797597335,
+            "weighted_mean_cosine": 0.9999789761503499,
+            "max_relative_norm_change": 0.002403168609907241
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.922221,
+            "warm_p50_ms": 0.1315115,
+            "warm_p95_ms": 0.1354263,
+            "warm_p99_ms": 0.15232642,
+            "samples_ms": [
+              0.136819,
+              0.134374,
+              0.132978,
+              0.132,
+              0.131511,
+              0.135353,
+              0.133886,
+              0.133886,
+              0.132908,
+              0.131511,
+              0.132,
+              0.131022,
+              0.131092,
+              0.130533,
+              0.132977,
+              0.131092,
+              0.132,
+              0.130533,
+              0.132,
+              0.162241,
+              0.132419,
+              0.130115,
+              0.131092,
+              0.131092,
+              0.130045,
+              0.129556,
+              0.130533,
+              0.130533,
+              0.131511,
+              0.130603,
+              0.130115,
+              0.130115,
+              0.132,
+              0.131581,
+              0.132489,
+              0.132001,
+              0.131512,
+              0.131511,
+              0.130114,
+              0.132
+            ],
+            "warm_rows_per_second": 3893195.6520912615
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1726950,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "f74165bb32ed3307f423ea4917e648ddb56eef15fa4521f69fd6f16fc3599f66",
+            "table_sha256": "e3c61a84ae42232b395b0aec70a7cd0bae29d2b67c4f706876b2204483fc318d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.202649642014876,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1728202,
+          "backend_with_key_registry_bytes": 1946680,
+          "backend_with_datrie_key_index_bytes": 1841914,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999471589781962,
+            "mean_cosine": 0.9999794823547403,
+            "p05_cosine": 0.9999697795998994,
+            "relative_l2_mean": 0.0063798520701271065,
+            "relative_l2_p95": 0.007798429717370971,
+            "relative_l2_max": 0.010301694004383433,
+            "weighted_relative_l2_mean": 0.006459010216051861,
+            "weighted_relative_frobenius": 0.0066886524797597335,
+            "weighted_mean_cosine": 0.9999789761503499,
+            "max_relative_norm_change": 0.002403168609907241
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.91426,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.1358653,
+            "warm_p99_ms": 0.14259861,
+            "samples_ms": [
+              0.135771,
+              0.137657,
+              0.133397,
+              0.131511,
+              0.131022,
+              0.133397,
+              0.130534,
+              0.131581,
+              0.131022,
+              0.132,
+              0.145758,
+              0.132908,
+              0.132001,
+              0.131093,
+              0.131093,
+              0.129207,
+              0.131023,
+              0.131022,
+              0.131511,
+              0.132,
+              0.131511,
+              0.129625,
+              0.131022,
+              0.131022,
+              0.131581,
+              0.130603,
+              0.132,
+              0.131512,
+              0.131022,
+              0.131511,
+              0.131092,
+              0.131511,
+              0.131511,
+              0.132001,
+              0.130604,
+              0.131582,
+              0.131511,
+              0.131511,
+              0.131022,
+              0.131511
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1175823,
+              "unique_rows": 8713,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 141,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 141,
+              "zlib_blocks": 0,
+              "xor_blocks": 141,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8713
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "0e16307f6d7d2f16b5df0bf18bb5e0ad4aa9696151e7d65d3a3cb64efcdc223b",
+            "table_sha256": "123562d52dd4c313e376c968d2224f93c7415d264d6a7974e87c1b10c8d1a495",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14536297111772,
+          "representatives_sha256": "6768f1ff6fc3d7df653ab57688d7db1413898bee807bd7a61a3abfa4c5029f9c",
+          "structurally_merged_rows": 5419,
+          "backend_artifact_bytes": 1177072,
+          "backend_with_key_registry_bytes": 1395550,
+          "backend_with_datrie_key_index_bytes": 1290784,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9899801138449026,
+            "mean_cosine": 0.9985845270900451,
+            "p05_cosine": 0.9930813891868836,
+            "relative_l2_mean": 0.034861390437250256,
+            "relative_l2_p95": 0.11772796904728766,
+            "relative_l2_max": 0.14200820684716933,
+            "weighted_relative_l2_mean": 0.022794419147791192,
+            "weighted_relative_frobenius": 0.011592827136221024,
+            "weighted_mean_cosine": 0.9992138226113876,
+            "max_relative_norm_change": 0.01097468020532888
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900024071397229,
+            "mean_cosine": 0.9985897209075235,
+            "p05_cosine": 0.9930826313595622,
+            "relative_l2_mean": 0.031029785163936886,
+            "relative_l2_p95": 0.11787638870426462,
+            "relative_l2_max": 0.14219781943961757,
+            "weighted_relative_l2_mean": 0.017946976639319694,
+            "weighted_relative_frobenius": 0.009600591901907743,
+            "weighted_mean_cosine": 0.9992252098943923,
+            "max_relative_norm_change": 0.010098747555370645
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.459126,
+            "warm_p50_ms": 0.131023,
+            "warm_p95_ms": 0.13375319999999996,
+            "warm_p99_ms": 0.14542052,
+            "samples_ms": [
+              0.140521,
+              0.132489,
+              0.132,
+              0.130114,
+              0.131022,
+              0.131022,
+              0.131092,
+              0.13249,
+              0.132,
+              0.131511,
+              0.132,
+              0.130604,
+              0.131023,
+              0.131023,
+              0.131023,
+              0.130534,
+              0.132,
+              0.128299,
+              0.130604,
+              0.130115,
+              0.130603,
+              0.131512,
+              0.131512,
+              0.131022,
+              0.131092,
+              0.131162,
+              0.130533,
+              0.130603,
+              0.130603,
+              0.148553,
+              0.133397,
+              0.130603,
+              0.132,
+              0.132,
+              0.132489,
+              0.130603,
+              0.130044,
+              0.130533,
+              0.132,
+              0.130184
+            ],
+            "warm_rows_per_second": 3907710.8599253567
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1128366,
+              "unique_rows": 8285,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 134,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 134,
+              "zlib_blocks": 4,
+              "xor_blocks": 130,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8285
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "646f01f4709bb7e548edcc943f72979f595c75c76b8723f5e9942df74d389984",
+            "table_sha256": "a221b6fbe42e9142dacbda3d08460e7c331d6c2c40d697dd22fbb58832d0d5ea",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1393656248692423,
+          "representatives_sha256": "8b2a9c93f4b9dafeed1567dbc52b1969bd2d5924cae49daf7b12835ce067e2db",
+          "structurally_merged_rows": 5847,
+          "backend_artifact_bytes": 1129615,
+          "backend_with_key_registry_bytes": 1348093,
+          "backend_with_datrie_key_index_bytes": 1243327,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9801019509718193,
+            "mean_cosine": 0.9981548793445838,
+            "p05_cosine": 0.9912022094948002,
+            "relative_l2_mean": 0.0397624235208118,
+            "relative_l2_p95": 0.1327321045453814,
+            "relative_l2_max": 0.20063492021887994,
+            "weighted_relative_l2_mean": 0.025245128151299166,
+            "weighted_relative_frobenius": 0.011933935921140228,
+            "weighted_mean_cosine": 0.9989989802006313,
+            "max_relative_norm_change": 0.01097468020532888
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800593020711716,
+            "mean_cosine": 0.9981587042292385,
+            "p05_cosine": 0.9911925880905068,
+            "relative_l2_mean": 0.03612972620269922,
+            "relative_l2_p95": 0.13290670551842743,
+            "relative_l2_max": 0.20076566518744676,
+            "weighted_relative_l2_mean": 0.02049709007338642,
+            "weighted_relative_frobenius": 0.010011650874360624,
+            "weighted_mean_cosine": 0.999009687671515,
+            "max_relative_norm_change": 0.010098747555370645
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.518352,
+            "warm_p50_ms": 0.131512,
+            "warm_p95_ms": 0.1358234,
+            "warm_p99_ms": 0.14602146,
+            "samples_ms": [
+              0.135771,
+              0.133397,
+              0.131512,
+              0.131023,
+              0.132908,
+              0.132489,
+              0.132978,
+              0.131511,
+              0.133886,
+              0.133886,
+              0.131511,
+              0.131512,
+              0.132,
+              0.131092,
+              0.131092,
+              0.132489,
+              0.131023,
+              0.131512,
+              0.131023,
+              0.132,
+              0.131511,
+              0.151905,
+              0.136819,
+              0.131511,
+              0.131512,
+              0.132,
+              0.131511,
+              0.132,
+              0.131512,
+              0.131093,
+              0.130185,
+              0.131511,
+              0.131511,
+              0.132,
+              0.135283,
+              0.134305,
+              0.132,
+              0.132001,
+              0.131093,
+              0.131512
+            ],
+            "warm_rows_per_second": 3893180.850416692
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1119365,
+              "unique_rows": 8202,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 133,
+              "zlib_blocks": 3,
+              "xor_blocks": 130,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8202
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "3a561747837ca991db9b9b7a7abf98bd3daf970df326ce35ce08132003bf3fb9",
+            "table_sha256": "99a21c2eceaec8b32fc69b4d5de4db8f66e98d2f3a3136cd91e65c3fb877eade",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13420826010406017,
+          "representatives_sha256": "c0e878fe084ee8df1cfa5e4eeefcfe3f0d6371135b2bbe3bd8e033450e686031",
+          "structurally_merged_rows": 5930,
+          "backend_artifact_bytes": 1120614,
+          "backend_with_key_registry_bytes": 1339092,
+          "backend_with_datrie_key_index_bytes": 1234326,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9701486181461639,
+            "mean_cosine": 0.9980143916261239,
+            "p05_cosine": 0.9907430056165512,
+            "relative_l2_mean": 0.041009092049086614,
+            "relative_l2_p95": 0.1365202950335466,
+            "relative_l2_max": 0.24363978297137226,
+            "weighted_relative_l2_mean": 0.0260052352356428,
+            "weighted_relative_frobenius": 0.012924036411778727,
+            "weighted_mean_cosine": 0.9989138264682151,
+            "max_relative_norm_change": 0.01097468020532888
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9701112399545528,
+            "mean_cosine": 0.9980180167163665,
+            "p05_cosine": 0.9906755883005909,
+            "relative_l2_mean": 0.037414039058715175,
+            "relative_l2_p95": 0.13672098797393897,
+            "relative_l2_max": 0.24369098703870892,
+            "weighted_relative_l2_mean": 0.021280622747528337,
+            "weighted_relative_frobenius": 0.01117075773889507,
+            "weighted_mean_cosine": 0.9989244699849454,
+            "max_relative_norm_change": 0.010098747555370645
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.155875,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.13579295,
+            "warm_p99_ms": 0.1521669,
+            "samples_ms": [
+              0.134934,
+              0.133397,
+              0.131511,
+              0.131092,
+              0.131092,
+              0.133956,
+              0.132908,
+              0.130603,
+              0.131511,
+              0.130115,
+              0.131512,
+              0.131581,
+              0.162381,
+              0.135353,
+              0.131581,
+              0.131092,
+              0.131511,
+              0.130114,
+              0.132,
+              0.132,
+              0.132,
+              0.131093,
+              0.131511,
+              0.131022,
+              0.131022,
+              0.131022,
+              0.130114,
+              0.131022,
+              0.130603,
+              0.131022,
+              0.131511,
+              0.131092,
+              0.131092,
+              0.130533,
+              0.131511,
+              0.131093,
+              0.130604,
+              0.135772,
+              0.136191,
+              0.133467
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1117375,
+              "unique_rows": 8185,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 132,
+              "zlib_blocks": 3,
+              "xor_blocks": 129,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8185
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "7b92d29e0623f52881105e40964eb31dd3488b45ea812fede290b3e1d3d3419c",
+            "table_sha256": "f7866a75986a6ee885c564b71332a5d937238ba1d0ce4ce7802eed12c2074983",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15252687805332243,
+          "representatives_sha256": "c1a9fa5dcc227e4066722a5ae828af0d54b42ec976d465b8a1ccf7ad8390f6df",
+          "structurally_merged_rows": 5947,
+          "backend_artifact_bytes": 1118624,
+          "backend_with_key_registry_bytes": 1337102,
+          "backend_with_datrie_key_index_bytes": 1232336,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9526420225325654,
+            "mean_cosine": 0.9979460880636477,
+            "p05_cosine": 0.9905713481499385,
+            "relative_l2_mean": 0.04146497261643976,
+            "relative_l2_p95": 0.13751176348738786,
+            "relative_l2_max": 0.30767438969030325,
+            "weighted_relative_l2_mean": 0.02631967532395068,
+            "weighted_relative_frobenius": 0.013384670786946199,
+            "weighted_mean_cosine": 0.9988666273981026,
+            "max_relative_norm_change": 0.01097468020532888
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9526048497143683,
+            "mean_cosine": 0.9979496431001218,
+            "p05_cosine": 0.9905341890130446,
+            "relative_l2_mean": 0.03787774947286743,
+            "relative_l2_p95": 0.13756244760914405,
+            "relative_l2_max": 0.30787719238090006,
+            "weighted_relative_l2_mean": 0.021600008171405432,
+            "weighted_relative_frobenius": 0.011701695336837683,
+            "weighted_mean_cosine": 0.9988772090881424,
+            "max_relative_norm_change": 0.010098747555370645
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.398644,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13712965,
+            "warm_p99_ms": 0.14862224,
+            "samples_ms": [
+              0.136749,
+              0.135352,
+              0.13626,
+              0.151346,
+              0.134794,
+              0.132,
+              0.132,
+              0.132978,
+              0.131093,
+              0.132,
+              0.132489,
+              0.131511,
+              0.132978,
+              0.132,
+              0.131511,
+              0.131023,
+              0.132489,
+              0.131581,
+              0.131511,
+              0.131511,
+              0.131023,
+              0.131582,
+              0.131512,
+              0.130604,
+              0.130604,
+              0.133467,
+              0.132978,
+              0.132908,
+              0.133397,
+              0.132489,
+              0.132001,
+              0.133397,
+              0.144362,
+              0.133886,
+              0.131511,
+              0.132,
+              0.133397,
+              0.132,
+              0.132,
+              0.131512
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1117462,
+              "unique_rows": 8184,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 132,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 132,
+              "zlib_blocks": 5,
+              "xor_blocks": 127,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8184
+            },
+            "source_float32_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178",
+            "decoded_float32_sha256": "82400842112d5cc5e60fe9ebbe01788530c547bfffe6a2cc67fb260f7c00c5f2",
+            "table_sha256": "53dc99e9f14b3b221ce077544c3ce9041959917141f59efd34d46b6f36f9b6d9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.13213550811633468,
+          "representatives_sha256": "bfb33af6533f0fd7d63a625008e67a6a91770e6f159b62efed6590253854b2b2",
+          "structurally_merged_rows": 5948,
+          "backend_artifact_bytes": 1118711,
+          "backend_with_key_registry_bytes": 1337189,
+          "backend_with_datrie_key_index_bytes": 1232423,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9011804812433917,
+            "mean_cosine": 0.9978587097768464,
+            "p05_cosine": 0.9904579582661998,
+            "relative_l2_mean": 0.04186114631853476,
+            "relative_l2_p95": 0.1381574059207003,
+            "relative_l2_max": 0.4456799429253098,
+            "weighted_relative_l2_mean": 0.02658140480970069,
+            "weighted_relative_frobenius": 0.01430581292194207,
+            "weighted_mean_cosine": 0.9988116744021801,
+            "max_relative_norm_change": 0.01097468020532888
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9013204637301045,
+            "mean_cosine": 0.9978622987668155,
+            "p05_cosine": 0.990461845214681,
+            "relative_l2_mean": 0.03827414125471684,
+            "relative_l2_p95": 0.13832441220687874,
+            "relative_l2_max": 0.44548952244239215,
+            "weighted_relative_l2_mean": 0.02186235257397199,
+            "weighted_relative_frobenius": 0.012744182905516623,
+            "weighted_mean_cosine": 0.9988223194633946,
+            "max_relative_norm_change": 0.010098747555370645
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.264339,
+            "warm_p50_ms": 0.131511,
+            "warm_p95_ms": 0.13409905,
+            "warm_p99_ms": 0.14215104,
+            "samples_ms": [
+              0.138147,
+              0.133886,
+              0.133467,
+              0.130604,
+              0.132419,
+              0.132489,
+              0.13242,
+              0.132,
+              0.130114,
+              0.130534,
+              0.131511,
+              0.131022,
+              0.131022,
+              0.131092,
+              0.131581,
+              0.131512,
+              0.13249,
+              0.132978,
+              0.130603,
+              0.131511,
+              0.132,
+              0.132489,
+              0.130534,
+              0.132,
+              0.130603,
+              0.131092,
+              0.129625,
+              0.130044,
+              0.132489,
+              0.144711,
+              0.131023,
+              0.131023,
+              0.132419,
+              0.131511,
+              0.132,
+              0.129066,
+              0.130044,
+              0.131511,
+              0.131511,
+              0.129625
+            ],
+            "warm_rows_per_second": 3893210.453878383
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "c57dd713d91fb69fec6853aa0b34ca8b479f86acffb9aca5ab48614b45217178"
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "rows": 14132,
+      "dim": 128,
+      "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+      "source_float32_bytes": 7235584,
+      "key_registry_bytes": 218478,
+      "unchanged_backbone_artifact_bytes": 0,
+      "alternative_datrie_key_index_bytes": 113712,
+      "query_rows": 512,
+      "query_ids_sha256": "48cdbdeffaad5c50239fec7524368c85bd12fc21eefeb42effaa6c7c5ff0c323",
+      "frequency_trace_sha256": "fc8afe9c1f9a53dfd826267bdad324151b311d81a4be4e4834bd129ccf363886",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 512,
+            "storage": {
+              "artifact_bytes": 7235584,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "table_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03935490385629237,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 7236389,
+          "backend_with_key_registry_bytes": 7454867,
+          "backend_with_datrie_key_index_bytes": 7350101,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.379937,
+            "warm_p50_ms": 0.062473,
+            "warm_p95_ms": 0.0648165,
+            "warm_p99_ms": 0.08188186999999998,
+            "samples_ms": [
+              0.064813,
+              0.064393,
+              0.064813,
+              0.064812,
+              0.064254,
+              0.09275,
+              0.064883,
+              0.063416,
+              0.064393,
+              0.064813,
+              0.064813,
+              0.064254,
+              0.064324,
+              0.062438,
+              0.063835,
+              0.062857,
+              0.062438,
+              0.06195,
+              0.062019,
+              0.062438,
+              0.061949,
+              0.062368,
+              0.062019,
+              0.062508,
+              0.06153,
+              0.061879,
+              0.061949,
+              0.061949,
+              0.062019,
+              0.061111,
+              0.062858,
+              0.061949,
+              0.062368,
+              0.062997,
+              0.062019,
+              0.062089,
+              0.062438,
+              0.062438,
+              0.062858,
+              0.063346
+            ],
+            "warm_rows_per_second": 8195540.473484546
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6812385,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 49,
+              "xor_blocks": 835,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "table_sha256": "3c308989d9e4435c9b64bc1f8042a24b58e6af06c675322b29228495836ae5d3",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6078370399773121,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6813594,
+          "backend_with_key_registry_bytes": 7032072,
+          "backend_with_datrie_key_index_bytes": 6927306,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.036797,
+            "warm_p50_ms": 0.071936,
+            "warm_p95_ms": 0.07655045,
+            "warm_p99_ms": 0.07840512999999999,
+            "samples_ms": [
+              0.079549,
+              0.076616,
+              0.075638,
+              0.075639,
+              0.074731,
+              0.073822,
+              0.07473,
+              0.074311,
+              0.0748,
+              0.076547,
+              0.073822,
+              0.074311,
+              0.07473,
+              0.071517,
+              0.071448,
+              0.071448,
+              0.071936,
+              0.071029,
+              0.071518,
+              0.071936,
+              0.071448,
+              0.071518,
+              0.07012,
+              0.071378,
+              0.073334,
+              0.072915,
+              0.071936,
+              0.071937,
+              0.071029,
+              0.070958,
+              0.071448,
+              0.071937,
+              0.071378,
+              0.07047,
+              0.071937,
+              0.069981,
+              0.071378,
+              0.071448,
+              0.071377,
+              0.071867
+            ],
+            "warm_rows_per_second": 7117437.722419929
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6812385,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 49,
+              "xor_blocks": 835,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "table_sha256": "3c308989d9e4435c9b64bc1f8042a24b58e6af06c675322b29228495836ae5d3",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6630070290993899,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6813593,
+          "backend_with_key_registry_bytes": 7032071,
+          "backend_with_datrie_key_index_bytes": 6927305,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.959691,
+            "warm_p50_ms": 0.071378,
+            "warm_p95_ms": 0.076197,
+            "warm_p99_ms": 0.08105382,
+            "samples_ms": [
+              0.076197,
+              0.076127,
+              0.074311,
+              0.073823,
+              0.07522,
+              0.073753,
+              0.073822,
+              0.073822,
+              0.076197,
+              0.073822,
+              0.074311,
+              0.074241,
+              0.073823,
+              0.07047,
+              0.0704,
+              0.071378,
+              0.070958,
+              0.071029,
+              0.069562,
+              0.070959,
+              0.069074,
+              0.070959,
+              0.074241,
+              0.071378,
+              0.071378,
+              0.071448,
+              0.070959,
+              0.07047,
+              0.071448,
+              0.070959,
+              0.07054,
+              0.069492,
+              0.084159,
+              0.072425,
+              0.073333,
+              0.07054,
+              0.07054,
+              0.07047,
+              0.070959,
+              0.069073
+            ],
+            "warm_rows_per_second": 7173078.539606042
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 6812385,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 884,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 884,
+              "zlib_blocks": 49,
+              "xor_blocks": 835,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "table_sha256": "3c308989d9e4435c9b64bc1f8042a24b58e6af06c675322b29228495836ae5d3",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6472038871143013,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 6813593,
+          "backend_with_key_registry_bytes": 7032071,
+          "backend_with_datrie_key_index_bytes": 6927305,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.96018,
+            "warm_p50_ms": 0.071448,
+            "warm_p95_ms": 0.07561979999999997,
+            "warm_p99_ms": 0.12001117999999995,
+            "samples_ms": [
+              0.081924,
+              0.075288,
+              0.074241,
+              0.07473,
+              0.071029,
+              0.072007,
+              0.072425,
+              0.072425,
+              0.072006,
+              0.144362,
+              0.073822,
+              0.072426,
+              0.071448,
+              0.071028,
+              0.070959,
+              0.072426,
+              0.071028,
+              0.071378,
+              0.071378,
+              0.072425,
+              0.070959,
+              0.073334,
+              0.073334,
+              0.072915,
+              0.070539,
+              0.071098,
+              0.07061,
+              0.07047,
+              0.071448,
+              0.07047,
+              0.071448,
+              0.07047,
+              0.071029,
+              0.071937,
+              0.071447,
+              0.07054,
+              0.069981,
+              0.07047,
+              0.07047,
+              0.071448
+            ],
+            "warm_rows_per_second": 7166050.834173105
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4312855,
+              "unique_rows": 8755,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 548,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 548,
+              "zlib_blocks": 335,
+              "xor_blocks": 213,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8755
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "e7fe4379c53dd2f901f93b06027b9675225cf138d76c14febb466dffa8a50e74",
+            "table_sha256": "dd763eb9308f1f0a4ced7bc88972e9e793c3ada18bae66b28b048d89b212ab9b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4010178688913584,
+          "representatives_sha256": "018390edeae40939895cd7c39faa236b68fafee217da3bbfcd60df4c223ab3f8",
+          "structurally_merged_rows": 5377,
+          "backend_artifact_bytes": 4314062,
+          "backend_with_key_registry_bytes": 4532540,
+          "backend_with_datrie_key_index_bytes": 4427774,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900010721780895,
+            "mean_cosine": 0.9986084953232017,
+            "p05_cosine": 0.993215256177573,
+            "relative_l2_mean": 0.03070619265155565,
+            "relative_l2_p95": 0.11651034927530395,
+            "relative_l2_max": 0.1419349417581233,
+            "weighted_relative_l2_mean": 0.017809658251168703,
+            "weighted_relative_frobenius": 0.009554490322035257,
+            "weighted_mean_cosine": 0.9992321028745716,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900010721780895,
+            "mean_cosine": 0.9986084953232017,
+            "p05_cosine": 0.993215256177573,
+            "relative_l2_mean": 0.03070619265155565,
+            "relative_l2_p95": 0.11651034927530395,
+            "relative_l2_max": 0.1419349417581233,
+            "weighted_relative_l2_mean": 0.017809658251168703,
+            "weighted_relative_frobenius": 0.009554490322035257,
+            "weighted_mean_cosine": 0.9992321028745716,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.352991,
+            "warm_p50_ms": 0.07047,
+            "warm_p95_ms": 0.0748419,
+            "warm_p99_ms": 0.07708675,
+            "samples_ms": [
+              0.075638,
+              0.072844,
+              0.0748,
+              0.073753,
+              0.071867,
+              0.073822,
+              0.072914,
+              0.073822,
+              0.073333,
+              0.072355,
+              0.072286,
+              0.071867,
+              0.071866,
+              0.078013,
+              0.071937,
+              0.069143,
+              0.069632,
+              0.069003,
+              0.069631,
+              0.068584,
+              0.069492,
+              0.069632,
+              0.07054,
+              0.069981,
+              0.069981,
+              0.070889,
+              0.071448,
+              0.0748,
+              0.07047,
+              0.07047,
+              0.068654,
+              0.069492,
+              0.069492,
+              0.069562,
+              0.070051,
+              0.069003,
+              0.069562,
+              0.068654,
+              0.07047,
+              0.069423
+            ],
+            "warm_rows_per_second": 7265503.050943663
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4091660,
+              "unique_rows": 8289,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 519,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 518,
+              "zlib_blocks": 347,
+              "xor_blocks": 171,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8289
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "4f2e683d7805e5d20af336ad1ab4e4f9a34340d282bd9f57cc6ef4765664588c",
+            "table_sha256": "d6b55db5687508cccadab3e8564807b43d8397f4a2469dec2e421d674e16dbf9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3817510849330574,
+          "representatives_sha256": "a901c4c315d184a9ea7e4d0d9d8e32fcffca0eb7029e87fd2900ce22354f6c12",
+          "structurally_merged_rows": 5843,
+          "backend_artifact_bytes": 4092867,
+          "backend_with_key_registry_bytes": 4311345,
+          "backend_with_datrie_key_index_bytes": 4206579,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9801304891798318,
+            "mean_cosine": 0.9981494860596879,
+            "p05_cosine": 0.9911426784933394,
+            "relative_l2_mean": 0.036195062260779946,
+            "relative_l2_p95": 0.13323938209852676,
+            "relative_l2_max": 0.20007905691257175,
+            "weighted_relative_l2_mean": 0.020541834143205002,
+            "weighted_relative_frobenius": 0.009887839452694107,
+            "weighted_mean_cosine": 0.9990035141227676,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9801304891798318,
+            "mean_cosine": 0.9981494860596879,
+            "p05_cosine": 0.9911426784933394,
+            "relative_l2_mean": 0.036195062260779946,
+            "relative_l2_p95": 0.13323938209852676,
+            "relative_l2_max": 0.20007905691257175,
+            "weighted_relative_l2_mean": 0.020541834143205002,
+            "weighted_relative_frobenius": 0.009887839452694107,
+            "weighted_mean_cosine": 0.9990035141227676,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.468858,
+            "warm_p50_ms": 0.070749,
+            "warm_p95_ms": 0.11067709999999997,
+            "warm_p99_ms": 0.13698629999999998,
+            "samples_ms": [
+              0.078083,
+              0.07473,
+              0.072914,
+              0.102247,
+              0.148971,
+              0.118241,
+              0.108813,
+              0.109301,
+              0.110279,
+              0.105949,
+              0.103644,
+              0.101759,
+              0.1012,
+              0.102178,
+              0.07948,
+              0.069912,
+              0.073334,
+              0.073334,
+              0.071867,
+              0.069981,
+              0.07054,
+              0.068654,
+              0.067607,
+              0.068166,
+              0.069003,
+              0.069492,
+              0.068654,
+              0.068096,
+              0.068165,
+              0.068584,
+              0.067746,
+              0.068165,
+              0.068584,
+              0.067606,
+              0.069492,
+              0.069143,
+              0.068165,
+              0.070958,
+              0.071378,
+              0.069911
+            ],
+            "warm_rows_per_second": 7236851.40426013
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4063691,
+              "unique_rows": 8231,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 515,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 515,
+              "zlib_blocks": 359,
+              "xor_blocks": 156,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8231
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "f299252d533d07c324070ebea99a861f94d69e0aa6c3b26fae7871addc807785",
+            "table_sha256": "268961ca0d0669b1a658f202a2e302a8c24e26e2530452a187ffef40403acaff",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38775255205109715,
+          "representatives_sha256": "709636525f6f6787155801add12c053730f005d6da5439518e9bee1dbdb81e10",
+          "structurally_merged_rows": 5901,
+          "backend_artifact_bytes": 4064898,
+          "backend_with_key_registry_bytes": 4283376,
+          "backend_with_datrie_key_index_bytes": 4178610,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9700633688165851,
+            "mean_cosine": 0.998046379372092,
+            "p05_cosine": 0.9907880633674943,
+            "relative_l2_mean": 0.03711988639603293,
+            "relative_l2_p95": 0.13578873025592136,
+            "relative_l2_max": 0.24521876248037364,
+            "weighted_relative_l2_mean": 0.021030742895474887,
+            "weighted_relative_frobenius": 0.010116847994454945,
+            "weighted_mean_cosine": 0.9989485428849026,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9700633688165851,
+            "mean_cosine": 0.998046379372092,
+            "p05_cosine": 0.9907880633674943,
+            "relative_l2_mean": 0.03711988639603293,
+            "relative_l2_p95": 0.13578873025592136,
+            "relative_l2_max": 0.24521876248037364,
+            "weighted_relative_l2_mean": 0.021030742895474887,
+            "weighted_relative_frobenius": 0.010116847994454945,
+            "weighted_mean_cosine": 0.9989485428849026,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.594095,
+            "warm_p50_ms": 0.07054,
+            "warm_p95_ms": 0.07780269999999999,
+            "warm_p99_ms": 0.08075529000000001,
+            "samples_ms": [
+              0.080946,
+              0.076686,
+              0.074241,
+              0.074241,
+              0.073752,
+              0.072914,
+              0.071517,
+              0.073403,
+              0.071937,
+              0.071518,
+              0.071028,
+              0.069981,
+              0.068584,
+              0.070539,
+              0.071448,
+              0.071029,
+              0.069562,
+              0.069562,
+              0.069143,
+              0.069562,
+              0.07047,
+              0.069981,
+              0.069074,
+              0.07061,
+              0.070539,
+              0.069981,
+              0.069562,
+              0.07054,
+              0.069562,
+              0.069073,
+              0.069562,
+              0.07054,
+              0.073403,
+              0.077663,
+              0.072844,
+              0.07047,
+              0.069562,
+              0.069562,
+              0.080457,
+              0.071028
+            ],
+            "warm_rows_per_second": 7258293.166997449
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4049073,
+              "unique_rows": 8200,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 513,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 513,
+              "zlib_blocks": 356,
+              "xor_blocks": 157,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8200
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "88b89ca0c6e9bfdc07772c720877973a90980360086049102eb00191b22979e2",
+            "table_sha256": "4481d38ddba5240aed2a3b28c7e491a4e8530a1776a632472f4710f284fea1a9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37774100410752,
+          "representatives_sha256": "15e683ceadbc4d78f01e5e7e56e96b69fb47cf1ef552f21877aad4aa2835dba4",
+          "structurally_merged_rows": 5932,
+          "backend_artifact_bytes": 4050280,
+          "backend_with_key_registry_bytes": 4268758,
+          "backend_with_datrie_key_index_bytes": 4163992,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9514328140470131,
+            "mean_cosine": 0.9979344438076095,
+            "p05_cosine": 0.990552467538009,
+            "relative_l2_mean": 0.03790951931057653,
+            "relative_l2_p95": 0.1375593224122512,
+            "relative_l2_max": 0.31084382639637137,
+            "weighted_relative_l2_mean": 0.021484572239686486,
+            "weighted_relative_frobenius": 0.01135935648014331,
+            "weighted_mean_cosine": 0.9988836707971713,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9514328140470131,
+            "mean_cosine": 0.9979344438076095,
+            "p05_cosine": 0.990552467538009,
+            "relative_l2_mean": 0.03790951931057653,
+            "relative_l2_p95": 0.1375593224122512,
+            "relative_l2_max": 0.31084382639637137,
+            "weighted_relative_l2_mean": 0.021484572239686486,
+            "weighted_relative_frobenius": 0.01135935648014331,
+            "weighted_mean_cosine": 0.9988836707971713,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.69718,
+            "warm_p50_ms": 0.069562,
+            "warm_p95_ms": 0.07391629999999999,
+            "warm_p99_ms": 0.09185469999999998,
+            "samples_ms": [
+              0.075708,
+              0.071936,
+              0.073403,
+              0.073333,
+              0.069632,
+              0.069073,
+              0.069003,
+              0.07047,
+              0.071517,
+              0.102178,
+              0.071448,
+              0.070889,
+              0.069422,
+              0.069143,
+              0.069562,
+              0.068514,
+              0.07054,
+              0.071029,
+              0.069562,
+              0.069073,
+              0.069562,
+              0.073822,
+              0.071936,
+              0.071867,
+              0.071448,
+              0.069143,
+              0.069074,
+              0.069562,
+              0.068235,
+              0.068584,
+              0.069562,
+              0.069073,
+              0.068095,
+              0.069073,
+              0.068584,
+              0.069073,
+              0.069562,
+              0.068585,
+              0.068584,
+              0.068584
+            ],
+            "warm_rows_per_second": 7360340.415744228
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 512,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 7235584,
+              "artifact_bytes": 4044516,
+              "unique_rows": 8191,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 512,
+              "block_rows": 16,
+              "blocks": 512,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 512,
+              "zlib_blocks": 362,
+              "xor_blocks": 150,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8191
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "21a0609cab73c8e512b40350268db37db4abb653c280b6a31b32e699609d2d5b",
+            "table_sha256": "8a070942214cfdc28e214b09ba33aae31faa4f7bf54ad72c8132c6d848bff681",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.37253565806895494,
+          "representatives_sha256": "c9fedb493c3925ad399707e17a6a860b796aba5a8e625de6672f3ce9e4cf020c",
+          "structurally_merged_rows": 5941,
+          "backend_artifact_bytes": 4045723,
+          "backend_with_key_registry_bytes": 4264201,
+          "backend_with_datrie_key_index_bytes": 4159435,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9052723324331029,
+            "mean_cosine": 0.997872344589949,
+            "p05_cosine": 0.9904502799530508,
+            "relative_l2_mean": 0.038233152597705405,
+            "relative_l2_p95": 0.13817922336006339,
+            "relative_l2_max": 0.43421287618849197,
+            "weighted_relative_l2_mean": 0.02169441101934335,
+            "weighted_relative_frobenius": 0.01190780425189542,
+            "weighted_mean_cosine": 0.9988430147109009,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9052723324331029,
+            "mean_cosine": 0.997872344589949,
+            "p05_cosine": 0.9904502799530508,
+            "relative_l2_mean": 0.038233152597705405,
+            "relative_l2_p95": 0.13817922336006339,
+            "relative_l2_max": 0.43421287618849197,
+            "weighted_relative_l2_mean": 0.02169441101934335,
+            "weighted_relative_frobenius": 0.01190780425189542,
+            "weighted_mean_cosine": 0.9988430147109009,
+            "max_relative_norm_change": 0.0100968194450101
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.546253,
+            "warm_p50_ms": 0.07141249999999999,
+            "warm_p95_ms": 0.09389114999999999,
+            "warm_p99_ms": 0.09756388,
+            "samples_ms": [
+              0.078501,
+              0.075289,
+              0.071378,
+              0.075219,
+              0.071936,
+              0.07054,
+              0.072844,
+              0.073333,
+              0.075289,
+              0.075219,
+              0.071378,
+              0.071936,
+              0.072425,
+              0.072844,
+              0.068235,
+              0.069073,
+              0.069493,
+              0.069143,
+              0.097918,
+              0.09701,
+              0.093727,
+              0.07473,
+              0.072425,
+              0.072356,
+              0.069981,
+              0.068654,
+              0.069143,
+              0.069492,
+              0.068654,
+              0.069981,
+              0.068514,
+              0.071448,
+              0.071448,
+              0.071447,
+              0.070959,
+              0.069004,
+              0.069492,
+              0.069143,
+              0.069073,
+              0.069073
+            ],
+            "warm_rows_per_second": 7169613.162961667
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3617792,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "58a8afde490d0e308f8add0008e5239d0de80c72e72d6d5ff0e13f47acc810a9",
+            "table_sha256": "891a04cf80ccfbc91b7e235af0b0a5c951005e27e177a089c05291a8bae10358",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.045193221885710955,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3618598,
+          "backend_with_key_registry_bytes": 3837076,
+          "backend_with_datrie_key_index_bytes": 3732310,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999646369165,
+            "mean_cosine": 0.9999999790364589,
+            "p05_cosine": 0.9999999731862095,
+            "relative_l2_mean": 0.0002065451703408264,
+            "relative_l2_p95": 0.00023398282848556456,
+            "relative_l2_max": 0.0002720648220136451,
+            "weighted_relative_l2_mean": 0.00020648960705042698,
+            "weighted_relative_frobenius": 0.00020887876201816394,
+            "weighted_mean_cosine": 0.9999999790633699,
+            "max_relative_norm_change": 0.0001369949692249569
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.498598,
+            "warm_p50_ms": 0.2204195,
+            "warm_p95_ms": 0.3327629999999999,
+            "warm_p99_ms": 0.35659279,
+            "samples_ms": [
+              0.221886,
+              0.219512,
+              0.220978,
+              0.22,
+              0.220978,
+              0.235155,
+              0.22007,
+              0.220489,
+              0.219092,
+              0.219581,
+              0.219581,
+              0.219581,
+              0.21993,
+              0.219442,
+              0.219512,
+              0.220001,
+              0.220001,
+              0.219093,
+              0.218604,
+              0.220071,
+              0.219512,
+              0.235645,
+              0.331677,
+              0.353397,
+              0.23327,
+              0.22035,
+              0.22042,
+              0.271124,
+              0.318476,
+              0.2332,
+              0.22,
+              0.220419,
+              0.219512,
+              0.220489,
+              0.358636,
+              0.274896,
+              0.282927,
+              0.27727,
+              0.265467,
+              0.317499
+            ],
+            "warm_rows_per_second": 2322843.4870780488
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3408317,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "58a8afde490d0e308f8add0008e5239d0de80c72e72d6d5ff0e13f47acc810a9",
+            "table_sha256": "95c82541f2f4d0148a5a7809366cc3421dd23b8b56deae7a8190562fb158b720",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36331925401464105,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3409526,
+          "backend_with_key_registry_bytes": 3628004,
+          "backend_with_datrie_key_index_bytes": 3523238,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999646369165,
+            "mean_cosine": 0.9999999790364589,
+            "p05_cosine": 0.9999999731862095,
+            "relative_l2_mean": 0.0002065451703408264,
+            "relative_l2_p95": 0.00023398282848556456,
+            "relative_l2_max": 0.0002720648220136451,
+            "weighted_relative_l2_mean": 0.00020648960705042698,
+            "weighted_relative_frobenius": 0.00020887876201816394,
+            "weighted_mean_cosine": 0.9999999790633699,
+            "max_relative_norm_change": 0.0001369949692249569
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.808566,
+            "warm_p50_ms": 0.22900949999999998,
+            "warm_p95_ms": 0.23397869999999998,
+            "warm_p99_ms": 0.25061204,
+            "samples_ms": [
+              0.233619,
+              0.230406,
+              0.230477,
+              0.22894,
+              0.22852,
+              0.22894,
+              0.228102,
+              0.227473,
+              0.22894,
+              0.22894,
+              0.228521,
+              0.22894,
+              0.22894,
+              0.228451,
+              0.22901,
+              0.256877,
+              0.231315,
+              0.228032,
+              0.229429,
+              0.231384,
+              0.2332,
+              0.230826,
+              0.229009,
+              0.22908,
+              0.230895,
+              0.227613,
+              0.229499,
+              0.229428,
+              0.229918,
+              0.228032,
+              0.22901,
+              0.228032,
+              0.240813,
+              0.229987,
+              0.229918,
+              0.228032,
+              0.228102,
+              0.230407,
+              0.228521,
+              0.22894
+            ],
+            "warm_rows_per_second": 2235715.1122551686
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3408317,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "58a8afde490d0e308f8add0008e5239d0de80c72e72d6d5ff0e13f47acc810a9",
+            "table_sha256": "95c82541f2f4d0148a5a7809366cc3421dd23b8b56deae7a8190562fb158b720",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.39766583405435085,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3409525,
+          "backend_with_key_registry_bytes": 3628003,
+          "backend_with_datrie_key_index_bytes": 3523237,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999646369165,
+            "mean_cosine": 0.9999999790364589,
+            "p05_cosine": 0.9999999731862095,
+            "relative_l2_mean": 0.0002065451703408264,
+            "relative_l2_p95": 0.00023398282848556456,
+            "relative_l2_max": 0.0002720648220136451,
+            "weighted_relative_l2_mean": 0.00020648960705042698,
+            "weighted_relative_frobenius": 0.00020887876201816394,
+            "weighted_mean_cosine": 0.9999999790633699,
+            "max_relative_norm_change": 0.0001369949692249569
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.791944,
+            "warm_p50_ms": 0.229918,
+            "warm_p95_ms": 0.23502399999999998,
+            "warm_p99_ms": 0.24341629,
+            "samples_ms": [
+              0.2332,
+              0.230406,
+              0.230826,
+              0.230407,
+              0.229918,
+              0.229918,
+              0.230407,
+              0.230407,
+              0.234598,
+              0.230896,
+              0.243607,
+              0.230337,
+              0.229079,
+              0.229988,
+              0.229498,
+              0.229918,
+              0.229499,
+              0.229429,
+              0.229918,
+              0.229499,
+              0.229987,
+              0.229499,
+              0.22901,
+              0.230895,
+              0.230407,
+              0.229918,
+              0.229917,
+              0.243118,
+              0.230407,
+              0.229987,
+              0.229987,
+              0.229499,
+              0.229498,
+              0.229429,
+              0.22894,
+              0.22852,
+              0.22901,
+              0.229429,
+              0.229429,
+              0.228521
+            ],
+            "warm_rows_per_second": 2226880.887968754
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 3408317,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 442,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 442,
+              "zlib_blocks": 0,
+              "xor_blocks": 442,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "58a8afde490d0e308f8add0008e5239d0de80c72e72d6d5ff0e13f47acc810a9",
+            "table_sha256": "95c82541f2f4d0148a5a7809366cc3421dd23b8b56deae7a8190562fb158b720",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3406867440789938,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3409525,
+          "backend_with_key_registry_bytes": 3628003,
+          "backend_with_datrie_key_index_bytes": 3523237,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999646369165,
+            "mean_cosine": 0.9999999790364589,
+            "p05_cosine": 0.9999999731862095,
+            "relative_l2_mean": 0.0002065451703408264,
+            "relative_l2_p95": 0.00023398282848556456,
+            "relative_l2_max": 0.0002720648220136451,
+            "weighted_relative_l2_mean": 0.00020648960705042698,
+            "weighted_relative_frobenius": 0.00020887876201816394,
+            "weighted_mean_cosine": 0.9999999790633699,
+            "max_relative_norm_change": 0.0001369949692249569
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.762191,
+            "warm_p50_ms": 0.22900949999999998,
+            "warm_p95_ms": 0.23327354999999997,
+            "warm_p99_ms": 0.24449718,
+            "samples_ms": [
+              0.232851,
+              0.230895,
+              0.227613,
+              0.22901,
+              0.22901,
+              0.22901,
+              0.22894,
+              0.24654,
+              0.231804,
+              0.22908,
+              0.229498,
+              0.228102,
+              0.229918,
+              0.22901,
+              0.227613,
+              0.22901,
+              0.229009,
+              0.22908,
+              0.227612,
+              0.228102,
+              0.227543,
+              0.228032,
+              0.227962,
+              0.228032,
+              0.241302,
+              0.229918,
+              0.228521,
+              0.227613,
+              0.22859,
+              0.22908,
+              0.22901,
+              0.22901,
+              0.228521,
+              0.227613,
+              0.228521,
+              0.229499,
+              0.228101,
+              0.228102,
+              0.226635,
+              0.229499
+            ],
+            "warm_rows_per_second": 2235715.1122551686
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2210511,
+              "unique_rows": 8749,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 274,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 274,
+              "zlib_blocks": 87,
+              "xor_blocks": 187,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8749
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "03a606c976a608624362337ad63b9de4e37052f8605cd31768a0f4f154a9ce53",
+            "table_sha256": "15c98fde434b647d340bc6a2e86d7a9a5117e86df9d4fa59230bbe4ddd7f4983",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2351542259566486,
+          "representatives_sha256": "956043b03b29a55c6ba1c8769f797812d95a669298725966e612a729bc0f1305",
+          "structurally_merged_rows": 5383,
+          "backend_artifact_bytes": 2211717,
+          "backend_with_key_registry_bytes": 2430195,
+          "backend_with_datrie_key_index_bytes": 2325429,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.990007056186391,
+            "mean_cosine": 0.9986070309700306,
+            "p05_cosine": 0.9932159084086382,
+            "relative_l2_mean": 0.03086968019594394,
+            "relative_l2_p95": 0.11652666725147992,
+            "relative_l2_max": 0.1419611647297449,
+            "weighted_relative_l2_mean": 0.017984365153411806,
+            "weighted_relative_frobenius": 0.009560715856289807,
+            "weighted_mean_cosine": 0.9992313660358744,
+            "max_relative_norm_change": 0.010105117790425226
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900091705454804,
+            "mean_cosine": 0.9986070378401536,
+            "p05_cosine": 0.9932155274809832,
+            "relative_l2_mean": 0.03074185093056735,
+            "relative_l2_p95": 0.11654768876388556,
+            "relative_l2_max": 0.14195528458548512,
+            "weighted_relative_l2_mean": 0.017827325370210853,
+            "weighted_relative_frobenius": 0.009558478461585218,
+            "weighted_mean_cosine": 0.999231380401188,
+            "max_relative_norm_change": 0.010089174934655571
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.205928,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.23315485,
+            "warm_p99_ms": 0.24787425999999999,
+            "samples_ms": [
+              0.232781,
+              0.229917,
+              0.22901,
+              0.229987,
+              0.22901,
+              0.22894,
+              0.228102,
+              0.229499,
+              0.22901,
+              0.253594,
+              0.232851,
+              0.229498,
+              0.228521,
+              0.228521,
+              0.228521,
+              0.228032,
+              0.228032,
+              0.228032,
+              0.227473,
+              0.227962,
+              0.228032,
+              0.228521,
+              0.228032,
+              0.226636,
+              0.228521,
+              0.228591,
+              0.238928,
+              0.228521,
+              0.22894,
+              0.22894,
+              0.229009,
+              0.227543,
+              0.229429,
+              0.228451,
+              0.227543,
+              0.227124,
+              0.228102,
+              0.228521,
+              0.22894,
+              0.228032
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2101413,
+              "unique_rows": 8282,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 259,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 259,
+              "zlib_blocks": 116,
+              "xor_blocks": 143,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8282
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "3a96c4256fcc02f1a5fcda34489b58d74a8e15808fe6d18b86efcddcfc8c0573",
+            "table_sha256": "96d36c87ddd5c34b913ae9b5f1b4e70fa7e2dbac86518a884510291d732ff463",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2250868040136993,
+          "representatives_sha256": "76c124d99e9a0715c870dcde178039f14872e2a220d3aa66ae8ef69cb4241b1e",
+          "structurally_merged_rows": 5850,
+          "backend_artifact_bytes": 2102620,
+          "backend_with_key_registry_bytes": 2321098,
+          "backend_with_datrie_key_index_bytes": 2216332,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.980132361987804,
+            "mean_cosine": 0.9981471850465657,
+            "p05_cosine": 0.991141640232687,
+            "relative_l2_mean": 0.03636265467885292,
+            "relative_l2_p95": 0.13322974873587912,
+            "relative_l2_max": 0.20006871358342282,
+            "weighted_relative_l2_mean": 0.02071855969197664,
+            "weighted_relative_frobenius": 0.00989450479246472,
+            "weighted_mean_cosine": 0.9990023627562143,
+            "max_relative_norm_change": 0.010138660244752193
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9801310084676192,
+            "mean_cosine": 0.9981471926948611,
+            "p05_cosine": 0.9911425797513979,
+            "relative_l2_mean": 0.03624166457588246,
+            "relative_l2_p95": 0.13323903332007203,
+            "relative_l2_max": 0.2000592916691895,
+            "weighted_relative_l2_mean": 0.020564924203437772,
+            "weighted_relative_frobenius": 0.009892340007271048,
+            "weighted_mean_cosine": 0.9990023773552794,
+            "max_relative_norm_change": 0.010098746211067064
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.711102,
+            "warm_p50_ms": 0.2287655,
+            "warm_p95_ms": 0.23453419999999997,
+            "warm_p99_ms": 0.25344405,
+            "samples_ms": [
+              0.231873,
+              0.230407,
+              0.228521,
+              0.228521,
+              0.22901,
+              0.229499,
+              0.22901,
+              0.261207,
+              0.232782,
+              0.229499,
+              0.22894,
+              0.228591,
+              0.228032,
+              0.228102,
+              0.228452,
+              0.22894,
+              0.22894,
+              0.22908,
+              0.228032,
+              0.227543,
+              0.228032,
+              0.229499,
+              0.228451,
+              0.22894,
+              0.241302,
+              0.232293,
+              0.229988,
+              0.22859,
+              0.227613,
+              0.227543,
+              0.227543,
+              0.226565,
+              0.228521,
+              0.231315,
+              0.234178,
+              0.230826,
+              0.227543,
+              0.227473,
+              0.228521,
+              0.228521
+            ],
+            "warm_rows_per_second": 2238099.7134620384
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2087813,
+              "unique_rows": 8224,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 257,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 257,
+              "zlib_blocks": 120,
+              "xor_blocks": 137,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8224
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "d07ef498733e1452d6be269c51990edcb0f3e4f12c6491ff315e2f8b71ea9467",
+            "table_sha256": "dd18f5186e790d904a239a15682d765e8ed1ac0798b9240057bffac5170bf58e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2296391341369599,
+          "representatives_sha256": "e728b6c67e5b22f9069b02a96ecb6b4e023a9c5b4c19df4e2427c9a29c3ce14f",
+          "structurally_merged_rows": 5908,
+          "backend_artifact_bytes": 2089020,
+          "backend_with_key_registry_bytes": 2307498,
+          "backend_with_datrie_key_index_bytes": 2202732,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9700701881194705,
+            "mean_cosine": 0.9980440754357444,
+            "p05_cosine": 0.9907911042391875,
+            "relative_l2_mean": 0.03728664315912571,
+            "relative_l2_p95": 0.1357957115925837,
+            "relative_l2_max": 0.24519072193375074,
+            "weighted_relative_l2_mean": 0.021207044963463435,
+            "weighted_relative_frobenius": 0.010123420958298426,
+            "weighted_mean_cosine": 0.9989473888952469,
+            "max_relative_norm_change": 0.010138660244752193
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9700687232478249,
+            "mean_cosine": 0.9980440826393321,
+            "p05_cosine": 0.9907918330818589,
+            "relative_l2_mean": 0.037166506643704786,
+            "relative_l2_p95": 0.1357704486930214,
+            "relative_l2_max": 0.2451995418904606,
+            "weighted_relative_l2_mean": 0.021053848111204372,
+            "weighted_relative_frobenius": 0.010121302767534777,
+            "weighted_mean_cosine": 0.9989474033210557,
+            "max_relative_norm_change": 0.010098746211067064
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.577147,
+            "warm_p50_ms": 0.228521,
+            "warm_p95_ms": 0.23540029999999998,
+            "warm_p99_ms": 0.24392851,
+            "samples_ms": [
+              0.233619,
+              0.229918,
+              0.235086,
+              0.22894,
+              0.228521,
+              0.229009,
+              0.234108,
+              0.241372,
+              0.232711,
+              0.230895,
+              0.228521,
+              0.227962,
+              0.229848,
+              0.227543,
+              0.232851,
+              0.22901,
+              0.228032,
+              0.227124,
+              0.22859,
+              0.234178,
+              0.228521,
+              0.228521,
+              0.227543,
+              0.226565,
+              0.245563,
+              0.232223,
+              0.22859,
+              0.228102,
+              0.227613,
+              0.228591,
+              0.228521,
+              0.228102,
+              0.227613,
+              0.227474,
+              0.228451,
+              0.228521,
+              0.2332,
+              0.227124,
+              0.227613,
+              0.227124
+            ],
+            "warm_rows_per_second": 2240494.309056936
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2080306,
+              "unique_rows": 8193,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 257,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 256,
+              "zlib_blocks": 125,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8193
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "b87db8420e7476028063309e419abcc76c4e7f8016bfc1cbaad613c73bd5c846",
+            "table_sha256": "ec7a5524d2373dd2bf37f093e78c7991f40cc51c8bf21ab740bc8200758eabbf",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22681321296840906,
+          "representatives_sha256": "94dd6e62f140d247194a90ba465fb0fe89b0bf82a4963c9a54f377809fcf6257",
+          "structurally_merged_rows": 5939,
+          "backend_artifact_bytes": 2081513,
+          "backend_with_key_registry_bytes": 2299991,
+          "backend_with_datrie_key_index_bytes": 2195225,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9514374218821062,
+            "mean_cosine": 0.9979321385598214,
+            "p05_cosine": 0.9905512436111426,
+            "relative_l2_mean": 0.03807581807203882,
+            "relative_l2_p95": 0.1375590599343331,
+            "relative_l2_max": 0.31082112559827385,
+            "weighted_relative_l2_mean": 0.02166062335741108,
+            "weighted_relative_frobenius": 0.011365209163908348,
+            "weighted_mean_cosine": 0.9988825164132097,
+            "max_relative_norm_change": 0.010138660244752193
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9514326597019475,
+            "mean_cosine": 0.9979321468354201,
+            "p05_cosine": 0.990549616265017,
+            "relative_l2_mean": 0.03795614209728174,
+            "relative_l2_p95": 0.13755454468164807,
+            "relative_l2_max": 0.310841627963749,
+            "weighted_relative_l2_mean": 0.021507681587830875,
+            "weighted_relative_frobenius": 0.011363347775666536,
+            "weighted_mean_cosine": 0.9988825303587557,
+            "max_relative_norm_change": 0.010098746211067064
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.828436,
+            "warm_p50_ms": 0.22894,
+            "warm_p95_ms": 0.24172444999999998,
+            "warm_p99_ms": 0.25124866,
+            "samples_ms": [
+              0.241721,
+              0.231803,
+              0.230825,
+              0.229429,
+              0.228102,
+              0.228591,
+              0.24179,
+              0.228521,
+              0.229918,
+              0.22887,
+              0.22894,
+              0.228451,
+              0.22894,
+              0.22894,
+              0.22901,
+              0.229009,
+              0.22901,
+              0.234179,
+              0.228521,
+              0.228381,
+              0.230896,
+              0.230896,
+              0.233759,
+              0.257296,
+              0.232293,
+              0.22894,
+              0.22852,
+              0.228521,
+              0.227054,
+              0.227544,
+              0.23327,
+              0.228521,
+              0.228101,
+              0.227543,
+              0.233689,
+              0.22894,
+              0.227054,
+              0.229498,
+              0.22894,
+              0.227544
+            ],
+            "warm_rows_per_second": 2236393.8149733553
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3617792,
+              "artifact_bytes": 2078125,
+              "unique_rows": 8184,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 256,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 256,
+              "zlib_blocks": 125,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8184
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "1e349ad3c6fd5a154e79b366f7504af81c349c3b150362d02a3039fdc4cd9ace",
+            "table_sha256": "c95ad8defc43336ab7732dc3dde94f4bc3816dc0f320adfa4a7f0ce39680e21e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22549356101080775,
+          "representatives_sha256": "72ae588e623f4aa824b05b1c4d5b6d93d1de2059eb335a7c684f32a53a74f5ce",
+          "structurally_merged_rows": 5948,
+          "backend_artifact_bytes": 2079332,
+          "backend_with_key_registry_bytes": 2297810,
+          "backend_with_datrie_key_index_bytes": 2193044,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9052630677527462,
+            "mean_cosine": 0.9978700376740262,
+            "p05_cosine": 0.9904479782806821,
+            "relative_l2_mean": 0.038399326678778566,
+            "relative_l2_p95": 0.13818826505076168,
+            "relative_l2_max": 0.43421943108487454,
+            "weighted_relative_l2_mean": 0.021870386623126264,
+            "weighted_relative_frobenius": 0.011913401642523774,
+            "weighted_mean_cosine": 0.9988418596550673,
+            "max_relative_norm_change": 0.010138660244752193
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9052623408990954,
+            "mean_cosine": 0.9978700427661503,
+            "p05_cosine": 0.9904473239689596,
+            "relative_l2_mean": 0.038279788666925,
+            "relative_l2_p95": 0.13819983197682933,
+            "relative_l2_max": 0.4342322325789638,
+            "weighted_relative_l2_mean": 0.0217175255331657,
+            "weighted_relative_frobenius": 0.011911638782710864,
+            "weighted_mean_cosine": 0.9988418721406954,
+            "max_relative_norm_change": 0.010098746211067064
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.953731,
+            "warm_p50_ms": 0.229883,
+            "warm_p95_ms": 0.3456933,
+            "warm_p99_ms": 0.37220983999999996,
+            "samples_ms": [
+              0.351931,
+              0.345365,
+              0.345365,
+              0.345365,
+              0.34341,
+              0.341035,
+              0.385175,
+              0.342083,
+              0.229429,
+              0.228451,
+              0.228032,
+              0.22887,
+              0.234178,
+              0.231873,
+              0.231803,
+              0.230337,
+              0.227613,
+              0.228521,
+              0.22901,
+              0.22901,
+              0.228032,
+              0.228521,
+              0.274407,
+              0.238438,
+              0.232711,
+              0.230826,
+              0.229009,
+              0.228521,
+              0.229009,
+              0.227543,
+              0.228451,
+              0.229429,
+              0.287187,
+              0.287188,
+              0.227613,
+              0.227543,
+              0.227054,
+              0.227963,
+              0.264489,
+              0.233619
+            ],
+            "warm_rows_per_second": 2227219.933618406
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 132,
+            "storage": {
+              "artifact_bytes": 1865424,
+              "unique_rows": 14132,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "1c37947f29f3da25c424fdd730690d3a4a1f55296f4034cf343a6892d5710e81",
+            "table_sha256": "c32e129ca5dd95b920e1532b4fa43658b2d93d5a6a71a0c7ba8b53ed4163e1c5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03687532618641853,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1866274,
+          "backend_with_key_registry_bytes": 2084752,
+          "backend_with_datrie_key_index_bytes": 1979986,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999416546250693,
+            "mean_cosine": 0.9999789981841369,
+            "p05_cosine": 0.9999686233018587,
+            "relative_l2_mean": 0.006454883173090688,
+            "relative_l2_p95": 0.007945469397262879,
+            "relative_l2_max": 0.010833502058372456,
+            "weighted_relative_l2_mean": 0.006481248993400622,
+            "weighted_relative_frobenius": 0.00659738924794254,
+            "weighted_mean_cosine": 0.9999788190130319,
+            "max_relative_norm_change": 0.0025646664461764367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.370928,
+            "warm_p50_ms": 0.12211749999999999,
+            "warm_p95_ms": 0.13324419999999998,
+            "warm_p99_ms": 0.15490753,
+            "samples_ms": [
+              0.12725,
+              0.124387,
+              0.122991,
+              0.122013,
+              0.122571,
+              0.122013,
+              0.12348,
+              0.139613,
+              0.124457,
+              0.122502,
+              0.132,
+              0.122013,
+              0.121105,
+              0.121594,
+              0.121664,
+              0.122152,
+              0.122083,
+              0.123969,
+              0.122572,
+              0.121523,
+              0.122502,
+              0.124388,
+              0.121594,
+              0.123968,
+              0.124387,
+              0.122082,
+              0.121664,
+              0.132909,
+              0.122083,
+              0.123969,
+              0.122083,
+              0.121524,
+              0.122083,
+              0.122083,
+              0.122082,
+              0.122572,
+              0.122013,
+              0.121943,
+              0.122013,
+              0.164686
+            ],
+            "warm_rows_per_second": 4192683.2763526933
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1724422,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "1c37947f29f3da25c424fdd730690d3a4a1f55296f4034cf343a6892d5710e81",
+            "table_sha256": "1ac10c201ab01b98342763b408901006a5b71b11a5df1916a5290c3fb6629807",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20558535307645798,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1725675,
+          "backend_with_key_registry_bytes": 1944153,
+          "backend_with_datrie_key_index_bytes": 1839387,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999416546250693,
+            "mean_cosine": 0.9999789981841369,
+            "p05_cosine": 0.9999686233018587,
+            "relative_l2_mean": 0.006454883173090688,
+            "relative_l2_p95": 0.007945469397262879,
+            "relative_l2_max": 0.010833502058372456,
+            "weighted_relative_l2_mean": 0.006481248993400622,
+            "weighted_relative_frobenius": 0.00659738924794254,
+            "weighted_mean_cosine": 0.9999788190130319,
+            "max_relative_norm_change": 0.0025646664461764367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.009314,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.1425711,
+            "warm_p99_ms": 0.15757546,
+            "samples_ms": [
+              0.165175,
+              0.132908,
+              0.133467,
+              0.132,
+              0.131092,
+              0.132,
+              0.130603,
+              0.13249,
+              0.132489,
+              0.132,
+              0.132489,
+              0.131023,
+              0.131023,
+              0.132,
+              0.134864,
+              0.131511,
+              0.130604,
+              0.132,
+              0.132,
+              0.131582,
+              0.129277,
+              0.129695,
+              0.130184,
+              0.131511,
+              0.131511,
+              0.142407,
+              0.137238,
+              0.131512,
+              0.131512,
+              0.145689,
+              0.132489,
+              0.130115,
+              0.130673,
+              0.136749,
+              0.134304,
+              0.132489,
+              0.131093,
+              0.132001,
+              0.131092,
+              0.130533
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1724422,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "1c37947f29f3da25c424fdd730690d3a4a1f55296f4034cf343a6892d5710e81",
+            "table_sha256": "1ac10c201ab01b98342763b408901006a5b71b11a5df1916a5290c3fb6629807",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2546287889126688,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1725674,
+          "backend_with_key_registry_bytes": 1944152,
+          "backend_with_datrie_key_index_bytes": 1839386,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999416546250693,
+            "mean_cosine": 0.9999789981841369,
+            "p05_cosine": 0.9999686233018587,
+            "relative_l2_mean": 0.006454883173090688,
+            "relative_l2_p95": 0.007945469397262879,
+            "relative_l2_max": 0.010833502058372456,
+            "weighted_relative_l2_mean": 0.006481248993400622,
+            "weighted_relative_frobenius": 0.00659738924794254,
+            "weighted_mean_cosine": 0.9999788190130319,
+            "max_relative_norm_change": 0.0025646664461764367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.976279,
+            "warm_p50_ms": 0.131023,
+            "warm_p95_ms": 0.13479744999999999,
+            "warm_p99_ms": 0.16570826,
+            "samples_ms": [
+              0.134794,
+              0.132489,
+              0.132489,
+              0.131511,
+              0.131022,
+              0.132908,
+              0.130604,
+              0.131093,
+              0.131511,
+              0.131511,
+              0.131511,
+              0.130114,
+              0.129206,
+              0.131022,
+              0.130114,
+              0.131022,
+              0.131511,
+              0.131092,
+              0.131092,
+              0.128298,
+              0.131092,
+              0.130603,
+              0.130045,
+              0.131023,
+              0.131023,
+              0.130603,
+              0.129137,
+              0.185429,
+              0.133886,
+              0.131581,
+              0.130603,
+              0.134863,
+              0.130604,
+              0.130603,
+              0.130603,
+              0.132489,
+              0.130603,
+              0.130603,
+              0.129625,
+              0.134794
+            ],
+            "warm_rows_per_second": 3907710.8599253567
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1724422,
+              "unique_rows": 14132,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 228,
+              "zlib_blocks": 0,
+              "xor_blocks": 228,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 14132
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "1c37947f29f3da25c424fdd730690d3a4a1f55296f4034cf343a6892d5710e81",
+            "table_sha256": "1ac10c201ab01b98342763b408901006a5b71b11a5df1916a5290c3fb6629807",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.20552047016099095,
+          "representatives_sha256": "99f43c31125f55c54c27ed391ba505ce31e22821afc532165dd58cdc508f69fc",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1725674,
+          "backend_with_key_registry_bytes": 1944152,
+          "backend_with_datrie_key_index_bytes": 1839386,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999416546250693,
+            "mean_cosine": 0.9999789981841369,
+            "p05_cosine": 0.9999686233018587,
+            "relative_l2_mean": 0.006454883173090688,
+            "relative_l2_p95": 0.007945469397262879,
+            "relative_l2_max": 0.010833502058372456,
+            "weighted_relative_l2_mean": 0.006481248993400622,
+            "weighted_relative_frobenius": 0.00659738924794254,
+            "weighted_mean_cosine": 0.9999788190130319,
+            "max_relative_norm_change": 0.0025646664461764367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 9.953021,
+            "warm_p50_ms": 0.1301495,
+            "warm_p95_ms": 0.1325588,
+            "warm_p99_ms": 0.14138372999999999,
+            "samples_ms": [
+              0.133885,
+              0.132,
+              0.131582,
+              0.132489,
+              0.132,
+              0.129625,
+              0.131511,
+              0.131511,
+              0.132,
+              0.131512,
+              0.132,
+              0.131022,
+              0.131511,
+              0.130114,
+              0.130533,
+              0.130533,
+              0.130533,
+              0.132,
+              0.129625,
+              0.129625,
+              0.129625,
+              0.129207,
+              0.129207,
+              0.129626,
+              0.146178,
+              0.132489,
+              0.129695,
+              0.129206,
+              0.130185,
+              0.128718,
+              0.129625,
+              0.131022,
+              0.130114,
+              0.129137,
+              0.129066,
+              0.129555,
+              0.128648,
+              0.129626,
+              0.130045,
+              0.130045
+            ],
+            "warm_rows_per_second": 3933937.510324665
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1182283,
+              "unique_rows": 8788,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 142,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 142,
+              "zlib_blocks": 0,
+              "xor_blocks": 142,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8788
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "a824e7dc6aae4c396c20672cde81a8e8b01bac06024c1aed441d90ac9326e4c1",
+            "table_sha256": "74a174e8442e68b19a8fd008323f91f7c9708a1adf0e3f06602bbe691c214dbb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1529743520077318,
+          "representatives_sha256": "d41b79fe8448d6f9dde66b6fa9a9fa774533b3195e2a343075490556bf0899af",
+          "structurally_merged_rows": 5344,
+          "backend_artifact_bytes": 1183532,
+          "backend_with_key_registry_bytes": 1402010,
+          "backend_with_datrie_key_index_bytes": 1297244,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9899108723181153,
+            "mean_cosine": 0.9985974036524515,
+            "p05_cosine": 0.9932142209859959,
+            "relative_l2_mean": 0.03463968394059213,
+            "relative_l2_p95": 0.11650950709251426,
+            "relative_l2_max": 0.142252491783661,
+            "weighted_relative_l2_mean": 0.022743038805837456,
+            "weighted_relative_frobenius": 0.011588159396950687,
+            "weighted_mean_cosine": 0.9992156948236537,
+            "max_relative_norm_change": 0.011184456409277174
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9900065524598948,
+            "mean_cosine": 0.9986026066492123,
+            "p05_cosine": 0.9931883698886925,
+            "relative_l2_mean": 0.030733278485272696,
+            "relative_l2_p95": 0.11685027491459732,
+            "relative_l2_max": 0.14242139704155687,
+            "weighted_relative_l2_mean": 0.01787775152113955,
+            "weighted_relative_frobenius": 0.00966408415736297,
+            "weighted_mean_cosine": 0.9992268155290017,
+            "max_relative_norm_change": 0.010090977690148559
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.00801,
+            "warm_p50_ms": 0.13130199999999997,
+            "warm_p95_ms": 0.14217989999999997,
+            "warm_p99_ms": 0.15465412,
+            "samples_ms": [
+              0.137658,
+              0.134794,
+              0.133816,
+              0.132,
+              0.131511,
+              0.131093,
+              0.131023,
+              0.130533,
+              0.147156,
+              0.132978,
+              0.131022,
+              0.132977,
+              0.132978,
+              0.130533,
+              0.131093,
+              0.130044,
+              0.130045,
+              0.133397,
+              0.132,
+              0.129626,
+              0.130114,
+              0.141428,
+              0.129626,
+              0.130604,
+              0.130115,
+              0.131581,
+              0.130045,
+              0.141918,
+              0.132,
+              0.132,
+              0.131092,
+              0.130533,
+              0.129556,
+              0.130114,
+              0.130114,
+              0.130184,
+              0.132489,
+              0.159448,
+              0.135353,
+              0.132489
+            ],
+            "warm_rows_per_second": 3899407.472848853
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1130550,
+              "unique_rows": 8319,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 135,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 135,
+              "zlib_blocks": 0,
+              "xor_blocks": 135,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8319
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "e04a9bbbe6ed08fbca27d3b0986983f6b93ab737f346e518120b5b64524fb1fa",
+            "table_sha256": "8e396b9ef65e52b1f577096e33001d09d9b1c029d3f9411fa7b35f45ebd20b46",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.16777170891873538,
+          "representatives_sha256": "05d1b683b3b51ddfaacc059479c1618a42851ef44dc661ef671327ceb3b453cd",
+          "structurally_merged_rows": 5813,
+          "backend_artifact_bytes": 1131799,
+          "backend_with_key_registry_bytes": 1350277,
+          "backend_with_datrie_key_index_bytes": 1245511,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9798827077614866,
+            "mean_cosine": 0.9981339639644252,
+            "p05_cosine": 0.991126565017416,
+            "relative_l2_mean": 0.03996771697003143,
+            "relative_l2_p95": 0.13336952753736225,
+            "relative_l2_max": 0.20134611295850205,
+            "weighted_relative_l2_mean": 0.025395107328377076,
+            "weighted_relative_frobenius": 0.011866439446284533,
+            "weighted_mean_cosine": 0.9989849126118469,
+            "max_relative_norm_change": 0.011545051309837495
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9800295519620152,
+            "mean_cosine": 0.9981378180939796,
+            "p05_cosine": 0.9911077709660768,
+            "relative_l2_mean": 0.03627773874662921,
+            "relative_l2_p95": 0.133575330698548,
+            "relative_l2_max": 0.20066482239216804,
+            "weighted_relative_l2_mean": 0.020637454063190525,
+            "weighted_relative_frobenius": 0.009996923230353167,
+            "weighted_mean_cosine": 0.9989953671888233,
+            "max_relative_norm_change": 0.010090977690148559
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.401926,
+            "warm_p50_ms": 0.132,
+            "warm_p95_ms": 0.13689315,
+            "warm_p99_ms": 0.14451251999999998,
+            "samples_ms": [
+              0.13675,
+              0.13675,
+              0.139613,
+              0.134863,
+              0.132978,
+              0.133466,
+              0.131092,
+              0.131092,
+              0.131092,
+              0.130533,
+              0.132489,
+              0.132839,
+              0.147645,
+              0.132908,
+              0.131022,
+              0.131022,
+              0.131511,
+              0.131581,
+              0.131511,
+              0.131093,
+              0.131093,
+              0.133397,
+              0.135771,
+              0.133956,
+              0.132001,
+              0.131511,
+              0.132489,
+              0.133397,
+              0.131023,
+              0.131512,
+              0.129556,
+              0.133397,
+              0.132,
+              0.132908,
+              0.13633,
+              0.131511,
+              0.131092,
+              0.132,
+              0.131512,
+              0.131163
+            ],
+            "warm_rows_per_second": 3878787.8787878784
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1124396,
+              "unique_rows": 8266,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 134,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 134,
+              "zlib_blocks": 3,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8266
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "9ec201def617a752929d2a8bc3e6b099aaf9171a6414ac8398124787fabab7ea",
+            "table_sha256": "375a9969194d26155e350b4501a22a1ff185c0d31b3fc2b4a09f952c66eafc73",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14849828905425966,
+          "representatives_sha256": "de61c1c712da640b57e4078fb10b81abcb058b67e42210c6fed8cb23b53e1c9a",
+          "structurally_merged_rows": 5866,
+          "backend_artifact_bytes": 1125645,
+          "backend_with_key_registry_bytes": 1344123,
+          "backend_with_datrie_key_index_bytes": 1239357,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9701382468354772,
+            "mean_cosine": 0.9980390119271941,
+            "p05_cosine": 0.9908073065862646,
+            "relative_l2_mean": 0.040792527914039235,
+            "relative_l2_p95": 0.13563235078609337,
+            "relative_l2_max": 0.24497082414096052,
+            "weighted_relative_l2_mean": 0.025803739344528464,
+            "weighted_relative_frobenius": 0.011907506555993772,
+            "weighted_mean_cosine": 0.9989378709925603,
+            "max_relative_norm_change": 0.011545051309837495
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.970420856601294,
+            "mean_cosine": 0.9980426977362156,
+            "p05_cosine": 0.990776119815563,
+            "relative_l2_mean": 0.037126568315976424,
+            "relative_l2_p95": 0.13598857146171736,
+            "relative_l2_max": 0.2437800342281442,
+            "weighted_relative_l2_mean": 0.021057985508379482,
+            "weighted_relative_frobenius": 0.010045723189348644,
+            "weighted_mean_cosine": 0.9989482421793255,
+            "max_relative_norm_change": 0.010090977690148559
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.427,
+            "warm_p50_ms": 0.132489,
+            "warm_p95_ms": 0.1387293,
+            "warm_p99_ms": 0.15526165,
+            "samples_ms": [
+              0.134305,
+              0.132978,
+              0.132489,
+              0.132489,
+              0.133886,
+              0.140521,
+              0.133467,
+              0.131092,
+              0.131511,
+              0.132489,
+              0.164686,
+              0.13626,
+              0.132908,
+              0.131512,
+              0.131512,
+              0.132489,
+              0.132489,
+              0.13242,
+              0.132,
+              0.132,
+              0.132,
+              0.131511,
+              0.131023,
+              0.132908,
+              0.129626,
+              0.131511,
+              0.136679,
+              0.137238,
+              0.136749,
+              0.132489,
+              0.138635,
+              0.132908,
+              0.13633,
+              0.135283,
+              0.132489,
+              0.132978,
+              0.131022,
+              0.131511,
+              0.129626,
+              0.131511
+            ],
+            "warm_rows_per_second": 3864471.7674674885
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1120791,
+              "unique_rows": 8235,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 133,
+              "zlib_blocks": 1,
+              "xor_blocks": 132,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8235
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "7e9b1ab14ac2b25cb9b467d50e5696269bfef612d85ba7b6cdd555653548f7d6",
+            "table_sha256": "6921034e96171757cebfcf8d3354d7f70c8aa5356ed9a946eef5064fa7dfd43b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.17001997190527618,
+          "representatives_sha256": "07f3594db208298cb4d28797bce605bf0ea698d232d93c0642adcd10c670e55c",
+          "structurally_merged_rows": 5897,
+          "backend_artifact_bytes": 1122040,
+          "backend_with_key_registry_bytes": 1340518,
+          "backend_with_datrie_key_index_bytes": 1235752,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.9513417357401348,
+            "mean_cosine": 0.9979278119096603,
+            "p05_cosine": 0.9905879251663541,
+            "relative_l2_mean": 0.0415656151939831,
+            "relative_l2_p95": 0.13721894132995344,
+            "relative_l2_max": 0.3112503293611566,
+            "weighted_relative_l2_mean": 0.026248778803007623,
+            "weighted_relative_frobenius": 0.013052340782278507,
+            "weighted_mean_cosine": 0.9988733671033254,
+            "max_relative_norm_change": 0.011545051309837495
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9513428546426225,
+            "mean_cosine": 0.9979314301481493,
+            "p05_cosine": 0.990524673728532,
+            "relative_l2_mean": 0.037913106122702,
+            "relative_l2_p95": 0.13763929961460214,
+            "relative_l2_max": 0.3113047564903937,
+            "weighted_relative_l2_mean": 0.02151018282355247,
+            "weighted_relative_frobenius": 0.011379386283756232,
+            "weighted_mean_cosine": 0.998883705182836,
+            "max_relative_norm_change": 0.010090977690148559
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.614873,
+            "warm_p50_ms": 0.131791,
+            "warm_p95_ms": 0.14005999999999996,
+            "warm_p99_ms": 0.16009847,
+            "samples_ms": [
+              0.139613,
+              0.136749,
+              0.138635,
+              0.132978,
+              0.131582,
+              0.132,
+              0.133397,
+              0.133816,
+              0.148553,
+              0.132908,
+              0.131092,
+              0.131023,
+              0.130534,
+              0.132978,
+              0.131511,
+              0.131022,
+              0.132489,
+              0.132489,
+              0.135772,
+              0.131512,
+              0.131023,
+              0.131511,
+              0.132489,
+              0.132908,
+              0.130115,
+              0.130533,
+              0.132,
+              0.131022,
+              0.135771,
+              0.132489,
+              0.130534,
+              0.131512,
+              0.129207,
+              0.129626,
+              0.129626,
+              0.130534,
+              0.130604,
+              0.130045,
+              0.16748,
+              0.135283
+            ],
+            "warm_rows_per_second": 3884939.032255617
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              14132,
+              128
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 132,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1865424,
+              "artifact_bytes": 1119674,
+              "unique_rows": 8227,
+              "row_map_bytes": 113056,
+              "n_rows": 14132,
+              "row_bytes": 132,
+              "block_rows": 62,
+              "blocks": 133,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 133,
+              "zlib_blocks": 2,
+              "xor_blocks": 131,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 8227
+            },
+            "source_float32_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c",
+            "decoded_float32_sha256": "10f98491cca5738c4fb306c1e251797790526dfe45938ba06e2ee2efe3cc4cfd",
+            "table_sha256": "bd9783a3d3c6e18c205114125d51e249e7ca7ce9ada9225c6336f26f6999f596",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1467373101040721,
+          "representatives_sha256": "60748e55b9acc28c24131d6a450e53eb3159eb3c5a10b3cce254f21bcc2ced32",
+          "structurally_merged_rows": 5905,
+          "backend_artifact_bytes": 1120923,
+          "backend_with_key_registry_bytes": 1339401,
+          "backend_with_datrie_key_index_bytes": 1234635,
+          "full_model_serving_artifact_bytes": null,
+          "fidelity_vs_float32": {
+            "rows": 14132,
+            "minimum_cosine": 0.905058789974138,
+            "mean_cosine": 0.9978704723170204,
+            "p05_cosine": 0.9904815039656957,
+            "relative_l2_mean": 0.04185979944478432,
+            "relative_l2_p95": 0.13801117982453734,
+            "relative_l2_max": 0.43474475731290524,
+            "weighted_relative_l2_mean": 0.02644353692266584,
+            "weighted_relative_frobenius": 0.013530645935659193,
+            "weighted_mean_cosine": 0.9988350872672367,
+            "max_relative_norm_change": 0.011545051309837495
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 14132,
+            "minimum_cosine": 0.9052706198580938,
+            "mean_cosine": 0.9978740643616799,
+            "p05_cosine": 0.9904604786044254,
+            "relative_l2_mean": 0.03821097608579753,
+            "relative_l2_p95": 0.13834025060732943,
+            "relative_l2_max": 0.43431985848158156,
+            "weighted_relative_l2_mean": 0.021707155072084528,
+            "weighted_relative_frobenius": 0.011924654731844517,
+            "weighted_mean_cosine": 0.9988454252007132,
+            "max_relative_norm_change": 0.010090977690148559
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.640924,
+            "warm_p50_ms": 0.131092,
+            "warm_p95_ms": 0.1376161,
+            "warm_p99_ms": 0.15888297999999998,
+            "samples_ms": [
+              0.136261,
+              0.135283,
+              0.137168,
+              0.132001,
+              0.167899,
+              0.13668,
+              0.137239,
+              0.132,
+              0.132978,
+              0.13242,
+              0.133467,
+              0.132,
+              0.130603,
+              0.130114,
+              0.131092,
+              0.132,
+              0.131511,
+              0.131581,
+              0.131092,
+              0.129206,
+              0.130115,
+              0.130534,
+              0.131022,
+              0.131022,
+              0.131581,
+              0.130114,
+              0.131022,
+              0.131092,
+              0.131022,
+              0.130533,
+              0.130603,
+              0.130603,
+              0.129695,
+              0.130114,
+              0.144781,
+              0.132489,
+              0.131022,
+              0.130114,
+              0.130603,
+              0.131022
+            ],
+            "warm_rows_per_second": 3905654.0444878405
+          }
+        }
+      ],
+      "baseline_quality": {},
+      "training_row_sha256": "d0f54618325a4f2c9ffa3ab5779125a3b6d0c7192249f54dad23a6ea5e81304c"
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "rows": 11760,
+      "dim": 64,
+      "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+      "source_float32_bytes": 3010560,
+      "key_registry_bytes": 161725,
+      "unchanged_backbone_artifact_bytes": 294686,
+      "alternative_datrie_key_index_bytes": 95280,
+      "query_rows": 512,
+      "query_ids_sha256": "8ba8e1ab159a822d9159f679166b91955ebc405920cda85ccf24f213c3eff2ad",
+      "frequency_trace_sha256": "73ddaf0153da6d907ac6eef82bf819aaec23a0a5eb289cb0f3f91092c37eb7f0",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3010560,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "table_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.016872901935130358,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3011364,
+          "backend_with_key_registry_bytes": 3173089,
+          "backend_with_datrie_key_index_bytes": 3106644,
+          "full_model_serving_artifact_bytes": 3467775,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.372394,
+            "warm_p50_ms": 0.0487495,
+            "warm_p95_ms": 0.05017045,
+            "warm_p99_ms": 0.05178485,
+            "samples_ms": [
+              0.05252,
+              0.049238,
+              0.048749,
+              0.050146,
+              0.050077,
+              0.050635,
+              0.049727,
+              0.049658,
+              0.049239,
+              0.04868,
+              0.048749,
+              0.048749,
+              0.048749,
+              0.048749,
+              0.048749,
+              0.04819,
+              0.048749,
+              0.049657,
+              0.048261,
+              0.048261,
+              0.04875,
+              0.04875,
+              0.048261,
+              0.048261,
+              0.048191,
+              0.049727,
+              0.04826,
+              0.049238,
+              0.04826,
+              0.049168,
+              0.047771,
+              0.049238,
+              0.048749,
+              0.049168,
+              0.048679,
+              0.049238,
+              0.04868,
+              0.049169,
+              0.049168,
+              0.049657
+            ],
+            "warm_rows_per_second": 10502671.8222751
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448185687646842,
+            "character_perplexity": 5.724862712278213,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908740,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "table_sha256": "7fd6c0632f94d7e3cbf018cb6c5053182ccef84cb8d20764c97cde11eb40c13f",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2654925410170108,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909946,
+          "backend_with_key_registry_bytes": 3071671,
+          "backend_with_datrie_key_index_bytes": 3005226,
+          "full_model_serving_artifact_bytes": 3366357,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.765056,
+            "warm_p50_ms": 0.058666,
+            "warm_p95_ms": 0.06246595,
+            "warm_p99_ms": 0.07769494999999998,
+            "samples_ms": [
+              0.06146,
+              0.060972,
+              0.059574,
+              0.059085,
+              0.059575,
+              0.058667,
+              0.087092,
+              0.060483,
+              0.060971,
+              0.062438,
+              0.058177,
+              0.05727,
+              0.060483,
+              0.060623,
+              0.060483,
+              0.0572,
+              0.057759,
+              0.062997,
+              0.058667,
+              0.057689,
+              0.057759,
+              0.058666,
+              0.057689,
+              0.05727,
+              0.056851,
+              0.056781,
+              0.05727,
+              0.059574,
+              0.058667,
+              0.058248,
+              0.057689,
+              0.056781,
+              0.058666,
+              0.059156,
+              0.058248,
+              0.058666,
+              0.056711,
+              0.056292,
+              0.057689,
+              0.05727
+            ],
+            "warm_rows_per_second": 8727371.90195343
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448185687646842,
+            "character_perplexity": 5.724862712278213,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908740,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "table_sha256": "7fd6c0632f94d7e3cbf018cb6c5053182ccef84cb8d20764c97cde11eb40c13f",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3065303419716656,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909945,
+          "backend_with_key_registry_bytes": 3071670,
+          "backend_with_datrie_key_index_bytes": 3005225,
+          "full_model_serving_artifact_bytes": 3366356,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.735233,
+            "warm_p50_ms": 0.0586315,
+            "warm_p95_ms": 0.06439385,
+            "warm_p99_ms": 0.07321912,
+            "samples_ms": [
+              0.078013,
+              0.065721,
+              0.060483,
+              0.060063,
+              0.058666,
+              0.058667,
+              0.058248,
+              0.058597,
+              0.057689,
+              0.057759,
+              0.058597,
+              0.058666,
+              0.064324,
+              0.061042,
+              0.058667,
+              0.057689,
+              0.058178,
+              0.058178,
+              0.058178,
+              0.060552,
+              0.061879,
+              0.061111,
+              0.058666,
+              0.058178,
+              0.061461,
+              0.060134,
+              0.058178,
+              0.058178,
+              0.061042,
+              0.057759,
+              0.058178,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.056362,
+              0.060552,
+              0.060064,
+              0.058178,
+              0.058667,
+              0.056292
+            ],
+            "warm_rows_per_second": 8732507.26998286
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448185687646842,
+            "character_perplexity": 5.724862712278213,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908740,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "table_sha256": "7fd6c0632f94d7e3cbf018cb6c5053182ccef84cb8d20764c97cde11eb40c13f",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.26189110218547285,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909945,
+          "backend_with_key_registry_bytes": 3071670,
+          "backend_with_datrie_key_index_bytes": 3005225,
+          "full_model_serving_artifact_bytes": 3366356,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.714909,
+            "warm_p50_ms": 0.05727,
+            "warm_p95_ms": 0.05976374999999999,
+            "warm_p99_ms": 0.07620616,
+            "samples_ms": [
+              0.06202,
+              0.059645,
+              0.059156,
+              0.059644,
+              0.059574,
+              0.059644,
+              0.059505,
+              0.059226,
+              0.058108,
+              0.058667,
+              0.056782,
+              0.0572,
+              0.058247,
+              0.058178,
+              0.0572,
+              0.05727,
+              0.058666,
+              0.056781,
+              0.056851,
+              0.056781,
+              0.056781,
+              0.056362,
+              0.056781,
+              0.05727,
+              0.05727,
+              0.056711,
+              0.05727,
+              0.056712,
+              0.0572,
+              0.05727,
+              0.056781,
+              0.056781,
+              0.056293,
+              0.0572,
+              0.05727,
+              0.05727,
+              0.085276,
+              0.059086,
+              0.056781,
+              0.05727
+            ],
+            "warm_rows_per_second": 8940108.25912345
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448185687646842,
+            "character_perplexity": 5.724862712278213,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732409,
+              "unique_rows": 11022,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11022
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "6cf3900d9818e1125b3dc91dcd6f874c00edb8cfdc7a079205e0cffde4c1b6ad",
+            "table_sha256": "2567f4b0454d6af57ca2f55ba6cd49f3222af1b279da2463c2cc3c5b13d1728a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.28853103797882795,
+          "representatives_sha256": "5371f13a257c93dc8bd3ba977ad2b4ad230151b800443e84d16b0f013d279495",
+          "structurally_merged_rows": 738,
+          "backend_artifact_bytes": 2733614,
+          "backend_with_key_registry_bytes": 2895339,
+          "backend_with_datrie_key_index_bytes": 2828894,
+          "full_model_serving_artifact_bytes": 3190025,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9902119474867733,
+            "mean_cosine": 0.9999571484538186,
+            "p05_cosine": 0.9997077550982506,
+            "relative_l2_mean": 0.002177182218231527,
+            "relative_l2_p95": 0.0243536770022943,
+            "relative_l2_max": 0.14017569822550982,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9902119474867733,
+            "mean_cosine": 0.9999571484538186,
+            "p05_cosine": 0.9997077550982506,
+            "relative_l2_mean": 0.002177182218231527,
+            "relative_l2_p95": 0.0243536770022943,
+            "relative_l2_max": 0.14017569822550982,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.001969,
+            "warm_p50_ms": 0.05727,
+            "warm_p95_ms": 0.05971479999999999,
+            "warm_p99_ms": 0.06679269,
+            "samples_ms": [
+              0.061041,
+              0.059085,
+              0.059645,
+              0.058178,
+              0.059574,
+              0.059155,
+              0.059156,
+              0.058737,
+              0.059085,
+              0.059155,
+              0.058667,
+              0.058178,
+              0.05727,
+              0.056781,
+              0.0572,
+              0.07047,
+              0.059644,
+              0.058667,
+              0.058666,
+              0.05727,
+              0.057201,
+              0.056781,
+              0.058247,
+              0.057759,
+              0.05727,
+              0.05727,
+              0.0572,
+              0.056712,
+              0.056781,
+              0.056292,
+              0.057201,
+              0.05727,
+              0.057201,
+              0.056781,
+              0.056851,
+              0.0572,
+              0.056781,
+              0.0572,
+              0.058108,
+              0.05727
+            ],
+            "warm_rows_per_second": 8940108.25912345
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744775876674702,
+            "character_perplexity": 5.7246183111411995,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732175,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "6546cea75e4ce2644b34c2e2427d96e5a68cb4262381e713192aee48b5976c70",
+            "table_sha256": "4c31862bd204934f3613922f9772e5ebd35dc5a689f8d7ad9d504a359c29a4fe",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2955526781734079,
+          "representatives_sha256": "19694405b05c56a8d71896197ae0b471d362baf069fc0566c431ad753cc50974",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 2733380,
+          "backend_with_key_registry_bytes": 2895105,
+          "backend_with_datrie_key_index_bytes": 2828660,
+          "full_model_serving_artifact_bytes": 3189791,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9837543867790927,
+            "mean_cosine": 0.9999557670241228,
+            "p05_cosine": 0.9997070350940703,
+            "relative_l2_mean": 0.0021925403769333758,
+            "relative_l2_p95": 0.02447099841182412,
+            "relative_l2_max": 0.18061194633374375,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9837543867790927,
+            "mean_cosine": 0.9999557670241228,
+            "p05_cosine": 0.9997070350940703,
+            "relative_l2_mean": 0.0021925403769333758,
+            "relative_l2_p95": 0.02447099841182412,
+            "relative_l2_max": 0.18061194633374375,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.937574,
+            "warm_p50_ms": 0.0582125,
+            "warm_p95_ms": 0.0606928,
+            "warm_p99_ms": 0.06342505,
+            "samples_ms": [
+              0.060623,
+              0.060483,
+              0.059226,
+              0.058178,
+              0.058667,
+              0.060133,
+              0.058666,
+              0.058737,
+              0.058667,
+              0.058667,
+              0.058178,
+              0.057688,
+              0.057689,
+              0.057759,
+              0.058178,
+              0.057758,
+              0.057689,
+              0.058247,
+              0.058667,
+              0.058667,
+              0.058666,
+              0.058248,
+              0.057689,
+              0.062019,
+              0.058597,
+              0.064324,
+              0.058178,
+              0.056222,
+              0.057759,
+              0.058178,
+              0.056781,
+              0.058248,
+              0.058178,
+              0.059156,
+              0.05727,
+              0.057689,
+              0.05727,
+              0.05727,
+              0.056781,
+              0.059645
+            ],
+            "warm_rows_per_second": 8795361.820914753
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744775876674702,
+            "character_perplexity": 5.7246183111411995,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2731766,
+              "unique_rows": 11019,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11019
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "9cdfdee066702234e8f4c084e8f0eca32f8cdbadbc2444baced796bfb7506b98",
+            "table_sha256": "4416d44102413d97608dc33b22ce9eb461383ea9ee746b930dba00f5d13b4154",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.33247158606536686,
+          "representatives_sha256": "ef9dbb10d591cf7deb74509522f592834311f7886ae73e5fdb843b1be1d00ddc",
+          "structurally_merged_rows": 741,
+          "backend_artifact_bytes": 2732971,
+          "backend_with_key_registry_bytes": 2894696,
+          "backend_with_datrie_key_index_bytes": 2828251,
+          "full_model_serving_artifact_bytes": 3189382,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9732942287303055,
+            "mean_cosine": 0.9999489751159576,
+            "p05_cosine": 0.9997031993162947,
+            "relative_l2_mean": 0.002249751455277053,
+            "relative_l2_p95": 0.024490715699937732,
+            "relative_l2_max": 0.23161634472212844,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9732942287303055,
+            "mean_cosine": 0.9999489751159576,
+            "p05_cosine": 0.9997031993162947,
+            "relative_l2_mean": 0.002249751455277053,
+            "relative_l2_p95": 0.024490715699937732,
+            "relative_l2_max": 0.23161634472212844,
+            "weighted_relative_l2_mean": 0.0008977103354020354,
+            "weighted_relative_frobenius": 0.0052940877733579465,
+            "weighted_mean_cosine": 0.9999852803166117,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.272464,
+            "warm_p50_ms": 0.058667,
+            "warm_p95_ms": 0.06201884999999999,
+            "warm_p99_ms": 0.07753276999999999,
+            "samples_ms": [
+              0.063346,
+              0.060971,
+              0.059225,
+              0.059086,
+              0.059156,
+              0.058177,
+              0.058667,
+              0.058248,
+              0.058178,
+              0.058178,
+              0.058247,
+              0.058108,
+              0.058666,
+              0.058666,
+              0.058667,
+              0.058247,
+              0.058178,
+              0.058667,
+              0.060552,
+              0.059156,
+              0.058667,
+              0.058666,
+              0.057689,
+              0.058667,
+              0.086603,
+              0.059574,
+              0.059225,
+              0.056851,
+              0.061949,
+              0.060063,
+              0.058667,
+              0.058248,
+              0.058178,
+              0.058178,
+              0.058178,
+              0.05727,
+              0.056292,
+              0.061531,
+              0.061112,
+              0.060064
+            ],
+            "warm_rows_per_second": 8727223.14077761
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744775876674702,
+            "character_perplexity": 5.7246183111411995,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.269117868789314e-05,
+            "mean_prediction_kl_nats": 1.4920202650035391e-06,
+            "prediction_kl_p99_nats": 2.4167480924158577e-05,
+            "maximum_prediction_kl_nats": 0.005274976667000143,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29146748781204224,
+            "maximum_per_target_cross_entropy_increase": 0.03230166435241699
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2731011,
+              "unique_rows": 11016,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11016
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "d9f4ff5c93b675a11e75a64012210089806f67f607a4f3e4e2e2e85387ad54db",
+            "table_sha256": "3527027d88a1b20f04a9b9fd658ee9b9eb440e71672b9b6515041a90a4c5b460",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25376729504205287,
+          "representatives_sha256": "e309956b4ee73e9916fb8c464f341e509a700946436d6e62b17fcf80ce54fdbc",
+          "structurally_merged_rows": 744,
+          "backend_artifact_bytes": 2732216,
+          "backend_with_key_registry_bytes": 2893941,
+          "backend_with_datrie_key_index_bytes": 2827496,
+          "full_model_serving_artifact_bytes": 3188627,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9601687946809417,
+            "mean_cosine": 0.999939420382366,
+            "p05_cosine": 0.9997003626652597,
+            "relative_l2_mean": 0.0023194666962265153,
+            "relative_l2_p95": 0.02470920431965932,
+            "relative_l2_max": 0.2817572783926916,
+            "weighted_relative_l2_mean": 0.0009328916835455479,
+            "weighted_relative_frobenius": 0.006194876167627727,
+            "weighted_mean_cosine": 0.9999803967664052,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9601687946809417,
+            "mean_cosine": 0.999939420382366,
+            "p05_cosine": 0.9997003626652597,
+            "relative_l2_mean": 0.0023194666962265153,
+            "relative_l2_p95": 0.02470920431965932,
+            "relative_l2_max": 0.2817572783926916,
+            "weighted_relative_l2_mean": 0.0009328916835455479,
+            "weighted_relative_frobenius": 0.006194876167627727,
+            "weighted_mean_cosine": 0.9999803967664052,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.239429,
+            "warm_p50_ms": 0.05727,
+            "warm_p95_ms": 0.061094199999999994,
+            "warm_p99_ms": 0.07811394999999999,
+            "samples_ms": [
+              0.059156,
+              0.060552,
+              0.063416,
+              0.060972,
+              0.059715,
+              0.058597,
+              0.058178,
+              0.056781,
+              0.0572,
+              0.056781,
+              0.0572,
+              0.0572,
+              0.05727,
+              0.0572,
+              0.05727,
+              0.056851,
+              0.05727,
+              0.05727,
+              0.056362,
+              0.05727,
+              0.0572,
+              0.056292,
+              0.05727,
+              0.056781,
+              0.056712,
+              0.058178,
+              0.087511,
+              0.060553,
+              0.058666,
+              0.056222,
+              0.058178,
+              0.055803,
+              0.056292,
+              0.056781,
+              0.056711,
+              0.0572,
+              0.057759,
+              0.057759,
+              0.058737,
+              0.057689
+            ],
+            "warm_rows_per_second": 8940108.25912345
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744914414661637,
+            "character_perplexity": 5.725411443176186,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.585049031779498e-05,
+            "mean_prediction_kl_nats": 2.047808473627732e-05,
+            "prediction_kl_p99_nats": 2.5371232452318965e-05,
+            "maximum_prediction_kl_nats": 0.07808918028685391,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.7477188110351562,
+            "maximum_per_target_cross_entropy_increase": 0.7326599359512329
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.585049031779498e-05,
+            "mean_prediction_kl_nats": 2.047808473627732e-05,
+            "prediction_kl_p99_nats": 2.5371232452318965e-05,
+            "maximum_prediction_kl_nats": 0.07808918028685391,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.7477188110351562,
+            "maximum_per_target_cross_entropy_increase": 0.7326599359512329
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2730517,
+              "unique_rows": 11014,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11014
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "07d3c6bde8799f757a6cd2c8b7fc5c6af26686f9470a270392ea00717ead9319",
+            "table_sha256": "47ea53506ce896d19ab1f81929ebf7c54d34616813ab228b077aa83d41289e87",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2493922938592732,
+          "representatives_sha256": "7107e68ec326b0530464a531e9230aa1faa8377c353b27c623ae49607fc34677",
+          "structurally_merged_rows": 746,
+          "backend_artifact_bytes": 2731722,
+          "backend_with_key_registry_bytes": 2893447,
+          "backend_with_datrie_key_index_bytes": 2827002,
+          "full_model_serving_artifact_bytes": 3188133,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9180803831583273,
+            "mean_cosine": 0.9999261414854912,
+            "p05_cosine": 0.9996995621760043,
+            "relative_l2_mean": 0.002386593403605294,
+            "relative_l2_p95": 0.024880453595176592,
+            "relative_l2_max": 0.4052832618653121,
+            "weighted_relative_l2_mean": 0.001579007164529692,
+            "weighted_relative_frobenius": 0.012000382636823912,
+            "weighted_mean_cosine": 0.9998503171798633,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9180803831583273,
+            "mean_cosine": 0.9999261414854912,
+            "p05_cosine": 0.9996995621760043,
+            "relative_l2_mean": 0.002386593403605294,
+            "relative_l2_p95": 0.024880453595176592,
+            "relative_l2_max": 0.4052832618653121,
+            "weighted_relative_l2_mean": 0.001579007164529692,
+            "weighted_relative_frobenius": 0.012000382636823912,
+            "weighted_mean_cosine": 0.9998503171798633,
+            "max_relative_norm_change": 0.010005118677483
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.146191,
+            "warm_p50_ms": 0.057689,
+            "warm_p95_ms": 0.060157449999999994,
+            "warm_p99_ms": 0.06807802999999998,
+            "samples_ms": [
+              0.060133,
+              0.060063,
+              0.057689,
+              0.057689,
+              0.072845,
+              0.059645,
+              0.057759,
+              0.057759,
+              0.058177,
+              0.0572,
+              0.0572,
+              0.05727,
+              0.058178,
+              0.058178,
+              0.057758,
+              0.05727,
+              0.057689,
+              0.057759,
+              0.05727,
+              0.056781,
+              0.0572,
+              0.0572,
+              0.057759,
+              0.057269,
+              0.05727,
+              0.056362,
+              0.058108,
+              0.056292,
+              0.060622,
+              0.059994,
+              0.058247,
+              0.058597,
+              0.057758,
+              0.056711,
+              0.056711,
+              0.056223,
+              0.05727,
+              0.058666,
+              0.057689,
+              0.05727
+            ],
+            "warm_rows_per_second": 8875175.510062577
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7452017749241024,
+            "character_perplexity": 5.727056935324424,
+            "next_character_accuracy": 0.5,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0003832795922784004,
+            "mean_prediction_kl_nats": 7.977040469276395e-05,
+            "prediction_kl_p99_nats": 0.0002471613945079618,
+            "maximum_prediction_kl_nats": 0.07808918028685391,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.7477188110351562,
+            "maximum_per_target_cross_entropy_increase": 0.7326599359512329
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0003832795922784004,
+            "mean_prediction_kl_nats": 7.977040469276395e-05,
+            "prediction_kl_p99_nats": 0.0002471613945079618,
+            "maximum_prediction_kl_nats": 0.07808918028685391,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.7477188110351562,
+            "maximum_per_target_cross_entropy_increase": 0.7326599359512329
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 1505280,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "d87571fa9337131f33612c6b040cbda96d6836e255a7c1cac1b5b07b4f12bd42",
+            "table_sha256": "080d6efb61408847148fbcc3c917499b8c29966c124b53c22e9aeca49ffbf968",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.03281928994692862,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1506085,
+          "backend_with_key_registry_bytes": 1667810,
+          "backend_with_datrie_key_index_bytes": 1601365,
+          "full_model_serving_artifact_bytes": 1962496,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999589501113,
+            "mean_cosine": 0.9999999792496315,
+            "p05_cosine": 0.9999999715554034,
+            "relative_l2_mean": 0.00020645360269819725,
+            "relative_l2_p95": 0.00024229765914773267,
+            "relative_l2_max": 0.000297725575888126,
+            "weighted_relative_l2_mean": 0.0001896498664291317,
+            "weighted_relative_frobenius": 0.00020927156759669916,
+            "weighted_mean_cosine": 0.9999999809188298,
+            "max_relative_norm_change": 0.00017913432724310765
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.394115,
+            "warm_p50_ms": 0.13318750000000001,
+            "warm_p95_ms": 0.1390331,
+            "warm_p99_ms": 0.16223252,
+            "samples_ms": [
+              0.135352,
+              0.132489,
+              0.133885,
+              0.172229,
+              0.137658,
+              0.134305,
+              0.132489,
+              0.133397,
+              0.132978,
+              0.133955,
+              0.132978,
+              0.132419,
+              0.133397,
+              0.132489,
+              0.133956,
+              0.132419,
+              0.138146,
+              0.132489,
+              0.132419,
+              0.132489,
+              0.132978,
+              0.132489,
+              0.133956,
+              0.132489,
+              0.138635,
+              0.133886,
+              0.131511,
+              0.132909,
+              0.133397,
+              0.132489,
+              0.132908,
+              0.133467,
+              0.146597,
+              0.134794,
+              0.133955,
+              0.131581,
+              0.132978,
+              0.133816,
+              0.134375,
+              0.132489
+            ],
+            "warm_rows_per_second": 3844204.5987799154
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448141552828185,
+            "character_perplexity": 5.724837445756205,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.413472126263009e-06,
+            "mean_prediction_kl_nats": 4.48062978350823e-09,
+            "prediction_kl_p99_nats": 3.0549903725941194e-08,
+            "maximum_prediction_kl_nats": 1.9802621999273275e-07,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001046895980834961,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491621,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "d87571fa9337131f33612c6b040cbda96d6836e255a7c1cac1b5b07b4f12bd42",
+            "table_sha256": "6374e32276827cec1fe4c3e58baa23a84a6803254c713026972f2f0768e8c818",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15144531498663127,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492828,
+          "backend_with_key_registry_bytes": 1654553,
+          "backend_with_datrie_key_index_bytes": 1588108,
+          "full_model_serving_artifact_bytes": 1949239,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999589501113,
+            "mean_cosine": 0.9999999792496315,
+            "p05_cosine": 0.9999999715554034,
+            "relative_l2_mean": 0.00020645360269819725,
+            "relative_l2_p95": 0.00024229765914773267,
+            "relative_l2_max": 0.000297725575888126,
+            "weighted_relative_l2_mean": 0.0001896498664291317,
+            "weighted_relative_frobenius": 0.00020927156759669916,
+            "weighted_mean_cosine": 0.9999999809188298,
+            "max_relative_norm_change": 0.00017913432724310765
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.872925,
+            "warm_p50_ms": 0.14146350000000002,
+            "warm_p95_ms": 0.14627579999999998,
+            "warm_p99_ms": 0.16738487999999999,
+            "samples_ms": [
+              0.144712,
+              0.141848,
+              0.141918,
+              0.156095,
+              0.140939,
+              0.141988,
+              0.14101,
+              0.141498,
+              0.141429,
+              0.141918,
+              0.14101,
+              0.14094,
+              0.140032,
+              0.141079,
+              0.141429,
+              0.141499,
+              0.141499,
+              0.140521,
+              0.141499,
+              0.141918,
+              0.141498,
+              0.14094,
+              0.142407,
+              0.140032,
+              0.14094,
+              0.140521,
+              0.14094,
+              0.141918,
+              0.141988,
+              0.141498,
+              0.174603,
+              0.145759,
+              0.141428,
+              0.141987,
+              0.141359,
+              0.140032,
+              0.139613,
+              0.140102,
+              0.141499,
+              0.14094
+            ],
+            "warm_rows_per_second": 3619308.160762316
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448141552828185,
+            "character_perplexity": 5.724837445756205,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.413472126263009e-06,
+            "mean_prediction_kl_nats": 4.48062978350823e-09,
+            "prediction_kl_p99_nats": 3.0549903725941194e-08,
+            "maximum_prediction_kl_nats": 1.9802621999273275e-07,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001046895980834961,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491621,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "d87571fa9337131f33612c6b040cbda96d6836e255a7c1cac1b5b07b4f12bd42",
+            "table_sha256": "6374e32276827cec1fe4c3e58baa23a84a6803254c713026972f2f0768e8c818",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.19145602802745998,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492827,
+          "backend_with_key_registry_bytes": 1654552,
+          "backend_with_datrie_key_index_bytes": 1588107,
+          "full_model_serving_artifact_bytes": 1949238,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999589501113,
+            "mean_cosine": 0.9999999792496315,
+            "p05_cosine": 0.9999999715554034,
+            "relative_l2_mean": 0.00020645360269819725,
+            "relative_l2_p95": 0.00024229765914773267,
+            "relative_l2_max": 0.000297725575888126,
+            "weighted_relative_l2_mean": 0.0001896498664291317,
+            "weighted_relative_frobenius": 0.00020927156759669916,
+            "weighted_mean_cosine": 0.9999999809188298,
+            "max_relative_norm_change": 0.00017913432724310765
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.83081,
+            "warm_p50_ms": 0.1403115,
+            "warm_p95_ms": 0.14467264999999999,
+            "warm_p99_ms": 0.16306738999999998,
+            "samples_ms": [
+              0.144292,
+              0.141429,
+              0.141918,
+              0.141498,
+              0.14094,
+              0.141499,
+              0.141499,
+              0.151905,
+              0.141918,
+              0.141498,
+              0.14094,
+              0.140521,
+              0.14059,
+              0.140032,
+              0.140032,
+              0.140032,
+              0.140031,
+              0.139613,
+              0.140939,
+              0.139543,
+              0.140031,
+              0.139613,
+              0.139054,
+              0.140032,
+              0.139543,
+              0.139543,
+              0.141429,
+              0.139543,
+              0.139543,
+              0.141429,
+              0.139543,
+              0.140032,
+              0.140102,
+              0.140032,
+              0.139543,
+              0.170204,
+              0.141918,
+              0.140521,
+              0.139613,
+              0.14101
+            ],
+            "warm_rows_per_second": 3649023.779234061
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448141552828185,
+            "character_perplexity": 5.724837445756205,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.413472126263009e-06,
+            "mean_prediction_kl_nats": 4.48062978350823e-09,
+            "prediction_kl_p99_nats": 3.0549903725941194e-08,
+            "maximum_prediction_kl_nats": 1.9802621999273275e-07,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001046895980834961,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491621,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "d87571fa9337131f33612c6b040cbda96d6836e255a7c1cac1b5b07b4f12bd42",
+            "table_sha256": "6374e32276827cec1fe4c3e58baa23a84a6803254c713026972f2f0768e8c818",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1503708059899509,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492827,
+          "backend_with_key_registry_bytes": 1654552,
+          "backend_with_datrie_key_index_bytes": 1588107,
+          "full_model_serving_artifact_bytes": 1949238,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999589501113,
+            "mean_cosine": 0.9999999792496315,
+            "p05_cosine": 0.9999999715554034,
+            "relative_l2_mean": 0.00020645360269819725,
+            "relative_l2_p95": 0.00024229765914773267,
+            "relative_l2_max": 0.000297725575888126,
+            "weighted_relative_l2_mean": 0.0001896498664291317,
+            "weighted_relative_frobenius": 0.00020927156759669916,
+            "weighted_mean_cosine": 0.9999999809188298,
+            "max_relative_norm_change": 0.00017913432724310765
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.864404,
+            "warm_p50_ms": 0.1409745,
+            "warm_p95_ms": 0.14347580000000001,
+            "warm_p99_ms": 0.15073919,
+            "samples_ms": [
+              0.145201,
+              0.142826,
+              0.140521,
+              0.141009,
+              0.14094,
+              0.143385,
+              0.141918,
+              0.141079,
+              0.141429,
+              0.142476,
+              0.140032,
+              0.140032,
+              0.141499,
+              0.141498,
+              0.141429,
+              0.141429,
+              0.14094,
+              0.140032,
+              0.14094,
+              0.141429,
+              0.141499,
+              0.141429,
+              0.140521,
+              0.141918,
+              0.140521,
+              0.141498,
+              0.15428,
+              0.142407,
+              0.14052,
+              0.140521,
+              0.14101,
+              0.140032,
+              0.140032,
+              0.140521,
+              0.140521,
+              0.14052,
+              0.140521,
+              0.14052,
+              0.140521,
+              0.139543
+            ],
+            "warm_rows_per_second": 3631862.499955666
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7448141552828185,
+            "character_perplexity": 5.724837445756205,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.413472126263009e-06,
+            "mean_prediction_kl_nats": 4.48062978350823e-09,
+            "prediction_kl_p99_nats": 3.0549903725941194e-08,
+            "maximum_prediction_kl_nats": 1.9802621999273275e-07,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001046895980834961,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404390,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "50a8e89da6a04132e68a9177c2801d3c8005d4de0c9d1bd4900df2d6599169ed",
+            "table_sha256": "65d6ac9b7c9a13ac811d321eb32c45152a51f7654e70c055337f4a1927e37bcc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14685038197785616,
+          "representatives_sha256": "9dae2e8d991c0156bb6ef113d07f5a8b76cf2d8848bd9336bc01b46acc0690f2",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 1405595,
+          "backend_with_key_registry_bytes": 1567320,
+          "backend_with_datrie_key_index_bytes": 1500875,
+          "full_model_serving_artifact_bytes": 1862006,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9902142136992986,
+            "mean_cosine": 0.9999570241423484,
+            "p05_cosine": 0.9997069046578577,
+            "relative_l2_mean": 0.002374939974054794,
+            "relative_l2_p95": 0.02446510401433875,
+            "relative_l2_max": 0.14016502249394194,
+            "weighted_relative_l2_mean": 0.0010836185932586516,
+            "weighted_relative_frobenius": 0.005302751473250229,
+            "weighted_mean_cosine": 0.9999851985547283,
+            "max_relative_norm_change": 0.01006602117159563
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9902144854182734,
+            "mean_cosine": 0.9999570398592639,
+            "p05_cosine": 0.999706774862023,
+            "relative_l2_mean": 0.0021816109990323834,
+            "relative_l2_p95": 0.024439317221512102,
+            "relative_l2_max": 0.1401612936749213,
+            "weighted_relative_l2_mean": 0.0009004591305039904,
+            "weighted_relative_frobenius": 0.005299381939658822,
+            "weighted_mean_cosine": 0.9999852152415863,
+            "max_relative_norm_change": 0.010091674015100499
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.546905,
+            "warm_p50_ms": 0.141429,
+            "warm_p95_ms": 0.14389729999999998,
+            "warm_p99_ms": 0.16187839999999998,
+            "samples_ms": [
+              0.145689,
+              0.143733,
+              0.143803,
+              0.14094,
+              0.14101,
+              0.140451,
+              0.141987,
+              0.141429,
+              0.141918,
+              0.143244,
+              0.141009,
+              0.142337,
+              0.141499,
+              0.14094,
+              0.140032,
+              0.140521,
+              0.141498,
+              0.141429,
+              0.14094,
+              0.141009,
+              0.14101,
+              0.141429,
+              0.141498,
+              0.172229,
+              0.143315,
+              0.141429,
+              0.141988,
+              0.141987,
+              0.14094,
+              0.141499,
+              0.140521,
+              0.140521,
+              0.14101,
+              0.141358,
+              0.14101,
+              0.141429,
+              0.141498,
+              0.140032,
+              0.14101,
+              0.140939
+            ],
+            "warm_rows_per_second": 3620191.0499261115
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7447695886431893,
+            "character_perplexity": 5.724582314674034,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.8978921988153566e-05,
+            "mean_prediction_kl_nats": 1.5003648247710951e-06,
+            "prediction_kl_p99_nats": 2.4263089393849343e-05,
+            "maximum_prediction_kl_nats": 0.005281839625376909,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29156380891799927,
+            "maximum_per_target_cross_entropy_increase": 0.03223705291748047
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.4565646551129405e-05,
+            "mean_prediction_kl_nats": 1.4950874560512e-06,
+            "prediction_kl_p99_nats": 2.4156584127195344e-05,
+            "maximum_prediction_kl_nats": 0.005281004070749687,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29161351919174194,
+            "maximum_per_target_cross_entropy_increase": 0.0321347713470459
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404305,
+              "unique_rows": 11020,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11020
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "29825b4a87a28b2025ca51c27e3cae5b6a3bfcd0c05afdad9b26976522531df5",
+            "table_sha256": "6fe923c28cbf5215b28698d8f27a6bc756f6dcd846bf687e0a8148ea5c93b4a1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14199619903229177,
+          "representatives_sha256": "f0ec87af3587e337c1c4c8edb2557719b558517a81d43d2a606f47308b7cb7fe",
+          "structurally_merged_rows": 740,
+          "backend_artifact_bytes": 1405510,
+          "backend_with_key_registry_bytes": 1567235,
+          "backend_with_datrie_key_index_bytes": 1500790,
+          "full_model_serving_artifact_bytes": 1861921,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9837543408059701,
+            "mean_cosine": 0.9999556427102196,
+            "p05_cosine": 0.9997066138329546,
+            "relative_l2_mean": 0.0023902789999247576,
+            "relative_l2_p95": 0.024466222694217606,
+            "relative_l2_max": 0.1806133927282591,
+            "weighted_relative_l2_mean": 0.0010836185932586516,
+            "weighted_relative_frobenius": 0.005302751473250229,
+            "weighted_mean_cosine": 0.9999851985547283,
+            "max_relative_norm_change": 0.01006602117159563
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9837551288575086,
+            "mean_cosine": 0.9999556584926701,
+            "p05_cosine": 0.9997063715966455,
+            "relative_l2_mean": 0.002196970119194705,
+            "relative_l2_p95": 0.024462612396548088,
+            "relative_l2_max": 0.18062325310889688,
+            "weighted_relative_l2_mean": 0.0009004591305039904,
+            "weighted_relative_frobenius": 0.005299381939658822,
+            "weighted_mean_cosine": 0.9999852152415863,
+            "max_relative_norm_change": 0.010091674015100499
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.499623,
+            "warm_p50_ms": 0.14101,
+            "warm_p95_ms": 0.14609409999999998,
+            "warm_p99_ms": 0.16184239,
+            "samples_ms": [
+              0.145689,
+              0.143873,
+              0.142476,
+              0.142337,
+              0.141918,
+              0.142895,
+              0.141009,
+              0.140451,
+              0.140521,
+              0.153791,
+              0.141988,
+              0.14101,
+              0.139543,
+              0.14101,
+              0.14052,
+              0.14094,
+              0.141498,
+              0.141009,
+              0.141499,
+              0.14101,
+              0.140032,
+              0.140032,
+              0.140032,
+              0.141918,
+              0.139612,
+              0.14101,
+              0.141499,
+              0.141498,
+              0.141429,
+              0.140101,
+              0.14101,
+              0.14101,
+              0.14094,
+              0.140521,
+              0.141428,
+              0.140521,
+              0.140521,
+              0.16699,
+              0.144711,
+              0.141498
+            ],
+            "warm_rows_per_second": 3630948.159704985
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7447695886431893,
+            "character_perplexity": 5.724582314674034,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.8978921988153566e-05,
+            "mean_prediction_kl_nats": 1.5003648247710951e-06,
+            "prediction_kl_p99_nats": 2.4263089393849343e-05,
+            "maximum_prediction_kl_nats": 0.005281839625376909,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29156380891799927,
+            "maximum_per_target_cross_entropy_increase": 0.03223705291748047
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.4565646551129405e-05,
+            "mean_prediction_kl_nats": 1.4950874560512e-06,
+            "prediction_kl_p99_nats": 2.4156584127195344e-05,
+            "maximum_prediction_kl_nats": 0.005281004070749687,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29161351919174194,
+            "maximum_per_target_cross_entropy_increase": 0.0321347713470459
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404121,
+              "unique_rows": 11018,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11018
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "8537fda851a863a3a84029a9a35810e06ec5375cec16d553c57aea00962d9e0f",
+            "table_sha256": "f120fb1d0d68e8d285e8011efd6ac02134d293f62c57e01123df89b484ffaf92",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1425056920852512,
+          "representatives_sha256": "9c79b707e53fa8c6b68a2764aed4fc2e78871fde3072fd85b38371484c85b693",
+          "structurally_merged_rows": 742,
+          "backend_artifact_bytes": 1405326,
+          "backend_with_key_registry_bytes": 1567051,
+          "backend_with_datrie_key_index_bytes": 1500606,
+          "full_model_serving_artifact_bytes": 1861737,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9732970565929171,
+            "mean_cosine": 0.9999488516192019,
+            "p05_cosine": 0.9997014529554792,
+            "relative_l2_mean": 0.002447449892319762,
+            "relative_l2_p95": 0.024615140375736734,
+            "relative_l2_max": 0.23160677521428877,
+            "weighted_relative_l2_mean": 0.0010836185932586516,
+            "weighted_relative_frobenius": 0.005302751473250229,
+            "weighted_mean_cosine": 0.9999851985547283,
+            "max_relative_norm_change": 0.01006602117159563
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9732851261570991,
+            "mean_cosine": 0.9999488651117413,
+            "p05_cosine": 0.9997016279208365,
+            "relative_l2_mean": 0.002254190340158536,
+            "relative_l2_p95": 0.024584885109046436,
+            "relative_l2_max": 0.23163816052831235,
+            "weighted_relative_l2_mean": 0.0009004591305039904,
+            "weighted_relative_frobenius": 0.005299381939658822,
+            "weighted_mean_cosine": 0.9999852152415863,
+            "max_relative_norm_change": 0.010091674015100499
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.541178,
+            "warm_p50_ms": 0.1405205,
+            "warm_p95_ms": 0.14438294999999998,
+            "warm_p99_ms": 0.14938222999999998,
+            "samples_ms": [
+              0.144362,
+              0.141917,
+              0.141498,
+              0.141918,
+              0.139613,
+              0.141917,
+              0.139543,
+              0.139543,
+              0.140591,
+              0.140101,
+              0.140032,
+              0.140032,
+              0.152324,
+              0.144292,
+              0.141917,
+              0.140521,
+              0.140451,
+              0.139613,
+              0.140101,
+              0.140102,
+              0.14094,
+              0.142476,
+              0.144781,
+              0.142825,
+              0.140521,
+              0.14101,
+              0.140101,
+              0.140521,
+              0.139474,
+              0.140521,
+              0.140032,
+              0.14101,
+              0.140032,
+              0.140032,
+              0.14052,
+              0.140521,
+              0.140451,
+              0.139543,
+              0.139612,
+              0.140102
+            ],
+            "warm_rows_per_second": 3643596.485921983
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7447695886431893,
+            "character_perplexity": 5.724582314674034,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.8978921988153566e-05,
+            "mean_prediction_kl_nats": 1.5003648247710951e-06,
+            "prediction_kl_p99_nats": 2.4263089393849343e-05,
+            "maximum_prediction_kl_nats": 0.005281839625376909,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29156380891799927,
+            "maximum_per_target_cross_entropy_increase": 0.03223705291748047
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.4565646551129405e-05,
+            "mean_prediction_kl_nats": 1.4950874560512e-06,
+            "prediction_kl_p99_nats": 2.4156584127195344e-05,
+            "maximum_prediction_kl_nats": 0.005281004070749687,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.29161351919174194,
+            "maximum_per_target_cross_entropy_increase": 0.0321347713470459
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1403739,
+              "unique_rows": 11015,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11015
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "e51ee71e2228cb2bae4d140947b94f98089beb87d8b3da0238138235aae919ec",
+            "table_sha256": "367b1f82a4867aabb4b2fe45ee290ce4f2b35a47a9d747a475ae28d5dc4e452a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1405726228840649,
+          "representatives_sha256": "6bd3fe3deae00366f6cd75d1d9d6f11fba4db36859d0dd3ee02f2410ca6d3924",
+          "structurally_merged_rows": 745,
+          "backend_artifact_bytes": 1404944,
+          "backend_with_key_registry_bytes": 1566669,
+          "backend_with_datrie_key_index_bytes": 1500224,
+          "full_model_serving_artifact_bytes": 1861355,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.960155144819022,
+            "mean_cosine": 0.999939296270149,
+            "p05_cosine": 0.9997002578366734,
+            "relative_l2_mean": 0.0025171110293148212,
+            "relative_l2_p95": 0.024786348941689802,
+            "relative_l2_max": 0.28180178923424,
+            "weighted_relative_l2_mean": 0.0011187750817993856,
+            "weighted_relative_frobenius": 0.006202467465180739,
+            "weighted_mean_cosine": 0.9999803141270506,
+            "max_relative_norm_change": 0.01006602117159563
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9601560142271234,
+            "mean_cosine": 0.9999393090213079,
+            "p05_cosine": 0.9997002081246212,
+            "relative_l2_mean": 0.0023239118823211095,
+            "relative_l2_p95": 0.024743986042518068,
+            "relative_l2_max": 0.2818126270142,
+            "weighted_relative_l2_mean": 0.0009356451784137656,
+            "weighted_relative_frobenius": 0.006199542749492902,
+            "weighted_mean_cosine": 0.9999803306355224,
+            "max_relative_norm_change": 0.010091674015100499
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.450384,
+            "warm_p50_ms": 0.14149850000000003,
+            "warm_p95_ms": 0.14665644999999994,
+            "warm_p99_ms": 0.16485845999999998,
+            "samples_ms": [
+              0.145759,
+              0.143873,
+              0.163708,
+              0.145689,
+              0.142406,
+              0.141918,
+              0.144362,
+              0.143315,
+              0.142826,
+              0.145689,
+              0.143873,
+              0.143314,
+              0.140451,
+              0.14101,
+              0.140521,
+              0.14101,
+              0.139612,
+              0.141918,
+              0.141499,
+              0.141009,
+              0.141009,
+              0.139543,
+              0.140032,
+              0.141499,
+              0.14094,
+              0.14094,
+              0.139613,
+              0.140032,
+              0.140032,
+              0.165594,
+              0.145759,
+              0.141917,
+              0.144362,
+              0.14101,
+              0.139543,
+              0.141987,
+              0.141429,
+              0.141498,
+              0.140521,
+              0.14101
+            ],
+            "warm_rows_per_second": 3618412.9160379786
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7449081665379969,
+            "character_perplexity": 5.725375670209355,
+            "next_character_accuracy": 0.4998466492869192,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.960178731304851e-05,
+            "mean_prediction_kl_nats": 2.0500548492147738e-05,
+            "prediction_kl_p99_nats": 2.5340378747971894e-05,
+            "maximum_prediction_kl_nats": 0.07817244889218078,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.7477798461914062,
+            "maximum_per_target_cross_entropy_increase": 0.7331861257553101
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.40156743748698e-05,
+            "mean_prediction_kl_nats": 2.0480700068925953e-05,
+            "prediction_kl_p99_nats": 2.5365348219468226e-05,
+            "maximum_prediction_kl_nats": 0.07807902524619609,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.7478551864624023,
+            "maximum_per_target_cross_entropy_increase": 0.7328281402587891
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1403425,
+              "unique_rows": 11013,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 172,
+              "zlib_blocks": 172,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11013
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "3a46124e28abdca5775ac021026a983e1e9350a898fc0c14c4cd53e040fba201",
+            "table_sha256": "28a8198f4dcf9ea36a8bd4fc23c634f230f93309d74d90de5fca62247f568e33",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1806480789091438,
+          "representatives_sha256": "0a681ee7bd1e11d04748c0880d3282b57af0a234af552328129aa424dfc43422",
+          "structurally_merged_rows": 747,
+          "backend_artifact_bytes": 1404630,
+          "backend_with_key_registry_bytes": 1566355,
+          "backend_with_datrie_key_index_bytes": 1499910,
+          "full_model_serving_artifact_bytes": 1861041,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9180787725868748,
+            "mean_cosine": 0.9999260172138794,
+            "p05_cosine": 0.999697042210066,
+            "relative_l2_mean": 0.002584209073013027,
+            "relative_l2_p95": 0.024874615513097185,
+            "relative_l2_max": 0.40529397587175664,
+            "weighted_relative_l2_mean": 0.0017645788534315207,
+            "weighted_relative_frobenius": 0.012004533806314922,
+            "weighted_mean_cosine": 0.9998502321939515,
+            "max_relative_norm_change": 0.01006602117159563
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9180784295526778,
+            "mean_cosine": 0.9999260305791812,
+            "p05_cosine": 0.9996978534310647,
+            "relative_l2_mean": 0.0023910388290498586,
+            "relative_l2_p95": 0.024873201335340264,
+            "relative_l2_max": 0.40530101614691605,
+            "weighted_relative_l2_mean": 0.0015817841165046895,
+            "weighted_relative_frobenius": 0.012002918545574105,
+            "weighted_mean_cosine": 0.9998502493311484,
+            "max_relative_norm_change": 0.010091674015100499
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.464074,
+            "warm_p50_ms": 0.1426505,
+            "warm_p95_ms": 0.1932726,
+            "warm_p99_ms": 0.21362054999999996,
+            "samples_ms": [
+              0.143873,
+              0.142895,
+              0.142406,
+              0.14101,
+              0.140032,
+              0.141498,
+              0.140032,
+              0.14094,
+              0.140451,
+              0.153791,
+              0.184381,
+              0.175092,
+              0.188782,
+              0.196324,
+              0.183124,
+              0.185429,
+              0.188851,
+              0.18927,
+              0.224679,
+              0.193112,
+              0.18452,
+              0.183544,
+              0.179283,
+              0.18075,
+              0.187804,
+              0.173137,
+              0.144223,
+              0.139124,
+              0.139054,
+              0.139124,
+              0.139124,
+              0.140031,
+              0.140032,
+              0.140521,
+              0.139124,
+              0.139124,
+              0.139543,
+              0.140521,
+              0.139124,
+              0.140032
+            ],
+            "warm_rows_per_second": 3589191.7658893587
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7451954546843569,
+            "character_perplexity": 5.7270207390659404,
+            "next_character_accuracy": 0.5,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00037695695009420585,
+            "mean_prediction_kl_nats": 7.977080127673468e-05,
+            "prediction_kl_p99_nats": 0.0002477179325109346,
+            "maximum_prediction_kl_nats": 0.07817244889218078,
+            "top1_changed_fraction": 0.0006134028523232633,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.7477798461914062,
+            "maximum_per_target_cross_entropy_increase": 0.7331861257553101
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00038137210539562576,
+            "mean_prediction_kl_nats": 7.974733484039327e-05,
+            "prediction_kl_p99_nats": 0.00024725658206455503,
+            "maximum_prediction_kl_nats": 0.07807902524619609,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.7478551864624023,
+            "maximum_per_target_cross_entropy_increase": 0.7328281402587891
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 799680,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "11d317c88faf40d248e5062c81409488c5bb22cad5013acb677fd2fa7b6038a7",
+            "table_sha256": "49e03d9e3f51e955fe94dc7e04708d1b097f5f5abbc78925511998693be3084e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.015065478160977364,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 800527,
+          "backend_with_key_registry_bytes": 962252,
+          "backend_with_datrie_key_index_bytes": 895807,
+          "full_model_serving_artifact_bytes": 1256938,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999473909108884,
+            "mean_cosine": 0.9999870639260287,
+            "p05_cosine": 0.9999756364724784,
+            "relative_l2_mean": 0.004980035071369554,
+            "relative_l2_p95": 0.007019963381426742,
+            "relative_l2_max": 0.01031362099466868,
+            "weighted_relative_l2_mean": 0.005052883220721706,
+            "weighted_relative_frobenius": 0.005508949576832854,
+            "weighted_mean_cosine": 0.9999857367458814,
+            "max_relative_norm_change": 0.0028045305141336367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.352839,
+            "warm_p50_ms": 0.098407,
+            "warm_p95_ms": 0.10171345,
+            "warm_p99_ms": 0.11197704,
+            "samples_ms": [
+              0.102178,
+              0.099314,
+              0.099314,
+              0.100292,
+              0.099384,
+              0.098826,
+              0.099315,
+              0.098407,
+              0.097498,
+              0.097917,
+              0.097917,
+              0.097498,
+              0.09701,
+              0.09701,
+              0.098895,
+              0.097987,
+              0.098476,
+              0.098477,
+              0.098896,
+              0.097988,
+              0.098406,
+              0.098406,
+              0.097917,
+              0.098895,
+              0.09659,
+              0.097498,
+              0.098336,
+              0.097917,
+              0.097429,
+              0.097918,
+              0.099315,
+              0.098407,
+              0.099385,
+              0.098896,
+              0.097918,
+              0.10085,
+              0.098407,
+              0.099314,
+              0.118242,
+              0.101689
+            ],
+            "warm_rows_per_second": 5202881.908807301
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744925143976087,
+            "character_perplexity": 5.725472873245465,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010658089074226226,
+            "mean_prediction_kl_nats": 3.530829573772787e-06,
+            "prediction_kl_p99_nats": 2.241467108712739e-05,
+            "maximum_prediction_kl_nats": 8.750250229179642e-05,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.02865290641784668,
+            "maximum_per_target_cross_entropy_increase": 0.021081924438476562
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893714,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 15,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "11d317c88faf40d248e5062c81409488c5bb22cad5013acb677fd2fa7b6038a7",
+            "table_sha256": "bc3d36b6926f94ea6c377e48cd3ed142b78e879cd954ae468fb87cc40de42f3c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08310471288859844,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894960,
+          "backend_with_key_registry_bytes": 1056685,
+          "backend_with_datrie_key_index_bytes": 990240,
+          "full_model_serving_artifact_bytes": 1351371,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999473909108884,
+            "mean_cosine": 0.9999870639260287,
+            "p05_cosine": 0.9999756364724784,
+            "relative_l2_mean": 0.004980035071369554,
+            "relative_l2_p95": 0.007019963381426742,
+            "relative_l2_max": 0.01031362099466868,
+            "weighted_relative_l2_mean": 0.005052883220721706,
+            "weighted_relative_frobenius": 0.005508949576832854,
+            "weighted_mean_cosine": 0.9999857367458814,
+            "max_relative_norm_change": 0.0028045305141336367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.767161,
+            "warm_p50_ms": 0.1112225,
+            "warm_p95_ms": 0.115049,
+            "warm_p99_ms": 0.11549008999999999,
+            "samples_ms": [
+              0.115448,
+              0.113562,
+              0.112026,
+              0.110629,
+              0.11035,
+              0.110629,
+              0.110209,
+              0.113073,
+              0.111676,
+              0.111258,
+              0.110209,
+              0.109301,
+              0.111676,
+              0.110768,
+              0.111676,
+              0.112584,
+              0.115517,
+              0.114539,
+              0.111188,
+              0.111607,
+              0.113073,
+              0.11014,
+              0.110769,
+              0.111607,
+              0.111257,
+              0.110699,
+              0.109721,
+              0.111257,
+              0.111676,
+              0.112096,
+              0.110699,
+              0.11021,
+              0.110279,
+              0.112584,
+              0.115028,
+              0.110699,
+              0.11014,
+              0.110768,
+              0.110768,
+              0.110209
+            ],
+            "warm_rows_per_second": 4603385.1064308025
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744925143976087,
+            "character_perplexity": 5.725472873245465,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010658089074226226,
+            "mean_prediction_kl_nats": 3.530829573772787e-06,
+            "prediction_kl_p99_nats": 2.241467108712739e-05,
+            "maximum_prediction_kl_nats": 8.750250229179642e-05,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.02865290641784668,
+            "maximum_per_target_cross_entropy_increase": 0.021081924438476562
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893714,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 15,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "11d317c88faf40d248e5062c81409488c5bb22cad5013acb677fd2fa7b6038a7",
+            "table_sha256": "bc3d36b6926f94ea6c377e48cd3ed142b78e879cd954ae468fb87cc40de42f3c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12294375686906278,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894959,
+          "backend_with_key_registry_bytes": 1056684,
+          "backend_with_datrie_key_index_bytes": 990239,
+          "full_model_serving_artifact_bytes": 1351370,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999473909108884,
+            "mean_cosine": 0.9999870639260287,
+            "p05_cosine": 0.9999756364724784,
+            "relative_l2_mean": 0.004980035071369554,
+            "relative_l2_p95": 0.007019963381426742,
+            "relative_l2_max": 0.01031362099466868,
+            "weighted_relative_l2_mean": 0.005052883220721706,
+            "weighted_relative_frobenius": 0.005508949576832854,
+            "weighted_mean_cosine": 0.9999857367458814,
+            "max_relative_norm_change": 0.0028045305141336367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.733567,
+            "warm_p50_ms": 0.1102795,
+            "warm_p95_ms": 0.11222789999999999,
+            "warm_p99_ms": 0.12965448999999998,
+            "samples_ms": [
+              0.113423,
+              0.112165,
+              0.111117,
+              0.111117,
+              0.110279,
+              0.111746,
+              0.11021,
+              0.11021,
+              0.111747,
+              0.112165,
+              0.10979,
+              0.109721,
+              0.140032,
+              0.111258,
+              0.109302,
+              0.11021,
+              0.110698,
+              0.110349,
+              0.110628,
+              0.11021,
+              0.11028,
+              0.110699,
+              0.109721,
+              0.110279,
+              0.109232,
+              0.109651,
+              0.11035,
+              0.110769,
+              0.108743,
+              0.10986,
+              0.108394,
+              0.11028,
+              0.111676,
+              0.109232,
+              0.110209,
+              0.11028,
+              0.109302,
+              0.11021,
+              0.110768,
+              0.10979
+            ],
+            "warm_rows_per_second": 4642748.652288049
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744925143976087,
+            "character_perplexity": 5.725472873245465,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010658089074226226,
+            "mean_prediction_kl_nats": 3.530829573772787e-06,
+            "prediction_kl_p99_nats": 2.241467108712739e-05,
+            "maximum_prediction_kl_nats": 8.750250229179642e-05,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.02865290641784668,
+            "maximum_per_target_cross_entropy_increase": 0.021081924438476562
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893714,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 15,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "11d317c88faf40d248e5062c81409488c5bb22cad5013acb677fd2fa7b6038a7",
+            "table_sha256": "bc3d36b6926f94ea6c377e48cd3ed142b78e879cd954ae468fb87cc40de42f3c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08123408304527402,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894959,
+          "backend_with_key_registry_bytes": 1056684,
+          "backend_with_datrie_key_index_bytes": 990239,
+          "full_model_serving_artifact_bytes": 1351370,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999473909108884,
+            "mean_cosine": 0.9999870639260287,
+            "p05_cosine": 0.9999756364724784,
+            "relative_l2_mean": 0.004980035071369554,
+            "relative_l2_p95": 0.007019963381426742,
+            "relative_l2_max": 0.01031362099466868,
+            "weighted_relative_l2_mean": 0.005052883220721706,
+            "weighted_relative_frobenius": 0.005508949576832854,
+            "weighted_mean_cosine": 0.9999857367458814,
+            "max_relative_norm_change": 0.0028045305141336367
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.708983,
+            "warm_p50_ms": 0.1106985,
+            "warm_p95_ms": 0.11400545,
+            "warm_p99_ms": 0.13964835999999997,
+            "samples_ms": [
+              0.11447,
+              0.113981,
+              0.111187,
+              0.110629,
+              0.110769,
+              0.112165,
+              0.111676,
+              0.111257,
+              0.110698,
+              0.110698,
+              0.111187,
+              0.110768,
+              0.110768,
+              0.11021,
+              0.108953,
+              0.10972,
+              0.110698,
+              0.109721,
+              0.108882,
+              0.155746,
+              0.113562,
+              0.110768,
+              0.111676,
+              0.110209,
+              0.110279,
+              0.110769,
+              0.11021,
+              0.111118,
+              0.11028,
+              0.109301,
+              0.109791,
+              0.110699,
+              0.11021,
+              0.109791,
+              0.110279,
+              0.112165,
+              0.11021,
+              0.110698,
+              0.111676,
+              0.111676
+            ],
+            "warm_rows_per_second": 4625175.5895518
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744925143976087,
+            "character_perplexity": 5.725472873245465,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010658089074226226,
+            "mean_prediction_kl_nats": 3.530829573772787e-06,
+            "prediction_kl_p99_nats": 2.241467108712739e-05,
+            "maximum_prediction_kl_nats": 8.750250229179642e-05,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.02865290641784668,
+            "maximum_per_target_cross_entropy_increase": 0.021081924438476562
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 843341,
+              "unique_rows": 11026,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 10,
+              "compressed_blocks": 82,
+              "zlib_blocks": 82,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11026
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "889ecd64b0c80353367f03cabfa6be39ca55699423581564d950fa8a65639032",
+            "table_sha256": "0e0317b5cc07cf1fc6c1de549fe20fdfd88ff2b5f632e6bcafc51903bca7fefa",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08627795591019094,
+          "representatives_sha256": "9dd523868af05e2ec81f6ada0eb4a1996ecb07459d057849fdece7eadb2c4760",
+          "structurally_merged_rows": 734,
+          "backend_artifact_bytes": 844585,
+          "backend_with_key_registry_bytes": 1006310,
+          "backend_with_datrie_key_index_bytes": 939865,
+          "full_model_serving_artifact_bytes": 1300996,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9925185716726764,
+            "mean_cosine": 0.9999452723868479,
+            "p05_cosine": 0.9997098827945491,
+            "relative_l2_mean": 0.006869948350346231,
+            "relative_l2_p95": 0.024423295005078234,
+            "relative_l2_max": 0.12213938394952205,
+            "weighted_relative_l2_mean": 0.005803078514374146,
+            "weighted_relative_frobenius": 0.007636228340675911,
+            "weighted_mean_cosine": 0.9999712258731059,
+            "max_relative_norm_change": 0.010522080816159867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9924329975314833,
+            "mean_cosine": 0.9999567840970592,
+            "p05_cosine": 0.9996946934776181,
+            "relative_l2_mean": 0.002197937842712327,
+            "relative_l2_p95": 0.024897731630796352,
+            "relative_l2_max": 0.12282019564119777,
+            "weighted_relative_l2_mean": 0.0009324724100068205,
+            "weighted_relative_frobenius": 0.005520060633454694,
+            "weighted_mean_cosine": 0.9999845157529222,
+            "max_relative_norm_change": 0.009943799209470403
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.77659,
+            "warm_p50_ms": 0.110279,
+            "warm_p95_ms": 0.11504995,
+            "warm_p99_ms": 0.13300074999999997,
+            "samples_ms": [
+              0.115029,
+              0.114051,
+              0.111117,
+              0.111676,
+              0.110768,
+              0.10979,
+              0.111118,
+              0.112095,
+              0.111257,
+              0.110769,
+              0.11021,
+              0.109302,
+              0.110768,
+              0.109232,
+              0.109791,
+              0.11028,
+              0.144223,
+              0.115448,
+              0.109721,
+              0.110628,
+              0.110279,
+              0.11021,
+              0.109721,
+              0.110279,
+              0.110628,
+              0.11014,
+              0.110349,
+              0.11021,
+              0.109791,
+              0.110279,
+              0.111606,
+              0.110209,
+              0.110699,
+              0.108883,
+              0.11021,
+              0.10986,
+              0.108813,
+              0.109232,
+              0.11028,
+              0.110279
+            ],
+            "warm_rows_per_second": 4642769.702300528
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.74488879921546,
+            "character_perplexity": 5.725264786085873,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.023291699165417e-05,
+            "mean_prediction_kl_nats": 4.729751282754875e-06,
+            "prediction_kl_p99_nats": 3.664258964740034e-05,
+            "maximum_prediction_kl_nats": 0.0006163941351551014,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.29679757356643677,
+            "maximum_per_target_cross_entropy_increase": 0.03550541400909424
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -3.634410016403937e-05,
+            "mean_prediction_kl_nats": 1.19834438801275e-06,
+            "prediction_kl_p99_nats": 2.5357726543204313e-05,
+            "maximum_prediction_kl_nats": 0.0006348251018272824,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.294968843460083,
+            "maximum_per_target_cross_entropy_increase": 0.036371469497680664
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 843228,
+              "unique_rows": 11024,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 9,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11024
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "5c68f0c4c1115c4ac4f47468c0970427d5816b50837276b478fca3a30081d8e6",
+            "table_sha256": "c4d1471287f3aa2449f1f0868a87bf6930aa29cfea2ff6268b138258600617fe",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08620755490846932,
+          "representatives_sha256": "78b8ed7d64ca2bffb2aefe2ea471e41d72bdf8a8c5a4826ee733dae05607e74c",
+          "structurally_merged_rows": 736,
+          "backend_artifact_bytes": 844471,
+          "backend_with_key_registry_bytes": 1006196,
+          "backend_with_datrie_key_index_bytes": 939751,
+          "full_model_serving_artifact_bytes": 1300882,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9835029294138288,
+            "mean_cosine": 0.9999430210554684,
+            "p05_cosine": 0.9997076885379784,
+            "relative_l2_mean": 0.006896279924639333,
+            "relative_l2_p95": 0.02444953821625191,
+            "relative_l2_max": 0.1820996223771739,
+            "weighted_relative_l2_mean": 0.0058064973361122395,
+            "weighted_relative_frobenius": 0.007663621969295788,
+            "weighted_mean_cosine": 0.9999709715160588,
+            "max_relative_norm_change": 0.010522080816159867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9837323408538031,
+            "mean_cosine": 0.9999545361559533,
+            "p05_cosine": 0.99969453404189,
+            "relative_l2_mean": 0.00222548504458345,
+            "relative_l2_p95": 0.025013083634212202,
+            "relative_l2_max": 0.18096465905004575,
+            "weighted_relative_l2_mean": 0.0009361089003034648,
+            "weighted_relative_frobenius": 0.005558494820779118,
+            "weighted_mean_cosine": 0.9999842571601029,
+            "max_relative_norm_change": 0.009943799209470403
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.847967,
+            "warm_p50_ms": 0.109302,
+            "warm_p95_ms": 0.11183775,
+            "warm_p99_ms": 0.13465091999999998,
+            "samples_ms": [
+              0.113562,
+              0.109371,
+              0.110279,
+              0.110699,
+              0.109791,
+              0.148134,
+              0.11021,
+              0.109302,
+              0.108394,
+              0.108743,
+              0.108813,
+              0.108324,
+              0.109721,
+              0.108324,
+              0.109721,
+              0.109721,
+              0.109301,
+              0.111746,
+              0.110698,
+              0.109301,
+              0.109302,
+              0.109791,
+              0.109302,
+              0.11021,
+              0.111747,
+              0.11021,
+              0.108812,
+              0.109721,
+              0.109232,
+              0.108813,
+              0.107835,
+              0.109301,
+              0.108743,
+              0.11028,
+              0.109301,
+              0.108812,
+              0.109301,
+              0.108883,
+              0.108743,
+              0.111257
+            ],
+            "warm_rows_per_second": 4684269.27229145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744884551868943,
+            "character_perplexity": 5.725240468954067,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.598528119194803e-05,
+            "mean_prediction_kl_nats": 5.179810257603944e-06,
+            "prediction_kl_p99_nats": 3.688835137538909e-05,
+            "maximum_prediction_kl_nats": 0.005859044073035739,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.29679757356643677,
+            "maximum_per_target_cross_entropy_increase": 0.03550541400909424
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.059128329518424e-05,
+            "mean_prediction_kl_nats": 1.6181806715206679e-06,
+            "prediction_kl_p99_nats": 2.5458426726578934e-05,
+            "maximum_prediction_kl_nats": 0.005460578185880949,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.294968843460083,
+            "maximum_per_target_cross_entropy_increase": 0.036371469497680664
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 843074,
+              "unique_rows": 11022,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 12,
+              "compressed_blocks": 80,
+              "zlib_blocks": 80,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11022
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "577aa68acb8cdba2e986daa24ca1390815aa8ab5fe978503dc17cb6c0ded05c9",
+            "table_sha256": "f28ea920fb725358777bd78c0a51d5b70ee961f1451c19a290e7e865ca36c721",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.11374809592962265,
+          "representatives_sha256": "b537133c6bfce4f4984e9e774b5715cf35b391ecde6bb0204224736b9ec2c9f9",
+          "structurally_merged_rows": 738,
+          "backend_artifact_bytes": 844318,
+          "backend_with_key_registry_bytes": 1006043,
+          "backend_with_datrie_key_index_bytes": 939598,
+          "full_model_serving_artifact_bytes": 1300729,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9731854466670903,
+            "mean_cosine": 0.9999362098877692,
+            "p05_cosine": 0.9997062041798425,
+            "relative_l2_mean": 0.006952655238500744,
+            "relative_l2_p95": 0.02454468943200593,
+            "relative_l2_max": 0.2319535707428676,
+            "weighted_relative_l2_mean": 0.0058064973361122395,
+            "weighted_relative_frobenius": 0.007663621969295788,
+            "weighted_mean_cosine": 0.9999709715160588,
+            "max_relative_norm_change": 0.010522080816159867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.972878135926894,
+            "mean_cosine": 0.9999477237904446,
+            "p05_cosine": 0.9996918254970836,
+            "relative_l2_mean": 0.002282572680306364,
+            "relative_l2_p95": 0.025176145704010097,
+            "relative_l2_max": 0.23306861619888342,
+            "weighted_relative_l2_mean": 0.0009361089003034648,
+            "weighted_relative_frobenius": 0.005558494820779118,
+            "weighted_mean_cosine": 0.9999842571601029,
+            "max_relative_norm_change": 0.009943799209470403
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.755777,
+            "warm_p50_ms": 0.1112225,
+            "warm_p95_ms": 0.1141007,
+            "warm_p99_ms": 0.13974522999999997,
+            "samples_ms": [
+              0.116356,
+              0.113982,
+              0.111746,
+              0.112654,
+              0.111746,
+              0.111676,
+              0.111606,
+              0.112095,
+              0.111537,
+              0.110279,
+              0.111606,
+              0.111676,
+              0.108743,
+              0.111258,
+              0.109791,
+              0.111118,
+              0.110768,
+              0.110698,
+              0.109232,
+              0.111258,
+              0.108813,
+              0.110768,
+              0.111257,
+              0.111676,
+              0.110699,
+              0.112166,
+              0.154699,
+              0.112584,
+              0.111188,
+              0.109232,
+              0.111187,
+              0.110698,
+              0.109302,
+              0.11021,
+              0.109372,
+              0.10972,
+              0.109721,
+              0.111257,
+              0.110699,
+              0.111607
+            ],
+            "warm_rows_per_second": 4603385.1064308025
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.744884551868943,
+            "character_perplexity": 5.725240468954067,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.598528119194803e-05,
+            "mean_prediction_kl_nats": 5.179810257603944e-06,
+            "prediction_kl_p99_nats": 3.688835137538909e-05,
+            "maximum_prediction_kl_nats": 0.005859044073035739,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.29679757356643677,
+            "maximum_per_target_cross_entropy_increase": 0.03550541400909424
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.059128329518424e-05,
+            "mean_prediction_kl_nats": 1.6181806715206679e-06,
+            "prediction_kl_p99_nats": 2.5458426726578934e-05,
+            "maximum_prediction_kl_nats": 0.005460578185880949,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.294968843460083,
+            "maximum_per_target_cross_entropy_increase": 0.036371469497680664
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842896,
+              "unique_rows": 11019,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 81,
+              "zlib_blocks": 81,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11019
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "95dc83bc2653e9337145412df1324dc2d312e84415fddbf1dff367f5d4e5f095",
+            "table_sha256": "810f7e3c3217dacae23a615b7c5f1be4e0203bb144f3708d6981a8fa6fd29936",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08859019307419658,
+          "representatives_sha256": "f227517c766358e150595bb5e8325380441dcc07039c2bd4f4b6e83899b70c5e",
+          "structurally_merged_rows": 741,
+          "backend_artifact_bytes": 844140,
+          "backend_with_key_registry_bytes": 1005865,
+          "backend_with_datrie_key_index_bytes": 939420,
+          "full_model_serving_artifact_bytes": 1300551,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9598427504538848,
+            "mean_cosine": 0.9999266341928937,
+            "p05_cosine": 0.9997015199376899,
+            "relative_l2_mean": 0.00702112551067649,
+            "relative_l2_p95": 0.0247034349911432,
+            "relative_l2_max": 0.2828580077137856,
+            "weighted_relative_l2_mean": 0.005841040036016813,
+            "weighted_relative_frobenius": 0.008315220355991155,
+            "weighted_mean_cosine": 0.9999660661244957,
+            "max_relative_norm_change": 0.010522080816159867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9600234276278778,
+            "mean_cosine": 0.9999381728045064,
+            "p05_cosine": 0.9996858536608259,
+            "relative_l2_mean": 0.0023522664632986278,
+            "relative_l2_p95": 0.02526999824170825,
+            "relative_l2_max": 0.28214583754347966,
+            "weighted_relative_l2_mean": 0.0009713035943111449,
+            "weighted_relative_frobenius": 0.006424690083692396,
+            "weighted_mean_cosine": 0.999979367336869,
+            "max_relative_norm_change": 0.009943799209470403
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.748723,
+            "warm_p50_ms": 0.1106985,
+            "warm_p95_ms": 0.11589139999999999,
+            "warm_p99_ms": 0.16287847999999994,
+            "samples_ms": [
+              0.116355,
+              0.11405,
+              0.11447,
+              0.111676,
+              0.110279,
+              0.113562,
+              0.113073,
+              0.112585,
+              0.112585,
+              0.110699,
+              0.111188,
+              0.109791,
+              0.111117,
+              0.110768,
+              0.109232,
+              0.109721,
+              0.112166,
+              0.111606,
+              0.192623,
+              0.115867,
+              0.111188,
+              0.11028,
+              0.110209,
+              0.109302,
+              0.109232,
+              0.111118,
+              0.109301,
+              0.109721,
+              0.109791,
+              0.110698,
+              0.110139,
+              0.109861,
+              0.110699,
+              0.109721,
+              0.111187,
+              0.109232,
+              0.109372,
+              0.10972,
+              0.109372,
+              0.109302
+            ],
+            "warm_rows_per_second": 4625175.5895518
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7450230403743143,
+            "character_perplexity": 5.726033403854421,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00020449251537473282,
+            "mean_prediction_kl_nats": 2.428676828904074e-05,
+            "prediction_kl_p99_nats": 3.8123776147374744e-05,
+            "maximum_prediction_kl_nats": 0.07868376115915458,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.7481122016906738,
+            "maximum_per_target_cross_entropy_increase": 0.7353435754776001
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.790119023641044e-05,
+            "mean_prediction_kl_nats": 2.0551677530587976e-05,
+            "prediction_kl_p99_nats": 2.6455327187997673e-05,
+            "maximum_prediction_kl_nats": 0.07804923014879808,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.7464032173156738,
+            "maximum_per_target_cross_entropy_increase": 0.732738733291626
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842765,
+              "unique_rows": 11017,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 81,
+              "zlib_blocks": 81,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11017
+            },
+            "source_float32_sha256": "74ba1cd907605debe6e87c0b632bf10ec6a40efceb5d71912f3cfe5977051323",
+            "decoded_float32_sha256": "e16cb157f87f733131edb7b59df971e344233e298557ad846424f4f42f9dabd7",
+            "table_sha256": "6fe5e4305ed3902d9e6b90311421e59b5f21efa6168d83d881f362e53725e750",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18645608704537153,
+          "representatives_sha256": "784ce25c32c23db2424eabaa2626daad205fc934da2e7f23d562b2abf3b6433c",
+          "structurally_merged_rows": 743,
+          "backend_artifact_bytes": 844009,
+          "backend_with_key_registry_bytes": 1005734,
+          "backend_with_datrie_key_index_bytes": 939289,
+          "full_model_serving_artifact_bytes": 1300420,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9178180295155871,
+            "mean_cosine": 0.9999133394146261,
+            "p05_cosine": 0.9997003036972144,
+            "relative_l2_mean": 0.007087242341082681,
+            "relative_l2_p95": 0.024850056293793433,
+            "relative_l2_max": 0.4061799028640071,
+            "weighted_relative_l2_mean": 0.0064790225927562044,
+            "weighted_relative_frobenius": 0.013234738509292052,
+            "weighted_mean_cosine": 0.9998356390480357,
+            "max_relative_norm_change": 0.010522080816159867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9172858244959732,
+            "mean_cosine": 0.9999248077935126,
+            "p05_cosine": 0.9996848710539707,
+            "relative_l2_mean": 0.002419604315695432,
+            "relative_l2_p95": 0.025287800604829137,
+            "relative_l2_max": 0.40764289911274443,
+            "weighted_relative_l2_mean": 0.0016208584560864932,
+            "weighted_relative_frobenius": 0.01216213538365954,
+            "weighted_mean_cosine": 0.9998481026659187,
+            "max_relative_norm_change": 0.009943799209470403
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.763739,
+            "warm_p50_ms": 0.112095,
+            "warm_p95_ms": 0.12583645,
+            "warm_p99_ms": 0.14118436,
+            "samples_ms": [
+              0.11454,
+              0.112654,
+              0.111746,
+              0.113562,
+              0.14527,
+              0.116845,
+              0.114469,
+              0.111676,
+              0.11447,
+              0.111607,
+              0.125365,
+              0.112585,
+              0.112514,
+              0.112095,
+              0.112095,
+              0.112095,
+              0.112654,
+              0.112654,
+              0.113982,
+              0.112654,
+              0.111257,
+              0.109791,
+              0.11014,
+              0.111257,
+              0.109301,
+              0.112584,
+              0.112095,
+              0.110768,
+              0.111746,
+              0.111676,
+              0.111117,
+              0.112095,
+              0.109721,
+              0.111746,
+              0.110209,
+              0.111117,
+              0.110628,
+              0.110279,
+              0.113143,
+              0.134794
+            ],
+            "warm_rows_per_second": 4567554.306614925
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7453099604119993,
+            "character_perplexity": 5.727676553289417,
+            "next_character_accuracy": 0.5005367274957828,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0004915123999688301,
+            "mean_prediction_kl_nats": 8.339455953100242e-05,
+            "prediction_kl_p99_nats": 0.00028306938107107763,
+            "maximum_prediction_kl_nats": 0.07868376115915458,
+            "top1_changed_fraction": 0.0023002606962122373,
+            "accuracy_change": 0.0006900782088636315,
+            "maximum_absolute_logit_change": 0.7481122016906738,
+            "maximum_per_target_cross_entropy_increase": 0.7353435754776001
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.000384890487255598,
+            "mean_prediction_kl_nats": 7.9830180664046e-05,
+            "prediction_kl_p99_nats": 0.00027854762476799084,
+            "maximum_prediction_kl_nats": 0.07804923014879808,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.7464032173156738,
+            "maximum_per_target_cross_entropy_increase": 0.732738733291626
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.7448185687646842,
+          "character_perplexity": 5.724862712278213,
+          "next_character_accuracy": 0.4998466492869192,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6103526363822893,
+          "character_perplexity": 5.00457571217865,
+          "next_character_accuracy": 0.5303227785018784,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.9",
+          "backend_with_key_registry_bytes": 2893447,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.610478337983415,
+            "character_perplexity": 5.005204834898665,
+            "next_character_accuracy": 0.5303227785018784,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00012570950190301332,
+            "mean_prediction_kl_nats": 3.522476674748964e-05,
+            "prediction_kl_p99_nats": 3.073411681134878e-05,
+            "maximum_prediction_kl_nats": 0.069073305132374,
+            "top1_changed_fraction": 0.0007666947788085563,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6207461357116699,
+            "maximum_per_target_cross_entropy_increase": 0.810072660446167
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -4.4151146362623543e-05,
+              0.00031408959841323583
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.9",
+          "backend_with_key_registry_bytes": 1566355,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6104803438537196,
+            "character_perplexity": 5.0052148747004805,
+            "next_character_accuracy": 0.5303227785018784,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00012771562637668983,
+            "mean_prediction_kl_nats": 3.5253858489440136e-05,
+            "prediction_kl_p99_nats": 3.0714668360973565e-05,
+            "maximum_prediction_kl_nats": 0.0691435144903208,
+            "top1_changed_fraction": 0.0007666947788085563,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6211075782775879,
+            "maximum_per_target_cross_entropy_increase": 0.8102507591247559
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -4.18414171096396e-05,
+              0.00031688913937407293
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-raw",
+          "backend_with_key_registry_bytes": 962252,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6103997491236468,
+            "character_perplexity": 5.004811497013974,
+            "next_character_accuracy": 0.5307061258912826,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 4.711385118005514e-05,
+            "mean_prediction_kl_nats": 3.3553609696799543e-06,
+            "prediction_kl_p99_nats": 2.355900870385665e-05,
+            "maximum_prediction_kl_nats": 7.72629051648873e-05,
+            "top1_changed_fraction": 0.0013800506018554013,
+            "accuracy_change": 0.00038334738940426494,
+            "maximum_absolute_logit_change": 0.029384613037109375,
+            "maximum_per_target_cross_entropy_increase": 0.021229267120361328
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              8.000077854203593e-07,
+              9.973376735015557e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6103547072455107,
+            "character_perplexity": 5.0045860759811625,
+            "next_character_accuracy": 0.5303227785018784,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 2.0708653656909176e-06,
+            "mean_prediction_kl_nats": 4.295727044007571e-09,
+            "prediction_kl_p99_nats": 2.9273537964819035e-08,
+            "maximum_prediction_kl_nats": 1.6115332053182775e-07,
+            "top1_changed_fraction": 7.666947788085564e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011279582977294922,
+            "maximum_per_target_cross_entropy_increase": 0.0007696151733398438
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6103997491236468,
+            "character_perplexity": 5.004811497013974,
+            "next_character_accuracy": 0.5307061258912826,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 4.711385118005514e-05,
+            "mean_prediction_kl_nats": 3.3553609696799543e-06,
+            "prediction_kl_p99_nats": 2.355900870385665e-05,
+            "maximum_prediction_kl_nats": 7.72629051648873e-05,
+            "top1_changed_fraction": 0.0013800506018554013,
+            "accuracy_change": 0.00038334738940426494,
+            "maximum_absolute_logit_change": 0.029384613037109375,
+            "maximum_per_target_cross_entropy_increase": 0.021229267120361328
+          }
+        }
+      },
+      "checkpoint_sha256": "3576a59df8b4c48fb5cac466445e0472fd53af1450d4c7ffe30d612cf90a6214",
+      "registry_sha256": "7fa792a7a13db17dc47320b6a65018697d338beda3b6328e9775d68716636b54"
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "rows": 11760,
+      "dim": 64,
+      "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+      "source_float32_bytes": 3010560,
+      "key_registry_bytes": 161725,
+      "unchanged_backbone_artifact_bytes": 294686,
+      "alternative_datrie_key_index_bytes": 95280,
+      "query_rows": 512,
+      "query_ids_sha256": "8ba8e1ab159a822d9159f679166b91955ebc405920cda85ccf24f213c3eff2ad",
+      "frequency_trace_sha256": "73ddaf0153da6d907ac6eef82bf819aaec23a0a5eb289cb0f3f91092c37eb7f0",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3010560,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "table_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.014276340138167143,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3011364,
+          "backend_with_key_registry_bytes": 3173089,
+          "backend_with_datrie_key_index_bytes": 3106644,
+          "full_model_serving_artifact_bytes": 3467775,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.394604,
+            "warm_p50_ms": 0.049727,
+            "warm_p95_ms": 0.05261179999999999,
+            "warm_p99_ms": 0.06417813,
+            "samples_ms": [
+              0.052102,
+              0.052521,
+              0.051124,
+              0.049238,
+              0.049238,
+              0.049657,
+              0.050146,
+              0.050146,
+              0.050216,
+              0.050146,
+              0.050146,
+              0.049657,
+              0.049727,
+              0.050146,
+              0.049657,
+              0.049727,
+              0.050146,
+              0.049727,
+              0.049657,
+              0.049657,
+              0.049727,
+              0.054337,
+              0.050146,
+              0.049657,
+              0.049727,
+              0.050146,
+              0.050146,
+              0.049727,
+              0.049657,
+              0.049657,
+              0.049168,
+              0.050216,
+              0.049658,
+              0.050147,
+              0.050146,
+              0.049727,
+              0.049727,
+              0.049727,
+              0.07047,
+              0.050146
+            ],
+            "warm_rows_per_second": 10296217.346713053
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7619878874351227,
+            "character_perplexity": 5.824003357774225,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908719,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "table_sha256": "a8a6088cda5b1406c3b425bc807b56a4eb283ab757ee8817c0438802b3677b0e",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2650056080892682,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909925,
+          "backend_with_key_registry_bytes": 3071650,
+          "backend_with_datrie_key_index_bytes": 3005205,
+          "full_model_serving_artifact_bytes": 3366336,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 12.715526,
+            "warm_p50_ms": 0.058247,
+            "warm_p95_ms": 0.07766719999999999,
+            "warm_p99_ms": 0.08123956,
+            "samples_ms": [
+              0.077524,
+              0.081784,
+              0.077105,
+              0.077104,
+              0.073333,
+              0.060552,
+              0.058736,
+              0.058667,
+              0.058178,
+              0.058247,
+              0.058178,
+              0.058247,
+              0.056362,
+              0.058667,
+              0.058248,
+              0.05727,
+              0.05727,
+              0.0572,
+              0.0572,
+              0.057759,
+              0.05727,
+              0.0572,
+              0.056292,
+              0.056711,
+              0.058178,
+              0.058178,
+              0.058667,
+              0.058178,
+              0.058666,
+              0.058178,
+              0.058667,
+              0.056781,
+              0.057758,
+              0.056292,
+              0.07473,
+              0.080388,
+              0.071937,
+              0.066698,
+              0.063766,
+              0.058667
+            ],
+            "warm_rows_per_second": 8790152.282520989
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7619878874351227,
+            "character_perplexity": 5.824003357774225,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908719,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "table_sha256": "a8a6088cda5b1406c3b425bc807b56a4eb283ab757ee8817c0438802b3677b0e",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3114413758739829,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909924,
+          "backend_with_key_registry_bytes": 3071649,
+          "backend_with_datrie_key_index_bytes": 3005204,
+          "full_model_serving_artifact_bytes": 3366335,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.74508,
+            "warm_p50_ms": 0.058667,
+            "warm_p95_ms": 0.062165499999999985,
+            "warm_p99_ms": 0.07782507999999999,
+            "samples_ms": [
+              0.066279,
+              0.06153,
+              0.060063,
+              0.058667,
+              0.059505,
+              0.060622,
+              0.059086,
+              0.059644,
+              0.061949,
+              0.059156,
+              0.059156,
+              0.056712,
+              0.058178,
+              0.058177,
+              0.058667,
+              0.057689,
+              0.058667,
+              0.0572,
+              0.05727,
+              0.085207,
+              0.060972,
+              0.058667,
+              0.059993,
+              0.05727,
+              0.057269,
+              0.056781,
+              0.056781,
+              0.058667,
+              0.0572,
+              0.057759,
+              0.058667,
+              0.059156,
+              0.056292,
+              0.058667,
+              0.0572,
+              0.05727,
+              0.056362,
+              0.056851,
+              0.058667,
+              0.058178
+            ],
+            "warm_rows_per_second": 8727223.14077761
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7619878874351227,
+            "character_perplexity": 5.824003357774225,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908719,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "table_sha256": "a8a6088cda5b1406c3b425bc807b56a4eb283ab757ee8817c0438802b3677b0e",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2655402428936213,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909924,
+          "backend_with_key_registry_bytes": 3071649,
+          "backend_with_datrie_key_index_bytes": 3005204,
+          "full_model_serving_artifact_bytes": 3366335,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.742845,
+            "warm_p50_ms": 0.058178,
+            "warm_p95_ms": 0.06009095,
+            "warm_p99_ms": 0.062028049999999994,
+            "samples_ms": [
+              0.060622,
+              0.060063,
+              0.058248,
+              0.057688,
+              0.058178,
+              0.059086,
+              0.058667,
+              0.058248,
+              0.057759,
+              0.057688,
+              0.058667,
+              0.062927,
+              0.057759,
+              0.058737,
+              0.058667,
+              0.058248,
+              0.058666,
+              0.058178,
+              0.058736,
+              0.056781,
+              0.056362,
+              0.057759,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.058178,
+              0.058248,
+              0.059505,
+              0.059644,
+              0.058177,
+              0.057689,
+              0.05727,
+              0.056781,
+              0.057689,
+              0.058248,
+              0.0572,
+              0.057689,
+              0.058248,
+              0.058178,
+              0.057759
+            ],
+            "warm_rows_per_second": 8800577.537900925
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7619878874351227,
+            "character_perplexity": 5.824003357774225,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732976,
+              "unique_rows": 11025,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11025
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "6f3cad212c8b92053408e3f1413f511ac4d98f1f102a24c84b584af64aaeb28b",
+            "table_sha256": "3a0405ee037427e6a197d0743c9770fb58b43c2f4e69b0852b3f80a3b08c4fe5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.26928883814252913,
+          "representatives_sha256": "0433240c0af194a070351d5d57755a2eb04ea4365346eabc9150ccbb46b1c357",
+          "structurally_merged_rows": 735,
+          "backend_artifact_bytes": 2734181,
+          "backend_with_key_registry_bytes": 2895906,
+          "backend_with_datrie_key_index_bytes": 2829461,
+          "full_model_serving_artifact_bytes": 3190592,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9932284489604623,
+            "mean_cosine": 0.9999581097104241,
+            "p05_cosine": 0.9996986518093584,
+            "relative_l2_mean": 0.002162167872962852,
+            "relative_l2_p95": 0.0248147106845416,
+            "relative_l2_max": 0.11643283329987608,
+            "weighted_relative_l2_mean": 0.000902934593800698,
+            "weighted_relative_frobenius": 0.005299696904874133,
+            "weighted_mean_cosine": 0.9999857134575801,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9932284489604623,
+            "mean_cosine": 0.9999581097104241,
+            "p05_cosine": 0.9996986518093584,
+            "relative_l2_mean": 0.002162167872962852,
+            "relative_l2_p95": 0.0248147106845416,
+            "relative_l2_max": 0.11643283329987608,
+            "weighted_relative_l2_mean": 0.000902934593800698,
+            "weighted_relative_frobenius": 0.005299696904874133,
+            "weighted_mean_cosine": 0.9999857134575801,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.070133,
+            "warm_p50_ms": 0.057758,
+            "warm_p95_ms": 0.06153005,
+            "warm_p99_ms": 0.06268085,
+            "samples_ms": [
+              0.06153,
+              0.063416,
+              0.060063,
+              0.061041,
+              0.059225,
+              0.059645,
+              0.059715,
+              0.058177,
+              0.058248,
+              0.058248,
+              0.05727,
+              0.058177,
+              0.057689,
+              0.057689,
+              0.059156,
+              0.057689,
+              0.057689,
+              0.061531,
+              0.058178,
+              0.057759,
+              0.058178,
+              0.057689,
+              0.05727,
+              0.057689,
+              0.05727,
+              0.057759,
+              0.05727,
+              0.057689,
+              0.057758,
+              0.057689,
+              0.057689,
+              0.05727,
+              0.057689,
+              0.057759,
+              0.05727,
+              0.0572,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.057758
+            ],
+            "warm_rows_per_second": 8864572.87302192
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620156589705396,
+            "character_perplexity": 5.8241651015356695,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.7771921049442663e-05,
+            "mean_prediction_kl_nats": 1.8640273193708572e-06,
+            "prediction_kl_p99_nats": 3.06553759923407e-05,
+            "maximum_prediction_kl_nats": 0.009303638315643778,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.04256582260131836
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 2.7771921049442663e-05,
+            "mean_prediction_kl_nats": 1.8640273193708572e-06,
+            "prediction_kl_p99_nats": 3.06553759923407e-05,
+            "maximum_prediction_kl_nats": 0.009303638315643778,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.04256582260131836
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732564,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "dc4a2442d9603c206a29f14840ac47b6e1c4bcca8b25696099674cd5dbd13711",
+            "table_sha256": "066e95a608e2f17caa6ead04461b729bc5e7312d05c1e9f11cac5dae2a6444b7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.26060099294409156,
+          "representatives_sha256": "b9022b09ef1ceb36d6ae184adf95f607090945b983bc83f60a1538cb45bc4baa",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 2733769,
+          "backend_with_key_registry_bytes": 2895494,
+          "backend_with_datrie_key_index_bytes": 2829049,
+          "full_model_serving_artifact_bytes": 3190180,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815472208001749,
+            "mean_cosine": 0.9999555118921756,
+            "p05_cosine": 0.9996977313037,
+            "relative_l2_mean": 0.0021918473872563965,
+            "relative_l2_p95": 0.024869959194056858,
+            "relative_l2_max": 0.1928935956994601,
+            "weighted_relative_l2_mean": 0.0009108762785184122,
+            "weighted_relative_frobenius": 0.005387920989374522,
+            "weighted_mean_cosine": 0.9999850981342973,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815472208001749,
+            "mean_cosine": 0.9999555118921756,
+            "p05_cosine": 0.9996977313037,
+            "relative_l2_mean": 0.0021918473872563965,
+            "relative_l2_p95": 0.024869959194056858,
+            "relative_l2_max": 0.1928935956994601,
+            "weighted_relative_l2_mean": 0.0009108762785184122,
+            "weighted_relative_frobenius": 0.005387920989374522,
+            "weighted_mean_cosine": 0.9999850981342973,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.792724,
+            "warm_p50_ms": 0.058143,
+            "warm_p95_ms": 0.060133,
+            "warm_p99_ms": 0.06064418,
+            "samples_ms": [
+              0.060971,
+              0.060133,
+              0.059644,
+              0.059644,
+              0.057689,
+              0.059644,
+              0.059574,
+              0.059645,
+              0.059086,
+              0.059155,
+              0.058108,
+              0.05727,
+              0.057759,
+              0.060064,
+              0.060133,
+              0.057689,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.058178,
+              0.057689,
+              0.058667,
+              0.05727,
+              0.058666,
+              0.057759,
+              0.05727,
+              0.059575,
+              0.057758,
+              0.058248,
+              0.057758,
+              0.060133,
+              0.057689,
+              0.057759,
+              0.058178,
+              0.05727,
+              0.058667,
+              0.057689,
+              0.057759,
+              0.059645,
+              0.057689
+            ],
+            "warm_rows_per_second": 8805875.169839878
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620191870194526,
+            "character_perplexity": 5.824185649511272,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 3.130007416692424e-05,
+            "mean_prediction_kl_nats": 3.677169019773703e-06,
+            "prediction_kl_p99_nats": 3.134725482268693e-05,
+            "maximum_prediction_kl_nats": 0.01202603974033005,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.10781413316726685
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.130007416692424e-05,
+            "mean_prediction_kl_nats": 3.677169019773703e-06,
+            "prediction_kl_p99_nats": 3.134725482268693e-05,
+            "maximum_prediction_kl_nats": 0.01202603974033005,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.10781413316726685
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732564,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "dc4a2442d9603c206a29f14840ac47b6e1c4bcca8b25696099674cd5dbd13711",
+            "table_sha256": "066e95a608e2f17caa6ead04461b729bc5e7312d05c1e9f11cac5dae2a6444b7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2508778888732195,
+          "representatives_sha256": "b9022b09ef1ceb36d6ae184adf95f607090945b983bc83f60a1538cb45bc4baa",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 2733769,
+          "backend_with_key_registry_bytes": 2895494,
+          "backend_with_datrie_key_index_bytes": 2829049,
+          "full_model_serving_artifact_bytes": 3190180,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815472208001749,
+            "mean_cosine": 0.9999555118921756,
+            "p05_cosine": 0.9996977313037,
+            "relative_l2_mean": 0.0021918473872563965,
+            "relative_l2_p95": 0.024869959194056858,
+            "relative_l2_max": 0.1928935956994601,
+            "weighted_relative_l2_mean": 0.0009108762785184122,
+            "weighted_relative_frobenius": 0.005387920989374522,
+            "weighted_mean_cosine": 0.9999850981342973,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815472208001749,
+            "mean_cosine": 0.9999555118921756,
+            "p05_cosine": 0.9996977313037,
+            "relative_l2_mean": 0.0021918473872563965,
+            "relative_l2_p95": 0.024869959194056858,
+            "relative_l2_max": 0.1928935956994601,
+            "weighted_relative_l2_mean": 0.0009108762785184122,
+            "weighted_relative_frobenius": 0.005387920989374522,
+            "weighted_mean_cosine": 0.9999850981342973,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 10.77198,
+            "warm_p50_ms": 0.057759,
+            "warm_p95_ms": 0.06009095,
+            "warm_p99_ms": 0.06113318,
+            "samples_ms": [
+              0.06146,
+              0.060063,
+              0.057759,
+              0.0572,
+              0.0572,
+              0.058178,
+              0.058667,
+              0.057689,
+              0.057689,
+              0.0572,
+              0.058667,
+              0.058247,
+              0.056292,
+              0.058667,
+              0.056781,
+              0.058178,
+              0.056781,
+              0.059086,
+              0.057689,
+              0.058667,
+              0.057759,
+              0.056781,
+              0.059225,
+              0.059155,
+              0.0572,
+              0.057758,
+              0.05727,
+              0.057689,
+              0.057689,
+              0.058178,
+              0.056781,
+              0.058178,
+              0.060622,
+              0.059645,
+              0.057759,
+              0.05727,
+              0.058667,
+              0.05734,
+              0.057759,
+              0.05727
+            ],
+            "warm_rows_per_second": 8864419.397842761
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620191870194526,
+            "character_perplexity": 5.824185649511272,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 3.130007416692424e-05,
+            "mean_prediction_kl_nats": 3.677169019773703e-06,
+            "prediction_kl_p99_nats": 3.134725482268693e-05,
+            "maximum_prediction_kl_nats": 0.01202603974033005,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.10781413316726685
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.130007416692424e-05,
+            "mean_prediction_kl_nats": 3.677169019773703e-06,
+            "prediction_kl_p99_nats": 3.134725482268693e-05,
+            "maximum_prediction_kl_nats": 0.01202603974033005,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30404186248779297,
+            "maximum_per_target_cross_entropy_increase": 0.10781413316726685
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2732050,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "4928f06da055cb0b4ad7ff511b6eeb90faf48ccdd7ca720e699eca8c64cb0997",
+            "table_sha256": "dfa5967e59333b01d1f76f69eb18ef1459343bbfcf338cbf085910c6baea1239",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25085365399718285,
+          "representatives_sha256": "23ac79b3f25b1f4c3454b3eaf09d347cbd138e5036dab7825f9678041e80a60e",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 2733255,
+          "backend_with_key_registry_bytes": 2894980,
+          "backend_with_datrie_key_index_bytes": 2828535,
+          "full_model_serving_artifact_bytes": 3189666,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536948201645477,
+            "mean_cosine": 0.999947709268633,
+            "p05_cosine": 0.9996967567902134,
+            "relative_l2_mean": 0.00224327120065354,
+            "relative_l2_p95": 0.024912690144640124,
+            "relative_l2_max": 0.30424701629479983,
+            "weighted_relative_l2_mean": 0.0011273360959741232,
+            "weighted_relative_frobenius": 0.009895820273657955,
+            "weighted_mean_cosine": 0.999952168096359,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536948201645477,
+            "mean_cosine": 0.999947709268633,
+            "p05_cosine": 0.9996967567902134,
+            "relative_l2_mean": 0.00224327120065354,
+            "relative_l2_p95": 0.024912690144640124,
+            "relative_l2_max": 0.30424701629479983,
+            "weighted_relative_l2_mean": 0.0011273360959741232,
+            "weighted_relative_frobenius": 0.009895820273657955,
+            "weighted_mean_cosine": 0.999952168096359,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.107848,
+            "warm_p50_ms": 0.058213,
+            "warm_p95_ms": 0.0643064,
+            "warm_p99_ms": 0.07859450999999999,
+            "samples_ms": [
+              0.063905,
+              0.060063,
+              0.058178,
+              0.058667,
+              0.058177,
+              0.064254,
+              0.065302,
+              0.060552,
+              0.060133,
+              0.060064,
+              0.059156,
+              0.058667,
+              0.058178,
+              0.058248,
+              0.056781,
+              0.057689,
+              0.057759,
+              0.087093,
+              0.059994,
+              0.059156,
+              0.059086,
+              0.059156,
+              0.059156,
+              0.058178,
+              0.058248,
+              0.057759,
+              0.058248,
+              0.057689,
+              0.057689,
+              0.058177,
+              0.0572,
+              0.057689,
+              0.055315,
+              0.05727,
+              0.058667,
+              0.057759,
+              0.057689,
+              0.058178,
+              0.057759,
+              0.0572
+            ],
+            "warm_rows_per_second": 8795286.276261317
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7621428741898844,
+            "character_perplexity": 5.824906071106866,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00015499876582933343,
+            "mean_prediction_kl_nats": 9.021660495853367e-05,
+            "prediction_kl_p99_nats": 4.863982362564446e-05,
+            "maximum_prediction_kl_nats": 0.05025749620497935,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6694626808166504,
+            "maximum_per_target_cross_entropy_increase": 0.3763465881347656
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015499876582933343,
+            "mean_prediction_kl_nats": 9.021660495853367e-05,
+            "prediction_kl_p99_nats": 4.863982362564446e-05,
+            "maximum_prediction_kl_nats": 0.05025749620497935,
+            "top1_changed_fraction": 0.00015335071308081582,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6694626808166504,
+            "maximum_per_target_cross_entropy_increase": 0.3763465881347656
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2730917,
+              "unique_rows": 11016,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11016
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "22c8fe6614ed4ff860170ad45c38208546df2ad07b0c98445a408a3ef57f2d17",
+            "table_sha256": "4ff1286f6601bdcc973c4fb202d12254a203df7053fd9d7a0fa7ef67bb2518cc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25930648297071457,
+          "representatives_sha256": "6bd47a0656069790de5e168cb0bc8157803c0809d0f911ce4fc16653eca85836",
+          "structurally_merged_rows": 744,
+          "backend_artifact_bytes": 2732122,
+          "backend_with_key_registry_bytes": 2893847,
+          "backend_with_datrie_key_index_bytes": 2827402,
+          "full_model_serving_artifact_bytes": 3188533,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9015189941457709,
+            "mean_cosine": 0.9999128903526319,
+            "p05_cosine": 0.9996942024133612,
+            "relative_l2_mean": 0.0024144631442916398,
+            "relative_l2_p95": 0.024995065662336325,
+            "relative_l2_max": 0.44265425326457186,
+            "weighted_relative_l2_mean": 0.0014611725216560735,
+            "weighted_relative_frobenius": 0.01452628211499881,
+            "weighted_mean_cosine": 0.9998874771283787,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9015189941457709,
+            "mean_cosine": 0.9999128903526319,
+            "p05_cosine": 0.9996942024133612,
+            "relative_l2_mean": 0.0024144631442916398,
+            "relative_l2_p95": 0.024995065662336325,
+            "relative_l2_max": 0.44265425326457186,
+            "weighted_relative_l2_mean": 0.0014611725216560735,
+            "weighted_relative_frobenius": 0.01452628211499881,
+            "weighted_mean_cosine": 0.9998874771283787,
+            "max_relative_norm_change": 0.009859081402261516
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.326451,
+            "warm_p50_ms": 0.0582125,
+            "warm_p95_ms": 0.06102435,
+            "warm_p99_ms": 0.06346775,
+            "samples_ms": [
+              0.064394,
+              0.059645,
+              0.060552,
+              0.058247,
+              0.058667,
+              0.059645,
+              0.059085,
+              0.058667,
+              0.060972,
+              0.060134,
+              0.058667,
+              0.057759,
+              0.057689,
+              0.059086,
+              0.056781,
+              0.058247,
+              0.058178,
+              0.058666,
+              0.05734,
+              0.05727,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.05727,
+              0.057689,
+              0.057689,
+              0.057759,
+              0.057689,
+              0.057759,
+              0.057828,
+              0.057689,
+              0.058667,
+              0.058737,
+              0.058667,
+              0.057689,
+              0.057689,
+              0.056711,
+              0.062019,
+              0.059575,
+              0.059644
+            ],
+            "warm_rows_per_second": 8795361.820914753
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7622545889350498,
+            "character_perplexity": 5.825556835353516,
+            "next_character_accuracy": 0.5002300260696212,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0002667370679342048,
+            "mean_prediction_kl_nats": 0.00011683976641027171,
+            "prediction_kl_p99_nats": 9.319469902709709e-05,
+            "maximum_prediction_kl_nats": 0.05025749620497935,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.8649499416351318,
+            "maximum_per_target_cross_entropy_increase": 0.3763465881347656
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0002667370679342048,
+            "mean_prediction_kl_nats": 0.00011683976641027171,
+            "prediction_kl_p99_nats": 9.319469902709709e-05,
+            "maximum_prediction_kl_nats": 0.05025749620497935,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.8649499416351318,
+            "maximum_per_target_cross_entropy_increase": 0.3763465881347656
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 1505280,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "811798cfb33aa60ba8fe68fa7bdc76afdb78f8ca17a89d0774d37291da0f6e18",
+            "table_sha256": "be3e6cb3faabcf8e7951e8696b5142f010d1678db8d4b7364a8077e60007e139",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.018310656072571874,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1506085,
+          "backend_with_key_registry_bytes": 1667810,
+          "backend_with_datrie_key_index_bytes": 1601365,
+          "full_model_serving_artifact_bytes": 1962496,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.999999955330057,
+            "mean_cosine": 0.9999999792978743,
+            "p05_cosine": 0.9999999716056523,
+            "relative_l2_mean": 0.00020619931955426777,
+            "relative_l2_p95": 0.00024277821700190904,
+            "relative_l2_max": 0.00030034986302671096,
+            "weighted_relative_l2_mean": 0.00018740057164396058,
+            "weighted_relative_frobenius": 0.00020735037194932163,
+            "weighted_mean_cosine": 0.9999999813082834,
+            "max_relative_norm_change": 0.00016211508208365433
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.590508,
+            "warm_p50_ms": 0.13646999999999998,
+            "warm_p95_ms": 0.20729335,
+            "warm_p99_ms": 0.22529658,
+            "samples_ms": [
+              0.202889,
+              0.216648,
+              0.206801,
+              0.198699,
+              0.199118,
+              0.193949,
+              0.198279,
+              0.194927,
+              0.199607,
+              0.195835,
+              0.192134,
+              0.158959,
+              0.136261,
+              0.13242,
+              0.135772,
+              0.134794,
+              0.132,
+              0.134374,
+              0.133816,
+              0.133397,
+              0.132908,
+              0.14527,
+              0.191644,
+              0.195905,
+              0.230826,
+              0.200654,
+              0.194928,
+              0.157562,
+              0.134863,
+              0.133956,
+              0.133467,
+              0.136679,
+              0.132978,
+              0.133816,
+              0.132978,
+              0.131512,
+              0.132489,
+              0.131511,
+              0.131511,
+              0.131022
+            ],
+            "warm_rows_per_second": 3751740.3092254717
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761986084105392,
+            "character_perplexity": 5.823992855185288,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.8033281047462318e-06,
+            "mean_prediction_kl_nats": 4.335405924479014e-09,
+            "prediction_kl_p99_nats": 3.1074343989937316e-08,
+            "maximum_prediction_kl_nats": 5.961903623836042e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010232925415039062,
+            "maximum_per_target_cross_entropy_increase": 0.000675201416015625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491617,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "811798cfb33aa60ba8fe68fa7bdc76afdb78f8ca17a89d0774d37291da0f6e18",
+            "table_sha256": "eb91629c3bc916b563bf24f086a779b9d4628c56b45efffbc009d24980259264",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14671796304173768,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492824,
+          "backend_with_key_registry_bytes": 1654549,
+          "backend_with_datrie_key_index_bytes": 1588104,
+          "full_model_serving_artifact_bytes": 1949235,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.999999955330057,
+            "mean_cosine": 0.9999999792978743,
+            "p05_cosine": 0.9999999716056523,
+            "relative_l2_mean": 0.00020619931955426777,
+            "relative_l2_p95": 0.00024277821700190904,
+            "relative_l2_max": 0.00030034986302671096,
+            "weighted_relative_l2_mean": 0.00018740057164396058,
+            "weighted_relative_frobenius": 0.00020735037194932163,
+            "weighted_mean_cosine": 0.9999999813082834,
+            "max_relative_norm_change": 0.00016211508208365433
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.94109,
+            "warm_p50_ms": 0.14191749999999997,
+            "warm_p95_ms": 0.1476904,
+            "warm_p99_ms": 0.15549723999999998,
+            "samples_ms": [
+              0.148553,
+              0.143454,
+              0.146247,
+              0.144362,
+              0.144711,
+              0.146597,
+              0.143733,
+              0.142895,
+              0.141429,
+              0.14108,
+              0.141847,
+              0.141987,
+              0.141918,
+              0.141918,
+              0.141847,
+              0.146667,
+              0.140032,
+              0.141428,
+              0.142407,
+              0.140032,
+              0.142336,
+              0.159937,
+              0.147645,
+              0.142406,
+              0.141917,
+              0.141987,
+              0.141848,
+              0.141918,
+              0.140031,
+              0.141429,
+              0.140032,
+              0.14094,
+              0.14101,
+              0.141009,
+              0.141429,
+              0.140032,
+              0.14101,
+              0.14094,
+              0.142407,
+              0.141428
+            ],
+            "warm_rows_per_second": 3607729.843042613
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761986084105392,
+            "character_perplexity": 5.823992855185288,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.8033281047462318e-06,
+            "mean_prediction_kl_nats": 4.335405924479014e-09,
+            "prediction_kl_p99_nats": 3.1074343989937316e-08,
+            "maximum_prediction_kl_nats": 5.961903623836042e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010232925415039062,
+            "maximum_per_target_cross_entropy_increase": 0.000675201416015625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491617,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "811798cfb33aa60ba8fe68fa7bdc76afdb78f8ca17a89d0774d37291da0f6e18",
+            "table_sha256": "eb91629c3bc916b563bf24f086a779b9d4628c56b45efffbc009d24980259264",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18984828097745776,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492823,
+          "backend_with_key_registry_bytes": 1654548,
+          "backend_with_datrie_key_index_bytes": 1588103,
+          "full_model_serving_artifact_bytes": 1949234,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.999999955330057,
+            "mean_cosine": 0.9999999792978743,
+            "p05_cosine": 0.9999999716056523,
+            "relative_l2_mean": 0.00020619931955426777,
+            "relative_l2_p95": 0.00024277821700190904,
+            "relative_l2_max": 0.00030034986302671096,
+            "weighted_relative_l2_mean": 0.00018740057164396058,
+            "weighted_relative_frobenius": 0.00020735037194932163,
+            "weighted_mean_cosine": 0.9999999813082834,
+            "max_relative_norm_change": 0.00016211508208365433
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.877116,
+            "warm_p50_ms": 0.14149850000000003,
+            "warm_p95_ms": 0.14473545000000002,
+            "warm_p99_ms": 0.16253985999999998,
+            "samples_ms": [
+              0.1452,
+              0.143733,
+              0.142895,
+              0.142476,
+              0.142337,
+              0.141499,
+              0.141498,
+              0.141499,
+              0.141499,
+              0.141429,
+              0.14101,
+              0.141359,
+              0.141499,
+              0.141009,
+              0.14101,
+              0.141429,
+              0.142336,
+              0.141498,
+              0.143315,
+              0.144711,
+              0.144362,
+              0.142406,
+              0.142336,
+              0.14101,
+              0.142407,
+              0.173626,
+              0.142826,
+              0.141498,
+              0.140591,
+              0.140032,
+              0.140032,
+              0.141988,
+              0.141429,
+              0.141009,
+              0.141429,
+              0.141917,
+              0.140101,
+              0.140521,
+              0.140032,
+              0.139543
+            ],
+            "warm_rows_per_second": 3618412.9160379786
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761986084105392,
+            "character_perplexity": 5.823992855185288,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.8033281047462318e-06,
+            "mean_prediction_kl_nats": 4.335405924479014e-09,
+            "prediction_kl_p99_nats": 3.1074343989937316e-08,
+            "maximum_prediction_kl_nats": 5.961903623836042e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010232925415039062,
+            "maximum_per_target_cross_entropy_increase": 0.000675201416015625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491617,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "811798cfb33aa60ba8fe68fa7bdc76afdb78f8ca17a89d0774d37291da0f6e18",
+            "table_sha256": "eb91629c3bc916b563bf24f086a779b9d4628c56b45efffbc009d24980259264",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15167432511225343,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492823,
+          "backend_with_key_registry_bytes": 1654548,
+          "backend_with_datrie_key_index_bytes": 1588103,
+          "full_model_serving_artifact_bytes": 1949234,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.999999955330057,
+            "mean_cosine": 0.9999999792978743,
+            "p05_cosine": 0.9999999716056523,
+            "relative_l2_mean": 0.00020619931955426777,
+            "relative_l2_p95": 0.00024277821700190904,
+            "relative_l2_max": 0.00030034986302671096,
+            "weighted_relative_l2_mean": 0.00018740057164396058,
+            "weighted_relative_frobenius": 0.00020735037194932163,
+            "weighted_mean_cosine": 0.9999999813082834,
+            "max_relative_norm_change": 0.00016211508208365433
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.848271,
+            "warm_p50_ms": 0.14237149999999998,
+            "warm_p95_ms": 0.169924,
+            "warm_p99_ms": 0.17363035999999998,
+            "samples_ms": [
+              0.144362,
+              0.176,
+              0.155606,
+              0.147155,
+              0.144781,
+              0.143803,
+              0.143803,
+              0.144292,
+              0.142337,
+              0.143245,
+              0.145759,
+              0.144781,
+              0.169924,
+              0.141498,
+              0.140521,
+              0.14094,
+              0.140939,
+              0.141498,
+              0.140032,
+              0.143873,
+              0.143803,
+              0.144222,
+              0.141987,
+              0.141917,
+              0.14094,
+              0.141918,
+              0.169924,
+              0.14101,
+              0.16315,
+              0.144223,
+              0.142896,
+              0.14101,
+              0.141498,
+              0.141498,
+              0.140032,
+              0.141848,
+              0.142406,
+              0.141917,
+              0.14094,
+              0.140032
+            ],
+            "warm_rows_per_second": 3596225.368138989
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761986084105392,
+            "character_perplexity": 5.823992855185288,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.8033281047462318e-06,
+            "mean_prediction_kl_nats": 4.335405924479014e-09,
+            "prediction_kl_p99_nats": 3.1074343989937316e-08,
+            "maximum_prediction_kl_nats": 5.961903623836042e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010232925415039062,
+            "maximum_per_target_cross_entropy_increase": 0.000675201416015625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404829,
+              "unique_rows": 11025,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11025
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "aae891e910365c9838a8e14ff62bc518e1387413e3136272c19c395acdcd1d62",
+            "table_sha256": "f10854c90a71b5b38d2dc288a44794aff49beb0abcf2c13e8058bcad7e440637",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14365919097326696,
+          "representatives_sha256": "0433240c0af194a070351d5d57755a2eb04ea4365346eabc9150ccbb46b1c357",
+          "structurally_merged_rows": 735,
+          "backend_artifact_bytes": 1406034,
+          "backend_with_key_registry_bytes": 1567759,
+          "backend_with_datrie_key_index_bytes": 1501314,
+          "full_model_serving_artifact_bytes": 1862445,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.993229021916863,
+            "mean_cosine": 0.9999580896496946,
+            "p05_cosine": 0.9996981100397673,
+            "relative_l2_mean": 0.0023555824252269805,
+            "relative_l2_p95": 0.02481648552558157,
+            "relative_l2_max": 0.1164297624166434,
+            "weighted_relative_l2_mean": 0.0010839693066042207,
+            "weighted_relative_frobenius": 0.0053040528702744776,
+            "weighted_mean_cosine": 0.9999856948084294,
+            "max_relative_norm_change": 0.009869613651210883
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9932305961542881,
+            "mean_cosine": 0.9999581091146609,
+            "p05_cosine": 0.9996977228528464,
+            "relative_l2_mean": 0.0021622629544317713,
+            "relative_l2_p95": 0.024824343791554238,
+            "relative_l2_max": 0.11641462754844928,
+            "weighted_relative_l2_mean": 0.0009031974001573273,
+            "weighted_relative_frobenius": 0.005301355563665608,
+            "weighted_mean_cosine": 0.9999857061304772,
+            "max_relative_norm_change": 0.009947623318429478
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.592791,
+            "warm_p50_ms": 0.1414285,
+            "warm_p95_ms": 0.14527,
+            "warm_p99_ms": 0.15131998,
+            "samples_ms": [
+              0.14527,
+              0.143314,
+              0.141499,
+              0.141499,
+              0.14101,
+              0.14527,
+              0.142337,
+              0.142407,
+              0.141918,
+              0.142476,
+              0.141917,
+              0.140032,
+              0.141429,
+              0.141428,
+              0.139543,
+              0.141917,
+              0.140032,
+              0.141848,
+              0.14052,
+              0.14101,
+              0.141429,
+              0.144292,
+              0.143315,
+              0.140521,
+              0.141429,
+              0.155188,
+              0.142896,
+              0.14101,
+              0.141009,
+              0.140521,
+              0.140521,
+              0.14101,
+              0.139124,
+              0.141429,
+              0.140521,
+              0.140451,
+              0.140102,
+              0.140031,
+              0.140032,
+              0.141428
+            ],
+            "warm_rows_per_second": 3620203.848587802
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620133024290583,
+            "character_perplexity": 5.824151376665186,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.541531689919542e-05,
+            "mean_prediction_kl_nats": 1.8676947177272281e-06,
+            "prediction_kl_p99_nats": 3.056987213103323e-05,
+            "maximum_prediction_kl_nats": 0.009301476677892186,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3039989471435547,
+            "maximum_per_target_cross_entropy_increase": 0.04271221160888672
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 2.7218694088177672e-05,
+            "mean_prediction_kl_nats": 1.8641467086508255e-06,
+            "prediction_kl_p99_nats": 3.073360547172181e-05,
+            "maximum_prediction_kl_nats": 0.00930052162812792,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3040299415588379,
+            "maximum_per_target_cross_entropy_increase": 0.04257345199584961
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404621,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "90e0b3db1e82134bb99d2f655fea869dbdbd1b964085839484dc2fe5e4c8873c",
+            "table_sha256": "d5fb9ea6ff92fffe220e9a68f328f35920e64190e49e455cbb51888e90481c3f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18668558495119214,
+          "representatives_sha256": "b9022b09ef1ceb36d6ae184adf95f607090945b983bc83f60a1538cb45bc4baa",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 1405826,
+          "backend_with_key_registry_bytes": 1567551,
+          "backend_with_datrie_key_index_bytes": 1501106,
+          "full_model_serving_artifact_bytes": 1862237,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815473821674361,
+            "mean_cosine": 0.9999554916802988,
+            "p05_cosine": 0.9996976348833175,
+            "relative_l2_mean": 0.002385236134563276,
+            "relative_l2_p95": 0.024851234547092083,
+            "relative_l2_max": 0.1928889038834104,
+            "weighted_relative_l2_mean": 0.0010919041739036977,
+            "weighted_relative_frobenius": 0.005392229889626232,
+            "weighted_mean_cosine": 0.999985079385915,
+            "max_relative_norm_change": 0.009869613651210883
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815473620654889,
+            "mean_cosine": 0.9999555112196998,
+            "p05_cosine": 0.9996973251586957,
+            "relative_l2_mean": 0.002191942915397932,
+            "relative_l2_p95": 0.024867639489037825,
+            "relative_l2_max": 0.1928818136964326,
+            "weighted_relative_l2_mean": 0.0009111399513267083,
+            "weighted_relative_frobenius": 0.005389569694692704,
+            "weighted_mean_cosine": 0.9999850907541233,
+            "max_relative_norm_change": 0.009947623318429478
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.582804,
+            "warm_p50_ms": 0.1409745,
+            "warm_p95_ms": 0.14529795,
+            "warm_p99_ms": 0.15183567,
+            "samples_ms": [
+              0.145201,
+              0.142896,
+              0.142826,
+              0.142477,
+              0.141009,
+              0.141498,
+              0.141918,
+              0.140521,
+              0.14052,
+              0.145829,
+              0.14094,
+              0.140521,
+              0.141009,
+              0.14094,
+              0.14101,
+              0.139963,
+              0.14527,
+              0.14094,
+              0.139543,
+              0.140032,
+              0.140032,
+              0.155676,
+              0.140451,
+              0.140591,
+              0.140521,
+              0.14101,
+              0.140032,
+              0.140102,
+              0.141498,
+              0.14101,
+              0.14101,
+              0.138635,
+              0.14101,
+              0.140451,
+              0.14101,
+              0.140031,
+              0.142825,
+              0.142895,
+              0.140102,
+              0.14052
+            ],
+            "warm_rows_per_second": 3631862.499955666
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620168032906287,
+            "character_perplexity": 5.824171766248611,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.8916273573369703e-05,
+            "mean_prediction_kl_nats": 3.681654640875653e-06,
+            "prediction_kl_p99_nats": 3.130291623387823e-05,
+            "maximum_prediction_kl_nats": 0.012031577285817373,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3039989471435547,
+            "maximum_per_target_cross_entropy_increase": 0.10785055160522461
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.071965707573691e-05,
+            "mean_prediction_kl_nats": 3.6776569666511883e-06,
+            "prediction_kl_p99_nats": 3.151438021132739e-05,
+            "maximum_prediction_kl_nats": 0.012028617322816076,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3040299415588379,
+            "maximum_per_target_cross_entropy_increase": 0.10784733295440674
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404621,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "90e0b3db1e82134bb99d2f655fea869dbdbd1b964085839484dc2fe5e4c8873c",
+            "table_sha256": "d5fb9ea6ff92fffe220e9a68f328f35920e64190e49e455cbb51888e90481c3f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1453714920207858,
+          "representatives_sha256": "b9022b09ef1ceb36d6ae184adf95f607090945b983bc83f60a1538cb45bc4baa",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 1405826,
+          "backend_with_key_registry_bytes": 1567551,
+          "backend_with_datrie_key_index_bytes": 1501106,
+          "full_model_serving_artifact_bytes": 1862237,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815473821674361,
+            "mean_cosine": 0.9999554916802988,
+            "p05_cosine": 0.9996976348833175,
+            "relative_l2_mean": 0.002385236134563276,
+            "relative_l2_p95": 0.024851234547092083,
+            "relative_l2_max": 0.1928889038834104,
+            "weighted_relative_l2_mean": 0.0010919041739036977,
+            "weighted_relative_frobenius": 0.005392229889626232,
+            "weighted_mean_cosine": 0.999985079385915,
+            "max_relative_norm_change": 0.009869613651210883
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9815473620654889,
+            "mean_cosine": 0.9999555112196998,
+            "p05_cosine": 0.9996973251586957,
+            "relative_l2_mean": 0.002191942915397932,
+            "relative_l2_p95": 0.024867639489037825,
+            "relative_l2_max": 0.1928818136964326,
+            "weighted_relative_l2_mean": 0.0009111399513267083,
+            "weighted_relative_frobenius": 0.005389569694692704,
+            "weighted_mean_cosine": 0.9999850907541233,
+            "max_relative_norm_change": 0.009947623318429478
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.555426,
+            "warm_p50_ms": 0.1419875,
+            "warm_p95_ms": 0.17034305,
+            "warm_p99_ms": 0.17204773,
+            "samples_ms": [
+              0.150438,
+              0.173137,
+              0.144781,
+              0.143734,
+              0.142407,
+              0.142895,
+              0.142895,
+              0.14101,
+              0.142337,
+              0.141499,
+              0.141918,
+              0.14052,
+              0.140521,
+              0.141429,
+              0.141987,
+              0.141917,
+              0.147575,
+              0.142407,
+              0.170344,
+              0.169854,
+              0.170343,
+              0.159936,
+              0.141988,
+              0.141429,
+              0.141987,
+              0.142406,
+              0.141499,
+              0.14101,
+              0.144851,
+              0.142966,
+              0.142896,
+              0.142896,
+              0.141499,
+              0.140031,
+              0.140451,
+              0.141009,
+              0.140032,
+              0.14101,
+              0.140521,
+              0.141499
+            ],
+            "warm_rows_per_second": 3605951.2281010654
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7620168032906287,
+            "character_perplexity": 5.824171766248611,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.8916273573369703e-05,
+            "mean_prediction_kl_nats": 3.681654640875653e-06,
+            "prediction_kl_p99_nats": 3.130291623387823e-05,
+            "maximum_prediction_kl_nats": 0.012031577285817373,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3039989471435547,
+            "maximum_per_target_cross_entropy_increase": 0.10785055160522461
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.071965707573691e-05,
+            "mean_prediction_kl_nats": 3.6776569666511883e-06,
+            "prediction_kl_p99_nats": 3.151438021132739e-05,
+            "maximum_prediction_kl_nats": 0.012028617322816076,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3040299415588379,
+            "maximum_per_target_cross_entropy_increase": 0.10784733295440674
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404406,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "00951198c4cc8a6dfcefc09b2f4af63b6e6751a341269d9d242ee5e5cd8eeb0f",
+            "table_sha256": "b72e110bfb4b26d659114a5ded8020f9e70d729b2a8caa0897e3daa7c77a34bc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14290357707068324,
+          "representatives_sha256": "23ac79b3f25b1f4c3454b3eaf09d347cbd138e5036dab7825f9678041e80a60e",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 1405611,
+          "backend_with_key_registry_bytes": 1567336,
+          "backend_with_datrie_key_index_bytes": 1500891,
+          "full_model_serving_artifact_bytes": 1862022,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536879264202704,
+            "mean_cosine": 0.999947688741713,
+            "p05_cosine": 0.9996970572637678,
+            "relative_l2_mean": 0.0024366258444878178,
+            "relative_l2_p95": 0.024877595078460064,
+            "relative_l2_max": 0.30427105702833357,
+            "weighted_relative_l2_mean": 0.0013082334405640028,
+            "weighted_relative_frobenius": 0.009898667711519395,
+            "weighted_mean_cosine": 0.9999521449646063,
+            "max_relative_norm_change": 0.009869613651210883
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536887235445123,
+            "mean_cosine": 0.9999477084445584,
+            "p05_cosine": 0.9996969521525462,
+            "relative_l2_mean": 0.002243366937749199,
+            "relative_l2_p95": 0.024871331284442407,
+            "relative_l2_max": 0.30426727296020073,
+            "weighted_relative_l2_mean": 0.001127612257645129,
+            "weighted_relative_frobenius": 0.009897187065153733,
+            "weighted_mean_cosine": 0.9999521569043672,
+            "max_relative_norm_change": 0.009947623318429478
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.442353,
+            "warm_p50_ms": 0.14149850000000003,
+            "warm_p95_ms": 0.1699727,
+            "warm_p99_ms": 0.17423063,
+            "samples_ms": [
+              0.144711,
+              0.142896,
+              0.142896,
+              0.14101,
+              0.140451,
+              0.14101,
+              0.141499,
+              0.141429,
+              0.157003,
+              0.141917,
+              0.14101,
+              0.141918,
+              0.141987,
+              0.140521,
+              0.169854,
+              0.169295,
+              0.175511,
+              0.168946,
+              0.141429,
+              0.140032,
+              0.141917,
+              0.141498,
+              0.140032,
+              0.145689,
+              0.140032,
+              0.14108,
+              0.140939,
+              0.140521,
+              0.142476,
+              0.140521,
+              0.141499,
+              0.14094,
+              0.140521,
+              0.140032,
+              0.141429,
+              0.172228,
+              0.145689,
+              0.141987,
+              0.141918,
+              0.14101
+            ],
+            "warm_rows_per_second": 3618412.9160379786
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7621404760933819,
+            "character_perplexity": 5.824892102436738,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00015260030050063522,
+            "mean_prediction_kl_nats": 9.020268807501378e-05,
+            "prediction_kl_p99_nats": 4.803773480834617e-05,
+            "maximum_prediction_kl_nats": 0.05024508373924575,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6693630218505859,
+            "maximum_per_target_cross_entropy_increase": 0.37635135650634766
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015440390704628653,
+            "mean_prediction_kl_nats": 9.021075152072548e-05,
+            "prediction_kl_p99_nats": 4.868768343371962e-05,
+            "maximum_prediction_kl_nats": 0.050253411308513185,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6694545745849609,
+            "maximum_per_target_cross_entropy_increase": 0.376340389251709
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1403813,
+              "unique_rows": 11016,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11016
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "1ffc72ca16ebb2263679347db4ab599758452a04990d3088f40760ef5fec0ac2",
+            "table_sha256": "7ebf6dbde9b37f79bc2f68357cd39a312fd52e6308a9e135fced9ee15413d0a3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1452479420695454,
+          "representatives_sha256": "6bd47a0656069790de5e168cb0bc8157803c0809d0f911ce4fc16653eca85836",
+          "structurally_merged_rows": 744,
+          "backend_artifact_bytes": 1405018,
+          "backend_with_key_registry_bytes": 1566743,
+          "backend_with_datrie_key_index_bytes": 1500298,
+          "full_model_serving_artifact_bytes": 1861429,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9015172971537725,
+            "mean_cosine": 0.9999128697481101,
+            "p05_cosine": 0.999693868495509,
+            "relative_l2_mean": 0.0026077337396000037,
+            "relative_l2_p95": 0.025014643768802226,
+            "relative_l2_max": 0.44264593861029344,
+            "weighted_relative_l2_mean": 0.0016419059260299174,
+            "weighted_relative_frobenius": 0.014528266044215006,
+            "weighted_mean_cosine": 0.9998874538114033,
+            "max_relative_norm_change": 0.009869613651210883
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9014989543453286,
+            "mean_cosine": 0.9999128887472181,
+            "p05_cosine": 0.9996941556050969,
+            "relative_l2_mean": 0.002414558381037749,
+            "relative_l2_p95": 0.02500559539624438,
+            "relative_l2_max": 0.44268190571327065,
+            "weighted_relative_l2_mean": 0.0014614366736284347,
+            "weighted_relative_frobenius": 0.014527090261736098,
+            "weighted_mean_cosine": 0.9998874688052568,
+            "max_relative_norm_change": 0.009947623318429478
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.497178,
+            "warm_p50_ms": 0.1424065,
+            "warm_p95_ms": 0.14750865,
+            "warm_p99_ms": 0.16694762999999999,
+            "samples_ms": [
+              0.144711,
+              0.144712,
+              0.142477,
+              0.142895,
+              0.142407,
+              0.143384,
+              0.154209,
+              0.144222,
+              0.142406,
+              0.142476,
+              0.141848,
+              0.142407,
+              0.142826,
+              0.142476,
+              0.141428,
+              0.141429,
+              0.147156,
+              0.145201,
+              0.142407,
+              0.142966,
+              0.141429,
+              0.14527,
+              0.144362,
+              0.143804,
+              0.142337,
+              0.141499,
+              0.141009,
+              0.14101,
+              0.14101,
+              0.141917,
+              0.141987,
+              0.141988,
+              0.140102,
+              0.141499,
+              0.175092,
+              0.141917,
+              0.141918,
+              0.14101,
+              0.141987,
+              0.142336
+            ],
+            "warm_rows_per_second": 3595341.5047768187
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7622522200388164,
+            "character_perplexity": 5.825543035230217,
+            "next_character_accuracy": 0.5002300260696212,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00026436754263474687,
+            "mean_prediction_kl_nats": 0.00011682734223863031,
+            "prediction_kl_p99_nats": 9.370032000681665e-05,
+            "maximum_prediction_kl_nats": 0.05024508373924575,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.8651859760284424,
+            "maximum_per_target_cross_entropy_increase": 0.37635135650634766
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0002661713507337706,
+            "mean_prediction_kl_nats": 0.00011683772936588893,
+            "prediction_kl_p99_nats": 9.312245935059851e-05,
+            "maximum_prediction_kl_nats": 0.050253411308513185,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.8652682304382324,
+            "maximum_per_target_cross_entropy_increase": 0.376340389251709
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 799680,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "f6ffab41a644dd67e026935d7b50595b09e149dee71f6d058748771dac0f90df",
+            "table_sha256": "286e59cb1634e5510ae31256135a585ad96dc5281b739140ec86c3f850c402a8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.015558068873360753,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 800527,
+          "backend_with_key_registry_bytes": 962252,
+          "backend_with_datrie_key_index_bytes": 895807,
+          "full_model_serving_artifact_bytes": 1256938,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999355787040166,
+            "mean_cosine": 0.9999869086187041,
+            "p05_cosine": 0.9999750882928043,
+            "relative_l2_mean": 0.00500744562114531,
+            "relative_l2_p95": 0.00710717717765626,
+            "relative_l2_max": 0.011400289643805562,
+            "weighted_relative_l2_mean": 0.005094142639764323,
+            "weighted_relative_frobenius": 0.005507144397623611,
+            "weighted_mean_cosine": 0.999985464118255,
+            "max_relative_norm_change": 0.0030795821881461597
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.335029,
+            "warm_p50_ms": 0.0974985,
+            "warm_p95_ms": 0.10225135,
+            "warm_p99_ms": 0.13308359999999997,
+            "samples_ms": [
+              0.10127,
+              0.098895,
+              0.09701,
+              0.096521,
+              0.097428,
+              0.097918,
+              0.097848,
+              0.097499,
+              0.151905,
+              0.102178,
+              0.097918,
+              0.09701,
+              0.09694,
+              0.097498,
+              0.098825,
+              0.097428,
+              0.099384,
+              0.097987,
+              0.103645,
+              0.10127,
+              0.09694,
+              0.100712,
+              0.09701,
+              0.09659,
+              0.097498,
+              0.098406,
+              0.096451,
+              0.097918,
+              0.096521,
+              0.096451,
+              0.095543,
+              0.09652,
+              0.096521,
+              0.096102,
+              0.096521,
+              0.097498,
+              0.098825,
+              0.098895,
+              0.097917,
+              0.099314
+            ],
+            "warm_rows_per_second": 5251362.8414796125
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761994707803187,
+            "character_perplexity": 5.824043079756192,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.82039132299268e-06,
+            "mean_prediction_kl_nats": 3.6558254564872534e-06,
+            "prediction_kl_p99_nats": 2.1573732474216604e-05,
+            "maximum_prediction_kl_nats": 9.125894225908877e-05,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.029454708099365234,
+            "maximum_per_target_cross_entropy_increase": 0.02509140968322754
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893386,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 12,
+              "compressed_blocks": 86,
+              "zlib_blocks": 86,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "f6ffab41a644dd67e026935d7b50595b09e149dee71f6d058748771dac0f90df",
+            "table_sha256": "7abea1c680e92a405165f5a1849259c285226ac51a1c93562204d21ecce8820c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08383755898103118,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894632,
+          "backend_with_key_registry_bytes": 1056357,
+          "backend_with_datrie_key_index_bytes": 989912,
+          "full_model_serving_artifact_bytes": 1351043,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999355787040166,
+            "mean_cosine": 0.9999869086187041,
+            "p05_cosine": 0.9999750882928043,
+            "relative_l2_mean": 0.00500744562114531,
+            "relative_l2_p95": 0.00710717717765626,
+            "relative_l2_max": 0.011400289643805562,
+            "weighted_relative_l2_mean": 0.005094142639764323,
+            "weighted_relative_frobenius": 0.005507144397623611,
+            "weighted_mean_cosine": 0.999985464118255,
+            "max_relative_norm_change": 0.0030795821881461597
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.955942,
+            "warm_p50_ms": 0.11028,
+            "warm_p95_ms": 0.11426389999999999,
+            "warm_p99_ms": 0.13382515999999997,
+            "samples_ms": [
+              0.119639,
+              0.113981,
+              0.112095,
+              0.112515,
+              0.108394,
+              0.111746,
+              0.112165,
+              0.111257,
+              0.112515,
+              0.112515,
+              0.109721,
+              0.111188,
+              0.110279,
+              0.110209,
+              0.109791,
+              0.111188,
+              0.109302,
+              0.108324,
+              0.109721,
+              0.111188,
+              0.11028,
+              0.112655,
+              0.107835,
+              0.142895,
+              0.113562,
+              0.10979,
+              0.111117,
+              0.109371,
+              0.110699,
+              0.109302,
+              0.107905,
+              0.110209,
+              0.110699,
+              0.10979,
+              0.11028,
+              0.110629,
+              0.10986,
+              0.110209,
+              0.109721,
+              0.11028
+            ],
+            "warm_rows_per_second": 4642727.602466449
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761994707803187,
+            "character_perplexity": 5.824043079756192,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.82039132299268e-06,
+            "mean_prediction_kl_nats": 3.6558254564872534e-06,
+            "prediction_kl_p99_nats": 2.1573732474216604e-05,
+            "maximum_prediction_kl_nats": 9.125894225908877e-05,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.029454708099365234,
+            "maximum_per_target_cross_entropy_increase": 0.02509140968322754
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893386,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 12,
+              "compressed_blocks": 86,
+              "zlib_blocks": 86,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "f6ffab41a644dd67e026935d7b50595b09e149dee71f6d058748771dac0f90df",
+            "table_sha256": "7abea1c680e92a405165f5a1849259c285226ac51a1c93562204d21ecce8820c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.12420411384664476,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894631,
+          "backend_with_key_registry_bytes": 1056356,
+          "backend_with_datrie_key_index_bytes": 989911,
+          "full_model_serving_artifact_bytes": 1351042,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999355787040166,
+            "mean_cosine": 0.9999869086187041,
+            "p05_cosine": 0.9999750882928043,
+            "relative_l2_mean": 0.00500744562114531,
+            "relative_l2_p95": 0.00710717717765626,
+            "relative_l2_max": 0.011400289643805562,
+            "weighted_relative_l2_mean": 0.005094142639764323,
+            "weighted_relative_frobenius": 0.005507144397623611,
+            "weighted_mean_cosine": 0.999985464118255,
+            "max_relative_norm_change": 0.0030795821881461597
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.91753,
+            "warm_p50_ms": 0.110489,
+            "warm_p95_ms": 0.11328269999999999,
+            "warm_p99_ms": 0.12083590999999999,
+            "samples_ms": [
+              0.115937,
+              0.112515,
+              0.113073,
+              0.110699,
+              0.11028,
+              0.113143,
+              0.110698,
+              0.108813,
+              0.110769,
+              0.109302,
+              0.112095,
+              0.123968,
+              0.111117,
+              0.111117,
+              0.110768,
+              0.109302,
+              0.111118,
+              0.10979,
+              0.109232,
+              0.11028,
+              0.11021,
+              0.109232,
+              0.109302,
+              0.11021,
+              0.111187,
+              0.111187,
+              0.111187,
+              0.111117,
+              0.110698,
+              0.10979,
+              0.109721,
+              0.108882,
+              0.108743,
+              0.110699,
+              0.108813,
+              0.10972,
+              0.109791,
+              0.11021,
+              0.113074,
+              0.11021
+            ],
+            "warm_rows_per_second": 4633945.46063409
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761994707803187,
+            "character_perplexity": 5.824043079756192,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.82039132299268e-06,
+            "mean_prediction_kl_nats": 3.6558254564872534e-06,
+            "prediction_kl_p99_nats": 2.1573732474216604e-05,
+            "maximum_prediction_kl_nats": 9.125894225908877e-05,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.029454708099365234,
+            "maximum_per_target_cross_entropy_increase": 0.02509140968322754
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893386,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 12,
+              "compressed_blocks": 86,
+              "zlib_blocks": 86,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "f6ffab41a644dd67e026935d7b50595b09e149dee71f6d058748771dac0f90df",
+            "table_sha256": "7abea1c680e92a405165f5a1849259c285226ac51a1c93562204d21ecce8820c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08165040798485279,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894631,
+          "backend_with_key_registry_bytes": 1056356,
+          "backend_with_datrie_key_index_bytes": 989911,
+          "full_model_serving_artifact_bytes": 1351042,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999355787040166,
+            "mean_cosine": 0.9999869086187041,
+            "p05_cosine": 0.9999750882928043,
+            "relative_l2_mean": 0.00500744562114531,
+            "relative_l2_p95": 0.00710717717765626,
+            "relative_l2_max": 0.011400289643805562,
+            "weighted_relative_l2_mean": 0.005094142639764323,
+            "weighted_relative_frobenius": 0.005507144397623611,
+            "weighted_mean_cosine": 0.999985464118255,
+            "max_relative_norm_change": 0.0030795821881461597
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.886311,
+            "warm_p50_ms": 0.111118,
+            "warm_p95_ms": 0.1136074,
+            "warm_p99_ms": 0.12426904,
+            "samples_ms": [
+              0.113562,
+              0.113143,
+              0.112235,
+              0.111746,
+              0.111118,
+              0.111677,
+              0.111537,
+              0.11028,
+              0.111677,
+              0.110699,
+              0.112026,
+              0.10979,
+              0.111257,
+              0.110629,
+              0.109791,
+              0.130534,
+              0.11028,
+              0.111606,
+              0.110209,
+              0.10979,
+              0.108324,
+              0.110279,
+              0.111746,
+              0.110698,
+              0.11021,
+              0.108813,
+              0.10965,
+              0.110349,
+              0.111118,
+              0.111118,
+              0.111118,
+              0.111746,
+              0.111188,
+              0.111188,
+              0.111607,
+              0.111607,
+              0.11028,
+              0.110209,
+              0.10972,
+              0.11447
+            ],
+            "warm_rows_per_second": 4607714.321712054
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761994707803187,
+            "character_perplexity": 5.824043079756192,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.82039132299268e-06,
+            "mean_prediction_kl_nats": 3.6558254564872534e-06,
+            "prediction_kl_p99_nats": 2.1573732474216604e-05,
+            "maximum_prediction_kl_nats": 9.125894225908877e-05,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.029454708099365234,
+            "maximum_per_target_cross_entropy_increase": 0.02509140968322754
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 843028,
+              "unique_rows": 11025,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 10,
+              "compressed_blocks": 82,
+              "zlib_blocks": 82,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11025
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "baddebcdadaa5e9ed9bd10c9957011f70f2e1711d3e0a79c782e80febbef68fd",
+            "table_sha256": "500510c305ae5f3d6b1008b379263ae6994195ab4eb0998621e26fb69f412ffe",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08750807098113,
+          "representatives_sha256": "7b7c1e628ffdfed37d646fe62d039db827254573cf58796ef56099be67fe76a6",
+          "structurally_merged_rows": 735,
+          "backend_artifact_bytes": 844272,
+          "backend_with_key_registry_bytes": 1005997,
+          "backend_with_datrie_key_index_bytes": 939552,
+          "full_model_serving_artifact_bytes": 1300683,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9932693001510837,
+            "mean_cosine": 0.9999451072569152,
+            "p05_cosine": 0.9996889849616917,
+            "relative_l2_mean": 0.00690180114140664,
+            "relative_l2_p95": 0.025131177274422562,
+            "relative_l2_max": 0.11602073490844073,
+            "weighted_relative_l2_mean": 0.0058481960078201126,
+            "weighted_relative_frobenius": 0.007637971226019644,
+            "weighted_mean_cosine": 0.9999712554419257,
+            "max_relative_norm_change": 0.010412935979967038
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9932108978475287,
+            "mean_cosine": 0.9999568063857526,
+            "p05_cosine": 0.9996803623187015,
+            "relative_l2_mean": 0.0022034061731780164,
+            "relative_l2_p95": 0.025527870272695073,
+            "relative_l2_max": 0.11652798676048805,
+            "weighted_relative_l2_mean": 0.0009280876904894124,
+            "weighted_relative_frobenius": 0.005479980336186081,
+            "weighted_mean_cosine": 0.9999850011202908,
+            "max_relative_norm_change": 0.009931715881154553
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.818774,
+            "warm_p50_ms": 0.109511,
+            "warm_p95_ms": 0.11263625,
+            "warm_p99_ms": 0.12160494999999999,
+            "samples_ms": [
+              0.114959,
+              0.110698,
+              0.110279,
+              0.110209,
+              0.10972,
+              0.111606,
+              0.112514,
+              0.10986,
+              0.11021,
+              0.11021,
+              0.109302,
+              0.111118,
+              0.125854,
+              0.109302,
+              0.109721,
+              0.109232,
+              0.108883,
+              0.108813,
+              0.108813,
+              0.108324,
+              0.108813,
+              0.109302,
+              0.110698,
+              0.109232,
+              0.109302,
+              0.109301,
+              0.110768,
+              0.109721,
+              0.109302,
+              0.110768,
+              0.107905,
+              0.109301,
+              0.108813,
+              0.111117,
+              0.111257,
+              0.109791,
+              0.108813,
+              0.109302,
+              0.108743,
+              0.109301
+            ],
+            "warm_rows_per_second": 4675329.418962479
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7619870145379721,
+            "character_perplexity": 5.823998274020508,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -8.728967694862381e-07,
+            "mean_prediction_kl_nats": 5.528766134507814e-06,
+            "prediction_kl_p99_nats": 4.193367377456218e-05,
+            "maximum_prediction_kl_nats": 0.00917243119023907,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.30211687088012695,
+            "maximum_per_target_cross_entropy_increase": 0.04476737976074219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -7.69323562160144e-06,
+            "mean_prediction_kl_nats": 1.885823733372095e-06,
+            "prediction_kl_p99_nats": 3.158589785402744e-05,
+            "maximum_prediction_kl_nats": 0.009249863092956145,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30378103256225586,
+            "maximum_per_target_cross_entropy_increase": 0.041460514068603516
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842894,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 81,
+              "zlib_blocks": 81,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "cab1f9f7e8f4959b0926979e6921bc461c4e345d8e9cfb1581dcd2010c1c7fac",
+            "table_sha256": "033187898fa39c8d68eb9a9fc3110f8bb7c02a7ab434d4575ced7ddad6a1987b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08755814679898322,
+          "representatives_sha256": "6981e9856c2b8822a5be05de16e0ce8076b5640fe3c60b327f3c856fc8916fd0",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 844138,
+          "backend_with_key_registry_bytes": 1005863,
+          "backend_with_datrie_key_index_bytes": 939418,
+          "full_model_serving_artifact_bytes": 1300549,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9813272660500127,
+            "mean_cosine": 0.9999425033140585,
+            "p05_cosine": 0.9996876099233718,
+            "relative_l2_mean": 0.006930306178244006,
+            "relative_l2_p95": 0.02523025606963592,
+            "relative_l2_max": 0.19399595707235132,
+            "weighted_relative_l2_mean": 0.00585568583280781,
+            "weighted_relative_frobenius": 0.007698795623847522,
+            "weighted_mean_cosine": 0.9999706467512589,
+            "max_relative_norm_change": 0.010412935979967038
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9810029673989541,
+            "mean_cosine": 0.9999541660152366,
+            "p05_cosine": 0.9996789564990175,
+            "relative_l2_mean": 0.0022332823861725636,
+            "relative_l2_p95": 0.025565944541053185,
+            "relative_l2_max": 0.1955265801156805,
+            "weighted_relative_l2_mean": 0.0009360131086985215,
+            "weighted_relative_frobenius": 0.005565058598246341,
+            "weighted_mean_cosine": 0.9999843880267955,
+            "max_relative_norm_change": 0.009931715881154553
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.669174,
+            "warm_p50_ms": 0.11171149999999999,
+            "warm_p95_ms": 0.11365279999999998,
+            "warm_p99_ms": 0.12291881999999998,
+            "samples_ms": [
+              0.115378,
+              0.113003,
+              0.112165,
+              0.111677,
+              0.111258,
+              0.112654,
+              0.111676,
+              0.112654,
+              0.112165,
+              0.109721,
+              0.110698,
+              0.110279,
+              0.12774,
+              0.111607,
+              0.110699,
+              0.110768,
+              0.112654,
+              0.113003,
+              0.113074,
+              0.110629,
+              0.110699,
+              0.112654,
+              0.112585,
+              0.113492,
+              0.112165,
+              0.113562,
+              0.112585,
+              0.113073,
+              0.111746,
+              0.111676,
+              0.111606,
+              0.112514,
+              0.110209,
+              0.10979,
+              0.111188,
+              0.110629,
+              0.111677,
+              0.111258,
+              0.112235,
+              0.11021
+            ],
+            "warm_rows_per_second": 4583234.492420208
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761990321590758,
+            "character_perplexity": 5.824017534322072,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.4341585978161666e-06,
+            "mean_prediction_kl_nats": 7.263649353478686e-06,
+            "prediction_kl_p99_nats": 4.307788164271621e-05,
+            "maximum_prediction_kl_nats": 0.011499851084857954,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.30211687088012695,
+            "maximum_per_target_cross_entropy_increase": 0.10541251301765442
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.386202809556931e-06,
+            "mean_prediction_kl_nats": 3.6478026720210987e-06,
+            "prediction_kl_p99_nats": 3.1849514343602146e-05,
+            "maximum_prediction_kl_nats": 0.01170144035072026,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30378103256225586,
+            "maximum_per_target_cross_entropy_increase": 0.1062164306640625
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842894,
+              "unique_rows": 11023,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 81,
+              "zlib_blocks": 81,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11023
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "cab1f9f7e8f4959b0926979e6921bc461c4e345d8e9cfb1581dcd2010c1c7fac",
+            "table_sha256": "033187898fa39c8d68eb9a9fc3110f8bb7c02a7ab434d4575ced7ddad6a1987b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08710683300159872,
+          "representatives_sha256": "6981e9856c2b8822a5be05de16e0ce8076b5640fe3c60b327f3c856fc8916fd0",
+          "structurally_merged_rows": 737,
+          "backend_artifact_bytes": 844138,
+          "backend_with_key_registry_bytes": 1005863,
+          "backend_with_datrie_key_index_bytes": 939418,
+          "full_model_serving_artifact_bytes": 1300549,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9813272660500127,
+            "mean_cosine": 0.9999425033140585,
+            "p05_cosine": 0.9996876099233718,
+            "relative_l2_mean": 0.006930306178244006,
+            "relative_l2_p95": 0.02523025606963592,
+            "relative_l2_max": 0.19399595707235132,
+            "weighted_relative_l2_mean": 0.00585568583280781,
+            "weighted_relative_frobenius": 0.007698795623847522,
+            "weighted_mean_cosine": 0.9999706467512589,
+            "max_relative_norm_change": 0.010412935979967038
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9810029673989541,
+            "mean_cosine": 0.9999541660152366,
+            "p05_cosine": 0.9996789564990175,
+            "relative_l2_mean": 0.0022332823861725636,
+            "relative_l2_p95": 0.025565944541053185,
+            "relative_l2_max": 0.1955265801156805,
+            "weighted_relative_l2_mean": 0.0009360131086985215,
+            "weighted_relative_frobenius": 0.005565058598246341,
+            "weighted_mean_cosine": 0.9999843880267955,
+            "max_relative_norm_change": 0.009931715881154553
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.67923,
+            "warm_p50_ms": 0.111153,
+            "warm_p95_ms": 0.11682735,
+            "warm_p99_ms": 0.13251994999999997,
+            "samples_ms": [
+              0.117822,
+              0.116775,
+              0.112654,
+              0.112654,
+              0.116355,
+              0.112025,
+              0.110768,
+              0.112235,
+              0.112165,
+              0.112654,
+              0.110628,
+              0.110349,
+              0.11021,
+              0.11014,
+              0.10986,
+              0.111257,
+              0.110698,
+              0.11014,
+              0.110769,
+              0.111188,
+              0.111676,
+              0.116355,
+              0.11028,
+              0.111257,
+              0.110699,
+              0.111118,
+              0.111677,
+              0.112654,
+              0.111188,
+              0.11021,
+              0.11014,
+              0.108882,
+              0.110699,
+              0.109861,
+              0.110698,
+              0.141917,
+              0.115378,
+              0.112095,
+              0.110699,
+              0.11028
+            ],
+            "warm_rows_per_second": 4606263.438683616
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.761990321590758,
+            "character_perplexity": 5.824017534322072,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.4341585978161666e-06,
+            "mean_prediction_kl_nats": 7.263649353478686e-06,
+            "prediction_kl_p99_nats": 4.307788164271621e-05,
+            "maximum_prediction_kl_nats": 0.011499851084857954,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.30211687088012695,
+            "maximum_per_target_cross_entropy_increase": 0.10541251301765442
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.386202809556931e-06,
+            "mean_prediction_kl_nats": 3.6478026720210987e-06,
+            "prediction_kl_p99_nats": 3.1849514343602146e-05,
+            "maximum_prediction_kl_nats": 0.01170144035072026,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.30378103256225586,
+            "maximum_per_target_cross_entropy_increase": 0.1062164306640625
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842756,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 10,
+              "compressed_blocks": 82,
+              "zlib_blocks": 82,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "ae6184a6148d23a1de6ec0fb9daeaad970c95ee9945259fe81029e0c54871e7f",
+            "table_sha256": "a72fd3463fc255f7b9558e25c7372ac1667c0c1e194ec0e99f438e49d8eff6ba",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08703964482992887,
+          "representatives_sha256": "29fc918a0f2f40e380f0476e35c73f352c984792f4332f4b2ed9d42ed215d0d6",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 844000,
+          "backend_with_key_registry_bytes": 1005725,
+          "backend_with_datrie_key_index_bytes": 939280,
+          "full_model_serving_artifact_bytes": 1300411,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536868525209022,
+            "mean_cosine": 0.9999346955272335,
+            "p05_cosine": 0.9996859107993521,
+            "relative_l2_mean": 0.006980950515669446,
+            "relative_l2_p95": 0.02526545387447921,
+            "relative_l2_max": 0.3043503712082752,
+            "weighted_relative_l2_mean": 0.0060684378003306744,
+            "weighted_relative_frobenius": 0.011322443046301875,
+            "weighted_mean_cosine": 0.9999377175024109,
+            "max_relative_norm_change": 0.010412935979967038
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9536637403364369,
+            "mean_cosine": 0.9999463655955405,
+            "p05_cosine": 0.9996754540293509,
+            "relative_l2_mean": 0.002284693356695273,
+            "relative_l2_p95": 0.025726232346550162,
+            "relative_l2_max": 0.3043045745324806,
+            "weighted_relative_l2_mean": 0.0011525003754382704,
+            "weighted_relative_frobenius": 0.009999323492696645,
+            "weighted_mean_cosine": 0.9999514403371849,
+            "max_relative_norm_change": 0.009931715881154553
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.776101,
+            "warm_p50_ms": 0.110698,
+            "warm_p95_ms": 0.116844,
+            "warm_p99_ms": 0.12408714,
+            "samples_ms": [
+              0.115029,
+              0.116844,
+              0.113562,
+              0.111188,
+              0.110279,
+              0.11028,
+              0.110139,
+              0.128718,
+              0.109372,
+              0.111187,
+              0.116844,
+              0.110768,
+              0.110698,
+              0.11028,
+              0.111257,
+              0.109721,
+              0.110699,
+              0.110698,
+              0.10979,
+              0.109651,
+              0.109861,
+              0.110698,
+              0.111187,
+              0.10979,
+              0.109721,
+              0.109721,
+              0.111187,
+              0.111257,
+              0.113981,
+              0.111118,
+              0.111607,
+              0.109721,
+              0.10979,
+              0.11021,
+              0.111187,
+              0.110768,
+              0.11021,
+              0.112584,
+              0.11021,
+              0.109302
+            ],
+            "warm_rows_per_second": 4625196.480514553
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7621143751519313,
+            "character_perplexity": 5.82474006925313,
+            "next_character_accuracy": 0.5003833767827021,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001264957167171801,
+            "mean_prediction_kl_nats": 9.39694650236695e-05,
+            "prediction_kl_p99_nats": 5.843497417067707e-05,
+            "maximum_prediction_kl_nats": 0.05044044031322442,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6701536178588867,
+            "maximum_per_target_cross_entropy_increase": 0.3766803741455078
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00011967450916720352,
+            "mean_prediction_kl_nats": 9.010682943788051e-05,
+            "prediction_kl_p99_nats": 4.83673399799821e-05,
+            "maximum_prediction_kl_nats": 0.050230559880163644,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.668968677520752,
+            "maximum_per_target_cross_entropy_increase": 0.37651634216308594
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842391,
+              "unique_rows": 11015,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 81,
+              "zlib_blocks": 81,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11015
+            },
+            "source_float32_sha256": "04a26ae7fd213c12d1608cab148bca035b427fba2b336ac8e1f3f738a79bbe5b",
+            "decoded_float32_sha256": "db1bc93a2b33fe8bf16905e9c9c6352e5a5ef58010129e3203f46ec0141d9a36",
+            "table_sha256": "8a947de03d30fb5b4640ee6f2f5a7b57819c767f5b2fc00a13e7328245cf9323",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.10442022397182882,
+          "representatives_sha256": "7df31a8d8f1072a211185674b8ae54ed2d4d8ab575dbd298cf13d13e659db635",
+          "structurally_merged_rows": 745,
+          "backend_artifact_bytes": 843635,
+          "backend_with_key_registry_bytes": 1005360,
+          "backend_with_datrie_key_index_bytes": 938915,
+          "full_model_serving_artifact_bytes": 1300046,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9013648960972993,
+            "mean_cosine": 0.9998944903338037,
+            "p05_cosine": 0.9996827477502208,
+            "relative_l2_mean": 0.007179385016144764,
+            "relative_l2_p95": 0.025540107620820828,
+            "relative_l2_max": 0.44293560563358964,
+            "weighted_relative_l2_mean": 0.006433061655660153,
+            "weighted_relative_frobenius": 0.015764260127780892,
+            "weighted_mean_cosine": 0.9998666365352867,
+            "max_relative_norm_change": 0.010412935979967038
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9019021061884321,
+            "mean_cosine": 0.9999062014743357,
+            "p05_cosine": 0.9996731657436946,
+            "relative_l2_mean": 0.002485952204778026,
+            "relative_l2_p95": 0.025836427923357233,
+            "relative_l2_max": 0.44148202456311975,
+            "weighted_relative_l2_mean": 0.0015226214218138445,
+            "weighted_relative_frobenius": 0.014842333695256017,
+            "weighted_mean_cosine": 0.9998802509623124,
+            "max_relative_norm_change": 0.009968830078026136
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.746348,
+            "warm_p50_ms": 0.1116765,
+            "warm_p95_ms": 0.1151198,
+            "warm_p99_ms": 0.13588858999999998,
+            "samples_ms": [
+              0.115029,
+              0.114959,
+              0.114469,
+              0.11454,
+              0.112584,
+              0.112584,
+              0.113143,
+              0.112165,
+              0.113981,
+              0.112654,
+              0.111746,
+              0.111188,
+              0.112514,
+              0.110699,
+              0.110769,
+              0.110699,
+              0.110629,
+              0.112096,
+              0.111188,
+              0.111188,
+              0.116845,
+              0.110629,
+              0.112584,
+              0.112585,
+              0.110769,
+              0.148064,
+              0.112166,
+              0.111677,
+              0.114051,
+              0.110209,
+              0.111676,
+              0.111536,
+              0.110629,
+              0.110349,
+              0.11021,
+              0.11021,
+              0.110279,
+              0.111187,
+              0.110628,
+              0.110699
+            ],
+            "warm_rows_per_second": 4584670.90211459
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7621814550112926,
+            "character_perplexity": 5.825130805102898,
+            "next_character_accuracy": 0.5003067014261616,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001935863115821644,
+            "mean_prediction_kl_nats": 0.00013970315832643,
+            "prediction_kl_p99_nats": 0.00010846144734936316,
+            "maximum_prediction_kl_nats": 0.0683686249485541,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.8703510761260986,
+            "maximum_per_target_cross_entropy_increase": 0.3766803741455078
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00018676464645119763,
+            "mean_prediction_kl_nats": 0.00013571551772811213,
+            "prediction_kl_p99_nats": 0.00010863712816719506,
+            "maximum_prediction_kl_nats": 0.06812395448033506,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.8682162761688232,
+            "maximum_per_target_cross_entropy_increase": 0.37651634216308594
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.7619878874351227,
+          "character_perplexity": 5.824003357774225,
+          "next_character_accuracy": 0.5003067014261616,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6155188252771413,
+          "character_perplexity": 5.030497195633726,
+          "next_character_accuracy": 0.5292494058115464,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.95",
+          "backend_with_key_registry_bytes": 2894980,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6159370315575023,
+            "character_perplexity": 5.0326014211237675,
+            "next_character_accuracy": 0.5292494058115464,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00041829374079927037,
+            "mean_prediction_kl_nats": 0.0001224659868776353,
+            "prediction_kl_p99_nats": 6.492612482710993e-05,
+            "maximum_prediction_kl_nats": 0.049823547914828695,
+            "top1_changed_fraction": 0.0002300084336425669,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6587400436401367,
+            "maximum_per_target_cross_entropy_increase": 0.3685579299926758
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              9.471540831570154e-05,
+              0.0007101388272276771
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.95",
+          "backend_with_key_registry_bytes": 1567336,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6159358449097074,
+            "character_perplexity": 5.032595449201931,
+            "next_character_accuracy": 0.5292494058115464,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.0004171065973414183,
+            "mean_prediction_kl_nats": 0.0001224485145529409,
+            "prediction_kl_p99_nats": 6.468627058898175e-05,
+            "maximum_prediction_kl_nats": 0.049807480276882234,
+            "top1_changed_fraction": 0.0002300084336425669,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6586532592773438,
+            "maximum_per_target_cross_entropy_increase": 0.3685433864593506
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              9.510922932824986e-05,
+              0.0007089831271132332
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-raw",
+          "backend_with_key_registry_bytes": 962252,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.615536524896122,
+            "character_perplexity": 5.0305862343053445,
+            "next_character_accuracy": 0.5290960668557847,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 1.7699775619881114e-05,
+            "mean_prediction_kl_nats": 3.5440430999465437e-06,
+            "prediction_kl_p99_nats": 2.424724186036613e-05,
+            "maximum_prediction_kl_nats": 0.00011723431737023591,
+            "top1_changed_fraction": 0.0010733726903319788,
+            "accuracy_change": -0.00015333895576175038,
+            "maximum_absolute_logit_change": 0.02951216697692871,
+            "maximum_per_target_cross_entropy_increase": 0.0291440486907959
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -3.6594241267184036e-05,
+              7.115336931680388e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6155178001573416,
+            "character_perplexity": 5.030492038774091,
+            "next_character_accuracy": 0.5292494058115464,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.0251192743875722e-06,
+            "mean_prediction_kl_nats": 4.051686320711723e-09,
+            "prediction_kl_p99_nats": 2.4765548518800662e-08,
+            "maximum_prediction_kl_nats": 7.780124816940553e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011723041534423828,
+            "maximum_per_target_cross_entropy_increase": 0.0008974075317382812
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.615536524896122,
+            "character_perplexity": 5.0305862343053445,
+            "next_character_accuracy": 0.5290960668557847,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 1.7699775619881114e-05,
+            "mean_prediction_kl_nats": 3.5440430999465437e-06,
+            "prediction_kl_p99_nats": 2.424724186036613e-05,
+            "maximum_prediction_kl_nats": 0.00011723431737023591,
+            "top1_changed_fraction": 0.0010733726903319788,
+            "accuracy_change": -0.00015333895576175038,
+            "maximum_absolute_logit_change": 0.02951216697692871,
+            "maximum_per_target_cross_entropy_increase": 0.0291440486907959
+          }
+        }
+      },
+      "checkpoint_sha256": "2a6ed05f8dd35bbd2851b5fa21fc34024df681e447fa8e426f5a8888bd13a567",
+      "registry_sha256": "7fa792a7a13db17dc47320b6a65018697d338beda3b6328e9775d68716636b54"
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "rows": 11760,
+      "dim": 64,
+      "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+      "source_float32_bytes": 3010560,
+      "key_registry_bytes": 161725,
+      "unchanged_backbone_artifact_bytes": 294686,
+      "alternative_datrie_key_index_bytes": 95280,
+      "query_rows": 512,
+      "query_ids_sha256": "8ba8e1ab159a822d9159f679166b91955ebc405920cda85ccf24f213c3eff2ad",
+      "frequency_trace_sha256": "73ddaf0153da6d907ac6eef82bf819aaec23a0a5eb289cb0f3f91092c37eb7f0",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 3010560,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "table_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.014116892823949456,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3011364,
+          "backend_with_key_registry_bytes": 3173089,
+          "backend_with_datrie_key_index_bytes": 3106644,
+          "full_model_serving_artifact_bytes": 3467775,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.380356,
+            "warm_p50_ms": 0.048749,
+            "warm_p95_ms": 0.05079829999999999,
+            "warm_p99_ms": 0.06405067999999998,
+            "samples_ms": [
+              0.050704,
+              0.049657,
+              0.049238,
+              0.050635,
+              0.050566,
+              0.048261,
+              0.048261,
+              0.071378,
+              0.04868,
+              0.048749,
+              0.049238,
+              0.049238,
+              0.048679,
+              0.048679,
+              0.048749,
+              0.049727,
+              0.05259,
+              0.047422,
+              0.047353,
+              0.047772,
+              0.047772,
+              0.047772,
+              0.047772,
+              0.047771,
+              0.049658,
+              0.04875,
+              0.04875,
+              0.048331,
+              0.04868,
+              0.048191,
+              0.049168,
+              0.048749,
+              0.048749,
+              0.049168,
+              0.048749,
+              0.049168,
+              0.04875,
+              0.048679,
+              0.04868,
+              0.04826
+            ],
+            "warm_rows_per_second": 10502779.544195777
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519091112373895,
+            "character_perplexity": 5.765599346234589,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908412,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "table_sha256": "7e93ec1a1a2a6f90dacb21b8baea14bcb657151f929b151963e2c31ab687088b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2582893830258399,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909618,
+          "backend_with_key_registry_bytes": 3071343,
+          "backend_with_datrie_key_index_bytes": 3004898,
+          "full_model_serving_artifact_bytes": 3366029,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.772598,
+            "warm_p50_ms": 0.056327,
+            "warm_p95_ms": 0.059204849999999996,
+            "warm_p99_ms": 0.06822830999999999,
+            "samples_ms": [
+              0.060133,
+              0.059156,
+              0.058666,
+              0.057759,
+              0.055803,
+              0.058177,
+              0.057689,
+              0.058178,
+              0.056851,
+              0.05727,
+              0.056781,
+              0.056781,
+              0.055873,
+              0.056292,
+              0.056711,
+              0.056292,
+              0.056223,
+              0.056711,
+              0.056292,
+              0.055385,
+              0.055874,
+              0.073404,
+              0.055315,
+              0.056292,
+              0.05727,
+              0.055804,
+              0.055803,
+              0.057689,
+              0.056292,
+              0.056292,
+              0.056781,
+              0.055803,
+              0.055803,
+              0.056292,
+              0.056781,
+              0.056292,
+              0.056223,
+              0.055734,
+              0.056362,
+              0.056362
+            ],
+            "warm_rows_per_second": 9089779.324302731
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519091112373895,
+            "character_perplexity": 5.765599346234589,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908412,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "table_sha256": "7e93ec1a1a2a6f90dacb21b8baea14bcb657151f929b151963e2c31ab687088b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3099501240067184,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909617,
+          "backend_with_key_registry_bytes": 3071342,
+          "backend_with_datrie_key_index_bytes": 3004897,
+          "full_model_serving_artifact_bytes": 3366028,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.709182,
+            "warm_p50_ms": 0.05727,
+            "warm_p95_ms": 0.059179449999999995,
+            "warm_p99_ms": 0.05964461,
+            "samples_ms": [
+              0.059645,
+              0.059155,
+              0.058667,
+              0.058667,
+              0.059155,
+              0.058178,
+              0.059644,
+              0.058178,
+              0.05727,
+              0.056851,
+              0.057759,
+              0.057689,
+              0.056781,
+              0.057689,
+              0.056711,
+              0.05727,
+              0.056781,
+              0.057689,
+              0.05727,
+              0.057688,
+              0.056292,
+              0.05727,
+              0.057759,
+              0.056781,
+              0.056781,
+              0.056781,
+              0.058737,
+              0.056292,
+              0.057689,
+              0.057758,
+              0.056781,
+              0.055873,
+              0.057269,
+              0.05727,
+              0.056781,
+              0.056292,
+              0.0572,
+              0.056781,
+              0.057759,
+              0.057689
+            ],
+            "warm_rows_per_second": 8940108.25912345
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519091112373895,
+            "character_perplexity": 5.765599346234589,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2908412,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 368,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 368,
+              "zlib_blocks": 368,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "table_sha256": "7e93ec1a1a2a6f90dacb21b8baea14bcb657151f929b151963e2c31ab687088b",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.34943046304397285,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2909617,
+          "backend_with_key_registry_bytes": 3071342,
+          "backend_with_datrie_key_index_bytes": 3004897,
+          "full_model_serving_artifact_bytes": 3366028,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.762191,
+            "warm_p50_ms": 0.058876,
+            "warm_p95_ms": 0.06073724999999999,
+            "warm_p99_ms": 0.08201328999999997,
+            "samples_ms": [
+              0.062927,
+              0.060622,
+              0.059575,
+              0.058667,
+              0.059993,
+              0.058667,
+              0.058597,
+              0.058247,
+              0.058667,
+              0.058597,
+              0.059086,
+              0.059575,
+              0.058178,
+              0.059225,
+              0.059156,
+              0.059645,
+              0.059086,
+              0.058667,
+              0.057689,
+              0.058667,
+              0.057759,
+              0.059085,
+              0.057689,
+              0.059226,
+              0.059155,
+              0.094216,
+              0.060622,
+              0.059085,
+              0.059156,
+              0.058667,
+              0.059155,
+              0.057759,
+              0.058178,
+              0.058666,
+              0.059156,
+              0.058178,
+              0.057759,
+              0.058248,
+              0.059156,
+              0.05727
+            ],
+            "warm_rows_per_second": 8696242.951287452
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519091112373895,
+            "character_perplexity": 5.765599346234589,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2731820,
+              "unique_rows": 11021,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11021
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "f0f3a94725b746f29df1fec1fabd3306d43db9fb0792c7a68bc4530d60b530c3",
+            "table_sha256": "9aa7bbd6f4c34211b5b934797f20c9a017278737c90ae6212e8b47ce378ec213",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2539064190350473,
+          "representatives_sha256": "b2a2c586d832f72a82e6bed54951d102fcd31cb52e09568675a2d5bb129adde2",
+          "structurally_merged_rows": 739,
+          "backend_artifact_bytes": 2733025,
+          "backend_with_key_registry_bytes": 2894750,
+          "backend_with_datrie_key_index_bytes": 2828305,
+          "full_model_serving_artifact_bytes": 3189436,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9936638928519256,
+            "mean_cosine": 0.9999572416826517,
+            "p05_cosine": 0.9996970082566761,
+            "relative_l2_mean": 0.002194145516018723,
+            "relative_l2_p95": 0.02484940231566842,
+            "relative_l2_max": 0.11261831137802518,
+            "weighted_relative_l2_mean": 0.0009363406367065997,
+            "weighted_relative_frobenius": 0.005649047524990139,
+            "weighted_mean_cosine": 0.99998411650889,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9936638928519256,
+            "mean_cosine": 0.9999572416826517,
+            "p05_cosine": 0.9996970082566761,
+            "relative_l2_mean": 0.002194145516018723,
+            "relative_l2_p95": 0.02484940231566842,
+            "relative_l2_max": 0.11261831137802518,
+            "weighted_relative_l2_mean": 0.0009363406367065997,
+            "weighted_relative_frobenius": 0.005649047524990139,
+            "weighted_mean_cosine": 0.99998411650889,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.45461,
+            "warm_p50_ms": 0.059156,
+            "warm_p95_ms": 0.06339834999999999,
+            "warm_p99_ms": 0.08134977999999998,
+            "samples_ms": [
+              0.064393,
+              0.06153,
+              0.059086,
+              0.059156,
+              0.057689,
+              0.059575,
+              0.059156,
+              0.058248,
+              0.056781,
+              0.059225,
+              0.057689,
+              0.058667,
+              0.058247,
+              0.058178,
+              0.062508,
+              0.060623,
+              0.060553,
+              0.060623,
+              0.060552,
+              0.061949,
+              0.060553,
+              0.058666,
+              0.063346,
+              0.058177,
+              0.058667,
+              0.057759,
+              0.062019,
+              0.060133,
+              0.060552,
+              0.058247,
+              0.092191,
+              0.062997,
+              0.060134,
+              0.058597,
+              0.057758,
+              0.058178,
+              0.059644,
+              0.058666,
+              0.058108,
+              0.058177
+            ],
+            "warm_rows_per_second": 8655081.47947799
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519929477123368,
+            "character_perplexity": 5.766082734022218,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.383998932280922e-05,
+            "mean_prediction_kl_nats": 2.770631969897495e-06,
+            "prediction_kl_p99_nats": 4.4623592160388185e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.24453763663768768,
+            "maximum_per_target_cross_entropy_increase": 0.12383627891540527
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 8.383998932280922e-05,
+            "mean_prediction_kl_nats": 2.770631969897495e-06,
+            "prediction_kl_p99_nats": 4.4623592160388185e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.24453763663768768,
+            "maximum_per_target_cross_entropy_increase": 0.12383627891540527
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2731340,
+              "unique_rows": 11019,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11019
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "bd0b4a1a6b410139110dc36c42d89a8fe7133faf72c00a8b8e465bfbb070043b",
+            "table_sha256": "a632f5033a2e071283a882dfd952bc1e215658cee10447df37ed9e9cc6e1db68",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24768152995966375,
+          "representatives_sha256": "42f9123f512fff55a21e537090dfe83b149f298c3a78d81be88beb17535f0836",
+          "structurally_merged_rows": 741,
+          "backend_artifact_bytes": 2732545,
+          "backend_with_key_registry_bytes": 2894270,
+          "backend_with_datrie_key_index_bytes": 2827825,
+          "full_model_serving_artifact_bytes": 3188956,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9836618144825191,
+            "mean_cosine": 0.9999548743456357,
+            "p05_cosine": 0.9996957661170864,
+            "relative_l2_mean": 0.002222446327007907,
+            "relative_l2_p95": 0.02487716326434536,
+            "relative_l2_max": 0.18064942308355184,
+            "weighted_relative_l2_mean": 0.0009556901082547855,
+            "weighted_relative_frobenius": 0.006003689527503709,
+            "weighted_mean_cosine": 0.9999826539700699,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9836618144825191,
+            "mean_cosine": 0.9999548743456357,
+            "p05_cosine": 0.9996957661170864,
+            "relative_l2_mean": 0.002222446327007907,
+            "relative_l2_p95": 0.02487716326434536,
+            "relative_l2_max": 0.18064942308355184,
+            "weighted_relative_l2_mean": 0.0009556901082547855,
+            "weighted_relative_frobenius": 0.006003689527503709,
+            "weighted_mean_cosine": 0.9999826539700699,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.235169,
+            "warm_p50_ms": 0.057759,
+            "warm_p95_ms": 0.06262319999999999,
+            "warm_p99_ms": 0.08036211999999998,
+            "samples_ms": [
+              0.064812,
+              0.060622,
+              0.058597,
+              0.062508,
+              0.060064,
+              0.060064,
+              0.059645,
+              0.059155,
+              0.058667,
+              0.058667,
+              0.057758,
+              0.057689,
+              0.057689,
+              0.057759,
+              0.058177,
+              0.056222,
+              0.057269,
+              0.05727,
+              0.0572,
+              0.05727,
+              0.061879,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.058666,
+              0.058178,
+              0.090304,
+              0.058178,
+              0.057689,
+              0.056851,
+              0.057758,
+              0.057759,
+              0.057689,
+              0.057759,
+              0.057759,
+              0.057689,
+              0.058178,
+              0.0572
+            ],
+            "warm_rows_per_second": 8864419.397842761
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519840589324267,
+            "character_perplexity": 5.766031480809641,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.495050368583347e-05,
+            "mean_prediction_kl_nats": 2.9385354645919115e-06,
+            "prediction_kl_p99_nats": 4.492838028181003e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.27823472023010254,
+            "maximum_per_target_cross_entropy_increase": 0.12383627891540527
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 7.495050368583347e-05,
+            "mean_prediction_kl_nats": 2.9385354645919115e-06,
+            "prediction_kl_p99_nats": 4.492838028181003e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.27823472023010254,
+            "maximum_per_target_cross_entropy_increase": 0.12383627891540527
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2730652,
+              "unique_rows": 11016,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11016
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "78a46ec0ebb7935888f785beb23076c3208dbc1a9afa7da0f03aad268f4f5dc1",
+            "table_sha256": "20aedeb52dbafcf13f45a377bbcc139e1409d2f1788ee829e23e52ebbb15e0b4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2505855329800397,
+          "representatives_sha256": "a274b4e9c81850d6bc824846ad33d3d9de69d4b8e93ea38ace03538c3a26d240",
+          "structurally_merged_rows": 744,
+          "backend_artifact_bytes": 2731857,
+          "backend_with_key_registry_bytes": 2893582,
+          "backend_with_datrie_key_index_bytes": 2827137,
+          "full_model_serving_artifact_bytes": 3188268,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9715875739388654,
+            "mean_cosine": 0.9999462280900236,
+            "p05_cosine": 0.9996883188648951,
+            "relative_l2_mean": 0.0022973633980691386,
+            "relative_l2_p95": 0.02503481431327582,
+            "relative_l2_max": 0.23930394652713793,
+            "weighted_relative_l2_mean": 0.001033890052483249,
+            "weighted_relative_frobenius": 0.008099872832815666,
+            "weighted_mean_cosine": 0.999973591051415,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9715875739388654,
+            "mean_cosine": 0.9999462280900236,
+            "p05_cosine": 0.9996883188648951,
+            "relative_l2_mean": 0.0022973633980691386,
+            "relative_l2_p95": 0.02503481431327582,
+            "relative_l2_max": 0.23930394652713793,
+            "weighted_relative_l2_mean": 0.001033890052483249,
+            "weighted_relative_frobenius": 0.008099872832815666,
+            "weighted_mean_cosine": 0.999973591051415,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.04115,
+            "warm_p50_ms": 0.058178,
+            "warm_p95_ms": 0.06108639999999999,
+            "warm_p99_ms": 0.06288657,
+            "samples_ms": [
+              0.061949,
+              0.060482,
+              0.060133,
+              0.058667,
+              0.058667,
+              0.058666,
+              0.059156,
+              0.058597,
+              0.063486,
+              0.057689,
+              0.057759,
+              0.05727,
+              0.057689,
+              0.058178,
+              0.057689,
+              0.057689,
+              0.061041,
+              0.060063,
+              0.057689,
+              0.058667,
+              0.058178,
+              0.05727,
+              0.057689,
+              0.057689,
+              0.058666,
+              0.059086,
+              0.058667,
+              0.0572,
+              0.057689,
+              0.057689,
+              0.058178,
+              0.058178,
+              0.058667,
+              0.058178,
+              0.057689,
+              0.057688,
+              0.05727,
+              0.055803,
+              0.058178,
+              0.058178
+            ],
+            "warm_rows_per_second": 8800577.537900925
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7520013117528885,
+            "character_perplexity": 5.76613096197372,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.22047660971588e-05,
+            "mean_prediction_kl_nats": 4.803345681097564e-06,
+            "prediction_kl_p99_nats": 5.8310881644520935e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.595242977142334,
+            "maximum_per_target_cross_entropy_increase": 0.29039692878723145
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.22047660971588e-05,
+            "mean_prediction_kl_nats": 4.803345681097564e-06,
+            "prediction_kl_p99_nats": 5.8310881644520935e-05,
+            "maximum_prediction_kl_nats": 0.00425984633843475,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.595242977142334,
+            "maximum_per_target_cross_entropy_increase": 0.29039692878723145
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2729646,
+              "unique_rows": 11012,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 345,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 345,
+              "zlib_blocks": 345,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11012
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "eac53495e3e81d55c8e8b309eaa412d79df265e5aa6dd1c737112b3086a284a3",
+            "table_sha256": "144b6021639f0c3807015461bf170b763a30b62940c441846d36479e2556ce6a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2529222150333226,
+          "representatives_sha256": "16c486f4c3258df64b1f3e8f70b8b977e76c8da0cadff578ce6b2e5bbe67a062",
+          "structurally_merged_rows": 748,
+          "backend_artifact_bytes": 2730851,
+          "backend_with_key_registry_bytes": 2892576,
+          "backend_with_datrie_key_index_bytes": 2826131,
+          "full_model_serving_artifact_bytes": 3187262,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9541012187652339,
+            "mean_cosine": 0.9999330769840775,
+            "p05_cosine": 0.9996863061040018,
+            "relative_l2_mean": 0.0023918135538841395,
+            "relative_l2_p95": 0.0251782915387511,
+            "relative_l2_max": 0.30426032785720214,
+            "weighted_relative_l2_mean": 0.001083013765408763,
+            "weighted_relative_frobenius": 0.009491379452074398,
+            "weighted_mean_cosine": 0.9999667978349295,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9541012187652339,
+            "mean_cosine": 0.9999330769840775,
+            "p05_cosine": 0.9996863061040018,
+            "relative_l2_mean": 0.0023918135538841395,
+            "relative_l2_p95": 0.0251782915387511,
+            "relative_l2_max": 0.30426032785720214,
+            "weighted_relative_l2_mean": 0.001083013765408763,
+            "weighted_relative_frobenius": 0.009491379452074398,
+            "weighted_mean_cosine": 0.9999667978349295,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.328756,
+            "warm_p50_ms": 0.057689,
+            "warm_p95_ms": 0.0596413,
+            "warm_p99_ms": 0.06878280999999999,
+            "samples_ms": [
+              0.060901,
+              0.059225,
+              0.057689,
+              0.057759,
+              0.058178,
+              0.059574,
+              0.059575,
+              0.057689,
+              0.058666,
+              0.058248,
+              0.057759,
+              0.057759,
+              0.057201,
+              0.0572,
+              0.05727,
+              0.056781,
+              0.05727,
+              0.056781,
+              0.05727,
+              0.0572,
+              0.05727,
+              0.0572,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.05727,
+              0.058178,
+              0.057759,
+              0.056292,
+              0.057689,
+              0.056292,
+              0.057758,
+              0.057689,
+              0.05727,
+              0.05727,
+              0.073822,
+              0.059086,
+              0.057759,
+              0.057689
+            ],
+            "warm_rows_per_second": 8875175.510062577
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7521092260422866,
+            "character_perplexity": 5.766753243474986,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00020013482920029312,
+            "mean_prediction_kl_nats": 1.0234737776523216e-05,
+            "prediction_kl_p99_nats": 6.252705906023106e-05,
+            "maximum_prediction_kl_nats": 0.013867672945814268,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6122770309448242,
+            "maximum_per_target_cross_entropy_increase": 0.8541910648345947
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00020013482920029312,
+            "mean_prediction_kl_nats": 1.0234737776523216e-05,
+            "prediction_kl_p99_nats": 6.252705906023106e-05,
+            "maximum_prediction_kl_nats": 0.013867672945814268,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6122770309448242,
+            "maximum_per_target_cross_entropy_increase": 0.8541910648345947
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 3010560,
+              "artifact_bytes": 2728478,
+              "unique_rows": 11007,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 344,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 344,
+              "zlib_blocks": 344,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11007
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "6b18e9dd375b79d23d0886c70bf22971c101731ae4466c89ccaf7b515186aecc",
+            "table_sha256": "8b9acbe4b8e85269938eeab09061cb5e1c45520c2c3535cbbb534bb89f43cb19",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2824202699121088,
+          "representatives_sha256": "11e3c66f75f66346adec07ef5cd45185fff371452fb3e41586a7dc1a87b791c7",
+          "structurally_merged_rows": 753,
+          "backend_artifact_bytes": 2729683,
+          "backend_with_key_registry_bytes": 2891408,
+          "backend_with_datrie_key_index_bytes": 2824963,
+          "full_model_serving_artifact_bytes": 3186094,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.910428604511629,
+            "mean_cosine": 0.9998962694002413,
+            "p05_cosine": 0.9996822292021181,
+            "relative_l2_mean": 0.0025830225207301694,
+            "relative_l2_p95": 0.025385540658181598,
+            "relative_l2_max": 0.4227487665187151,
+            "weighted_relative_l2_mean": 0.001174464139748775,
+            "weighted_relative_frobenius": 0.010534642496976436,
+            "weighted_mean_cosine": 0.9999483978634752,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.910428604511629,
+            "mean_cosine": 0.9998962694002413,
+            "p05_cosine": 0.9996822292021181,
+            "relative_l2_mean": 0.0025830225207301694,
+            "relative_l2_p95": 0.025385540658181598,
+            "relative_l2_max": 0.4227487665187151,
+            "weighted_relative_l2_mean": 0.001174464139748775,
+            "weighted_relative_frobenius": 0.010534642496976436,
+            "weighted_mean_cosine": 0.9999483978634752,
+            "max_relative_norm_change": 0.010050490693820427
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 11.280985,
+            "warm_p50_ms": 0.057759,
+            "warm_p95_ms": 0.0625988,
+            "warm_p99_ms": 0.07156652999999999,
+            "samples_ms": [
+              0.06195,
+              0.062508,
+              0.060133,
+              0.059505,
+              0.057689,
+              0.060063,
+              0.059644,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.057758,
+              0.057689,
+              0.057759,
+              0.058178,
+              0.057689,
+              0.058667,
+              0.059155,
+              0.057759,
+              0.076197,
+              0.064324,
+              0.058108,
+              0.057689,
+              0.057689,
+              0.056711,
+              0.059086,
+              0.057689,
+              0.057689,
+              0.057759,
+              0.057689,
+              0.057759,
+              0.058248,
+              0.057759,
+              0.058178,
+              0.058248,
+              0.058248,
+              0.058667,
+              0.058178,
+              0.057689,
+              0.057759,
+              0.0572
+            ],
+            "warm_rows_per_second": 8864419.397842761
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7521683752870862,
+            "character_perplexity": 5.76709435266236,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.000259297661525257,
+            "mean_prediction_kl_nats": 2.7767721139857577e-05,
+            "prediction_kl_p99_nats": 6.82620767472471e-05,
+            "maximum_prediction_kl_nats": 0.055205727356219876,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6663031578063965,
+            "maximum_per_target_cross_entropy_increase": 0.8541910648345947
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.000259297661525257,
+            "mean_prediction_kl_nats": 2.7767721139857577e-05,
+            "prediction_kl_p99_nats": 6.82620767472471e-05,
+            "maximum_prediction_kl_nats": 0.055205727356219876,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6663031578063965,
+            "maximum_per_target_cross_entropy_increase": 0.8541910648345947
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 1505280,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "8f131fcc83bb844ad4e9d610693f55687d566532851a2724e31525d9369c4017",
+            "table_sha256": "ae77e374b3687298bc905011989dd5cea95a297efdc59cae484cf38c92f8e8d1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.019108804175630212,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1506085,
+          "backend_with_key_registry_bytes": 1667810,
+          "backend_with_datrie_key_index_bytes": 1601365,
+          "full_model_serving_artifact_bytes": 1962496,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999561702593,
+            "mean_cosine": 0.9999999793093656,
+            "p05_cosine": 0.9999999714403758,
+            "relative_l2_mean": 0.0002061393803210051,
+            "relative_l2_p95": 0.00024342303018898745,
+            "relative_l2_max": 0.0002964292448205526,
+            "weighted_relative_l2_mean": 0.00018699371965687282,
+            "weighted_relative_frobenius": 0.00020699072274290548,
+            "weighted_mean_cosine": 0.9999999813742835,
+            "max_relative_norm_change": 0.00017415355567106385
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.425823,
+            "warm_p50_ms": 0.132978,
+            "warm_p95_ms": 0.13661974999999996,
+            "warm_p99_ms": 0.16155541999999998,
+            "samples_ms": [
+              0.134305,
+              0.151416,
+              0.134375,
+              0.133816,
+              0.133397,
+              0.133397,
+              0.132489,
+              0.132978,
+              0.132977,
+              0.133816,
+              0.133885,
+              0.133886,
+              0.132908,
+              0.132,
+              0.132978,
+              0.132908,
+              0.132489,
+              0.133467,
+              0.132978,
+              0.133467,
+              0.132489,
+              0.132908,
+              0.132908,
+              0.131092,
+              0.132489,
+              0.132489,
+              0.132419,
+              0.132489,
+              0.13249,
+              0.132978,
+              0.168038,
+              0.135841,
+              0.132419,
+              0.133397,
+              0.133397,
+              0.132978,
+              0.131511,
+              0.133397,
+              0.133397,
+              0.132001
+            ],
+            "warm_rows_per_second": 3850260.9454195425
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751908738569852,
+            "character_perplexity": 5.765597197583279,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.7266746803859213e-07,
+            "mean_prediction_kl_nats": 3.967559244862379e-09,
+            "prediction_kl_p99_nats": 2.3306544418521744e-08,
+            "maximum_prediction_kl_nats": 7.241702038288769e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010852813720703125,
+            "maximum_per_target_cross_entropy_increase": 0.0007781982421875
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491702,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "8f131fcc83bb844ad4e9d610693f55687d566532851a2724e31525d9369c4017",
+            "table_sha256": "baf2739a65c9173b3a419ad965d58d8462a683778341881f6f71cad4c7463797",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14929922996088862,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492909,
+          "backend_with_key_registry_bytes": 1654634,
+          "backend_with_datrie_key_index_bytes": 1588189,
+          "full_model_serving_artifact_bytes": 1949320,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999561702593,
+            "mean_cosine": 0.9999999793093656,
+            "p05_cosine": 0.9999999714403758,
+            "relative_l2_mean": 0.0002061393803210051,
+            "relative_l2_p95": 0.00024342303018898745,
+            "relative_l2_max": 0.0002964292448205526,
+            "weighted_relative_l2_mean": 0.00018699371965687282,
+            "weighted_relative_frobenius": 0.00020699072274290548,
+            "weighted_mean_cosine": 0.9999999813742835,
+            "max_relative_norm_change": 0.00017415355567106385
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.891363,
+            "warm_p50_ms": 0.141429,
+            "warm_p95_ms": 0.1458044,
+            "warm_p99_ms": 0.15016047,
+            "samples_ms": [
+              0.145759,
+              0.142406,
+              0.143384,
+              0.141498,
+              0.14513,
+              0.143873,
+              0.141987,
+              0.14101,
+              0.140032,
+              0.141917,
+              0.141918,
+              0.141499,
+              0.141918,
+              0.141428,
+              0.141429,
+              0.141918,
+              0.140521,
+              0.141009,
+              0.14101,
+              0.140032,
+              0.140521,
+              0.152394,
+              0.142895,
+              0.146667,
+              0.144781,
+              0.142337,
+              0.142407,
+              0.141429,
+              0.14101,
+              0.14101,
+              0.14052,
+              0.140451,
+              0.141499,
+              0.140521,
+              0.14094,
+              0.14101,
+              0.140521,
+              0.140521,
+              0.140521,
+              0.140521
+            ],
+            "warm_rows_per_second": 3620191.0499261115
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751908738569852,
+            "character_perplexity": 5.765597197583279,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.7266746803859213e-07,
+            "mean_prediction_kl_nats": 3.967559244862379e-09,
+            "prediction_kl_p99_nats": 2.3306544418521744e-08,
+            "maximum_prediction_kl_nats": 7.241702038288769e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010852813720703125,
+            "maximum_per_target_cross_entropy_increase": 0.0007781982421875
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491702,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "8f131fcc83bb844ad4e9d610693f55687d566532851a2724e31525d9369c4017",
+            "table_sha256": "baf2739a65c9173b3a419ad965d58d8462a683778341881f6f71cad4c7463797",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.18716672179289162,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492908,
+          "backend_with_key_registry_bytes": 1654633,
+          "backend_with_datrie_key_index_bytes": 1588188,
+          "full_model_serving_artifact_bytes": 1949319,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999561702593,
+            "mean_cosine": 0.9999999793093656,
+            "p05_cosine": 0.9999999714403758,
+            "relative_l2_mean": 0.0002061393803210051,
+            "relative_l2_p95": 0.00024342303018898745,
+            "relative_l2_max": 0.0002964292448205526,
+            "weighted_relative_l2_mean": 0.00018699371965687282,
+            "weighted_relative_frobenius": 0.00020699072274290548,
+            "weighted_mean_cosine": 0.9999999813742835,
+            "max_relative_norm_change": 0.00017415355567106385
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.849737,
+            "warm_p50_ms": 0.14170850000000002,
+            "warm_p95_ms": 0.14629335,
+            "warm_p99_ms": 0.16134238,
+            "samples_ms": [
+              0.144781,
+              0.142337,
+              0.141918,
+              0.141009,
+              0.141499,
+              0.140521,
+              0.147155,
+              0.146248,
+              0.142825,
+              0.144711,
+              0.142896,
+              0.14052,
+              0.141429,
+              0.140521,
+              0.140521,
+              0.140032,
+              0.141359,
+              0.170413,
+              0.14534,
+              0.141499,
+              0.1452,
+              0.142896,
+              0.143315,
+              0.142896,
+              0.14101,
+              0.143314,
+              0.142895,
+              0.144711,
+              0.144292,
+              0.143873,
+              0.141429,
+              0.142476,
+              0.141429,
+              0.14101,
+              0.140031,
+              0.14101,
+              0.141009,
+              0.140521,
+              0.14101,
+              0.141498
+            ],
+            "warm_rows_per_second": 3613050.734430185
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751908738569852,
+            "character_perplexity": 5.765597197583279,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.7266746803859213e-07,
+            "mean_prediction_kl_nats": 3.967559244862379e-09,
+            "prediction_kl_p99_nats": 2.3306544418521744e-08,
+            "maximum_prediction_kl_nats": 7.241702038288769e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010852813720703125,
+            "maximum_per_target_cross_entropy_increase": 0.0007781982421875
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1491702,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 184,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 184,
+              "zlib_blocks": 184,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "8f131fcc83bb844ad4e9d610693f55687d566532851a2724e31525d9369c4017",
+            "table_sha256": "baf2739a65c9173b3a419ad965d58d8462a683778341881f6f71cad4c7463797",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1468518499750644,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 1492908,
+          "backend_with_key_registry_bytes": 1654633,
+          "backend_with_datrie_key_index_bytes": 1588188,
+          "full_model_serving_artifact_bytes": 1949319,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999561702593,
+            "mean_cosine": 0.9999999793093656,
+            "p05_cosine": 0.9999999714403758,
+            "relative_l2_mean": 0.0002061393803210051,
+            "relative_l2_p95": 0.00024342303018898745,
+            "relative_l2_max": 0.0002964292448205526,
+            "weighted_relative_l2_mean": 0.00018699371965687282,
+            "weighted_relative_frobenius": 0.00020699072274290548,
+            "weighted_mean_cosine": 0.9999999813742835,
+            "max_relative_norm_change": 0.00017415355567106385
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.891363,
+            "warm_p50_ms": 0.1416735,
+            "warm_p95_ms": 0.14574574999999998,
+            "warm_p99_ms": 0.17258308,
+            "samples_ms": [
+              0.145201,
+              0.142965,
+              0.141918,
+              0.141988,
+              0.14094,
+              0.141918,
+              0.142407,
+              0.141988,
+              0.142337,
+              0.141009,
+              0.141428,
+              0.14101,
+              0.141848,
+              0.141009,
+              0.141009,
+              0.140451,
+              0.141428,
+              0.142825,
+              0.183124,
+              0.156096,
+              0.143874,
+              0.142337,
+              0.14101,
+              0.141009,
+              0.141987,
+              0.142337,
+              0.142406,
+              0.141498,
+              0.142476,
+              0.139613,
+              0.141498,
+              0.141499,
+              0.142337,
+              0.14101,
+              0.141009,
+              0.140521,
+              0.141429,
+              0.141917,
+              0.14101,
+              0.14094
+            ],
+            "warm_rows_per_second": 3613943.3274394996
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751908738569852,
+            "character_perplexity": 5.765597197583279,
+            "next_character_accuracy": 0.5006900782088637,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.7266746803859213e-07,
+            "mean_prediction_kl_nats": 3.967559244862379e-09,
+            "prediction_kl_p99_nats": 2.3306544418521744e-08,
+            "maximum_prediction_kl_nats": 7.241702038288769e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010852813720703125,
+            "maximum_per_target_cross_entropy_increase": 0.0007781982421875
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404516,
+              "unique_rows": 11022,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11022
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "785de7f6356459f0902c06da3b6caad2a0961b50ed6388b3ab2e23be05a0dc31",
+            "table_sha256": "845b2b891603f41d960335876f3379e6c21681d01ced708060391d0dd25d2523",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1694920409936458,
+          "representatives_sha256": "9013105313d6ddeb5e0f2c6c13db3aed609b655ac8c660cda775726425c1bfa6",
+          "structurally_merged_rows": 738,
+          "backend_artifact_bytes": 1405721,
+          "backend_with_key_registry_bytes": 1567446,
+          "backend_with_datrie_key_index_bytes": 1501001,
+          "full_model_serving_artifact_bytes": 1862132,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9936624335326107,
+            "mean_cosine": 0.9999574335860908,
+            "p05_cosine": 0.9996982293524213,
+            "relative_l2_mean": 0.002381315830960158,
+            "relative_l2_p95": 0.02482178038069265,
+            "relative_l2_max": 0.11263148326372621,
+            "weighted_relative_l2_mean": 0.0011114270993146658,
+            "weighted_relative_frobenius": 0.005608434419236457,
+            "weighted_mean_cosine": 0.9999842876418499,
+            "max_relative_norm_change": 0.010028110073227618
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9936621571143124,
+            "mean_cosine": 0.9999574540023862,
+            "p05_cosine": 0.9996979216243842,
+            "relative_l2_mean": 0.002188099155414633,
+            "relative_l2_p95": 0.024799198256564084,
+            "relative_l2_max": 0.11263622270436796,
+            "weighted_relative_l2_mean": 0.0009309170684210872,
+            "weighted_relative_frobenius": 0.005604080214656733,
+            "weighted_mean_cosine": 0.999984306340439,
+            "max_relative_norm_change": 0.009973852896569286
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.445636,
+            "warm_p50_ms": 0.1414285,
+            "warm_p95_ms": 0.14569584999999996,
+            "warm_p99_ms": 0.15571358000000002,
+            "samples_ms": [
+              0.1452,
+              0.142895,
+              0.141499,
+              0.141429,
+              0.141917,
+              0.142406,
+              0.156095,
+              0.141987,
+              0.141498,
+              0.142896,
+              0.140521,
+              0.142406,
+              0.140521,
+              0.140521,
+              0.141917,
+              0.140521,
+              0.141429,
+              0.140031,
+              0.140521,
+              0.141009,
+              0.141499,
+              0.14101,
+              0.141498,
+              0.140521,
+              0.14101,
+              0.141498,
+              0.140521,
+              0.14101,
+              0.140521,
+              0.139543,
+              0.141428,
+              0.140521,
+              0.140521,
+              0.155117,
+              0.141987,
+              0.142476,
+              0.14101,
+              0.140521,
+              0.141498,
+              0.140521
+            ],
+            "warm_rows_per_second": 3620203.848587802
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519901895170722,
+            "character_perplexity": 5.766066830062059,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.108156661531794e-05,
+            "mean_prediction_kl_nats": 2.7003989792803626e-06,
+            "prediction_kl_p99_nats": 4.4022399019958154e-05,
+            "maximum_prediction_kl_nats": 0.00427000501318861,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.24455657601356506,
+            "maximum_per_target_cross_entropy_increase": 0.12400329113006592
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 8.145426443871102e-05,
+            "mean_prediction_kl_nats": 2.6931912207071457e-06,
+            "prediction_kl_p99_nats": 4.41447738182781e-05,
+            "maximum_prediction_kl_nats": 0.004265104875593458,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.24464166164398193,
+            "maximum_per_target_cross_entropy_increase": 0.12392067909240723
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404353,
+              "unique_rows": 11020,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11020
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "78571ac5fc12853614a0d899073f39dd8547b1d0f844cd4be7b36d1301b33539",
+            "table_sha256": "75d931f1d53e3d9797b296d3e9d38beb1623dac5280fbf3c463e20b508167d54",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14509666594676673,
+          "representatives_sha256": "207d7ee8c9849014e5ecc344843ce94ee019d669b1107e94eb340448afd0a919",
+          "structurally_merged_rows": 740,
+          "backend_artifact_bytes": 1405558,
+          "backend_with_key_registry_bytes": 1567283,
+          "backend_with_datrie_key_index_bytes": 1500838,
+          "full_model_serving_artifact_bytes": 1861969,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9836722642304618,
+            "mean_cosine": 0.9999550670186391,
+            "p05_cosine": 0.9996975312475809,
+            "relative_l2_mean": 0.002409581727041581,
+            "relative_l2_p95": 0.024849233211097135,
+            "relative_l2_max": 0.18058696496909937,
+            "weighted_relative_l2_mean": 0.001130755829370565,
+            "weighted_relative_frobenius": 0.005965541474413652,
+            "weighted_mean_cosine": 0.9999828249229119,
+            "max_relative_norm_change": 0.010028110073227618
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.983662787110448,
+            "mean_cosine": 0.9999550867509435,
+            "p05_cosine": 0.9996974624952747,
+            "relative_l2_mean": 0.002216398924696341,
+            "relative_l2_p95": 0.024838888229141796,
+            "relative_l2_max": 0.1806373240056417,
+            "weighted_relative_l2_mean": 0.0009502665207172197,
+            "weighted_relative_frobenius": 0.005961406671631451,
+            "weighted_mean_cosine": 0.9999828438059056,
+            "max_relative_norm_change": 0.009973852896569286
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.424823,
+            "warm_p50_ms": 0.141429,
+            "warm_p95_ms": 0.14564695,
+            "warm_p99_ms": 0.16381553999999998,
+            "samples_ms": [
+              0.143873,
+              0.143314,
+              0.142407,
+              0.14052,
+              0.141429,
+              0.141918,
+              0.142476,
+              0.140521,
+              0.14101,
+              0.141009,
+              0.14101,
+              0.14101,
+              0.14045,
+              0.14101,
+              0.175092,
+              0.142407,
+              0.141429,
+              0.141498,
+              0.140591,
+              0.141499,
+              0.140032,
+              0.140521,
+              0.139612,
+              0.140521,
+              0.141428,
+              0.141429,
+              0.141499,
+              0.14101,
+              0.140521,
+              0.140032,
+              0.141987,
+              0.139613,
+              0.146178,
+              0.143454,
+              0.143384,
+              0.141918,
+              0.141429,
+              0.141009,
+              0.144292,
+              0.145619
+            ],
+            "warm_rows_per_second": 3620191.0499261115
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519812967441397,
+            "character_perplexity": 5.766015553967019,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.218811218665827e-05,
+            "mean_prediction_kl_nats": 2.8673964566398535e-06,
+            "prediction_kl_p99_nats": 4.422877980386387e-05,
+            "maximum_prediction_kl_nats": 0.00427000501318861,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.2781916856765747,
+            "maximum_per_target_cross_entropy_increase": 0.12400329113006592
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 7.256080669574896e-05,
+            "mean_prediction_kl_nats": 2.8610946976357848e-06,
+            "prediction_kl_p99_nats": 4.421483256831372e-05,
+            "maximum_prediction_kl_nats": 0.004265104875593458,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.27823901176452637,
+            "maximum_per_target_cross_entropy_increase": 0.12392067909240723
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1404013,
+              "unique_rows": 11017,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11017
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "4e4e27a7f10c80adedc7b35304bb6d89e97dc17fb0c58379a0d24e41afa70e20",
+            "table_sha256": "444efd7255148d02ece8f2f798bbeec15f92a73f324134f9c1b408efb75bf235",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15004485612735152,
+          "representatives_sha256": "4b7ad2db943cbe62fafde32d2beb4eb1654c97fc6c4a11076be545993968b9ab",
+          "structurally_merged_rows": 743,
+          "backend_artifact_bytes": 1405218,
+          "backend_with_key_registry_bytes": 1566943,
+          "backend_with_datrie_key_index_bytes": 1500498,
+          "full_model_serving_artifact_bytes": 1861629,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9715812247051491,
+            "mean_cosine": 0.9999464193252622,
+            "p05_cosine": 0.9996918807512631,
+            "relative_l2_mean": 0.0024844494170948132,
+            "relative_l2_p95": 0.025000227633378485,
+            "relative_l2_max": 0.23931966315367953,
+            "weighted_relative_l2_mean": 0.0012089073703037338,
+            "weighted_relative_frobenius": 0.008071870537997206,
+            "weighted_mean_cosine": 0.9999737605864243,
+            "max_relative_norm_change": 0.010028110073227618
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9715763313795763,
+            "mean_cosine": 0.9999464378996576,
+            "p05_cosine": 0.9996921393279198,
+            "relative_l2_mean": 0.0022913286448834774,
+            "relative_l2_p95": 0.024953767743632015,
+            "relative_l2_max": 0.23934554468610783,
+            "weighted_relative_l2_mean": 0.0010284817488151697,
+            "weighted_relative_frobenius": 0.008069216677422612,
+            "weighted_mean_cosine": 0.9999737775473834,
+            "max_relative_norm_change": 0.009973852896569286
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.447102,
+            "warm_p50_ms": 0.1431045,
+            "warm_p95_ms": 0.15956325,
+            "warm_p99_ms": 0.17014537999999998,
+            "samples_ms": [
+              0.149041,
+              0.149041,
+              0.145689,
+              0.141988,
+              0.142406,
+              0.143314,
+              0.142406,
+              0.14101,
+              0.144292,
+              0.147156,
+              0.150509,
+              0.145689,
+              0.159448,
+              0.154699,
+              0.142476,
+              0.142895,
+              0.155187,
+              0.161753,
+              0.148063,
+              0.147156,
+              0.142407,
+              0.140521,
+              0.175511,
+              0.141498,
+              0.14527,
+              0.143803,
+              0.143873,
+              0.14052,
+              0.142407,
+              0.14094,
+              0.141498,
+              0.14094,
+              0.14094,
+              0.144711,
+              0.140031,
+              0.141499,
+              0.14101,
+              0.141498,
+              0.141429,
+              0.144781
+            ],
+            "warm_rows_per_second": 3577805.0305895344
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519985300844854,
+            "character_perplexity": 5.766114922531722,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.942284508012468e-05,
+            "mean_prediction_kl_nats": 4.732999292025376e-06,
+            "prediction_kl_p99_nats": 5.5180821558474446e-05,
+            "maximum_prediction_kl_nats": 0.00427000501318861,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5952320098876953,
+            "maximum_per_target_cross_entropy_increase": 0.2905094623565674
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 8.979554601204205e-05,
+            "mean_prediction_kl_nats": 4.72634571777004e-06,
+            "prediction_kl_p99_nats": 5.572812791949773e-05,
+            "maximum_prediction_kl_nats": 0.004265104875593458,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.595128059387207,
+            "maximum_per_target_cross_entropy_increase": 0.29048895835876465
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1403486,
+              "unique_rows": 11013,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 173,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 172,
+              "zlib_blocks": 172,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11013
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "32d3efbc900eb2931365249475898406aaba52ee029fc94c02a9afefea84f5dd",
+            "table_sha256": "0992c9d6e5c63fc06ebd1ebbc7f37b595f9d7be3775c4e2512a0d4eed5b092fa",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.14616956911049783,
+          "representatives_sha256": "072a861c31f89876bfc32521508d31c3af9abc29633347f0f2d4dffa8be1d0be",
+          "structurally_merged_rows": 747,
+          "backend_artifact_bytes": 1404691,
+          "backend_with_key_registry_bytes": 1566416,
+          "backend_with_datrie_key_index_bytes": 1499971,
+          "full_model_serving_artifact_bytes": 1861102,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9540935690445206,
+            "mean_cosine": 0.9999332679413712,
+            "p05_cosine": 0.9996868885640952,
+            "relative_l2_mean": 0.0025788275188094374,
+            "relative_l2_p95": 0.025159322591634673,
+            "relative_l2_max": 0.30429112907861555,
+            "weighted_relative_l2_mean": 0.001257991412726988,
+            "weighted_relative_frobenius": 0.009467519517306568,
+            "weighted_mean_cosine": 0.999966966968916,
+            "max_relative_norm_change": 0.010028110073227618
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.954088589280544,
+            "mean_cosine": 0.9999332864986421,
+            "p05_cosine": 0.9996874062379404,
+            "relative_l2_mean": 0.0023857788662846047,
+            "relative_l2_p95": 0.025154377332231567,
+            "relative_l2_max": 0.3043068509506128,
+            "weighted_relative_l2_mean": 0.001077604318228787,
+            "weighted_relative_frobenius": 0.009465423815370745,
+            "weighted_mean_cosine": 0.9999669839465212,
+            "max_relative_norm_change": 0.009973852896569286
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.464632,
+            "warm_p50_ms": 0.140521,
+            "warm_p95_ms": 0.14480895,
+            "warm_p99_ms": 0.15369029,
+            "samples_ms": [
+              0.14534,
+              0.142895,
+              0.14094,
+              0.14101,
+              0.144781,
+              0.144362,
+              0.142406,
+              0.142477,
+              0.140521,
+              0.141498,
+              0.141429,
+              0.139543,
+              0.140521,
+              0.140521,
+              0.140032,
+              0.140101,
+              0.140451,
+              0.159029,
+              0.141918,
+              0.141428,
+              0.140032,
+              0.140102,
+              0.140032,
+              0.14094,
+              0.14052,
+              0.140032,
+              0.14052,
+              0.139613,
+              0.140521,
+              0.143873,
+              0.140032,
+              0.139543,
+              0.140032,
+              0.140521,
+              0.14101,
+              0.141429,
+              0.141918,
+              0.140032,
+              0.139054,
+              0.139054
+            ],
+            "warm_rows_per_second": 3643583.5213242145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.752106522501061,
+            "character_perplexity": 5.76673765284093,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00019743075055729176,
+            "mean_prediction_kl_nats": 1.0169879969428095e-05,
+            "prediction_kl_p99_nats": 6.048439962904012e-05,
+            "maximum_prediction_kl_nats": 0.013871782352292441,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6127772331237793,
+            "maximum_per_target_cross_entropy_increase": 0.85483717918396
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00019780349174025678,
+            "mean_prediction_kl_nats": 1.0161199275241385e-05,
+            "prediction_kl_p99_nats": 6.041215210047706e-05,
+            "maximum_prediction_kl_nats": 0.013866209796825128,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6127262115478516,
+            "maximum_per_target_cross_entropy_increase": 0.8547048568725586
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 1505280,
+              "artifact_bytes": 1402812,
+              "unique_rows": 11008,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 172,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 172,
+              "zlib_blocks": 172,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11008
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "e15d5dcbbde7631cd554c932b957f8fdd83481b33396efe09409dc8f86e6c974",
+            "table_sha256": "71403bc91623cece5472d7c4efdb6f4ac9c14aad9d857e2c570c554c6e431afb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.1447559108491987,
+          "representatives_sha256": "4445613e0eb1b8c00a2687569e9f020c68f3bb469b5c5750222604b97661a4b7",
+          "structurally_merged_rows": 752,
+          "backend_artifact_bytes": 1404017,
+          "backend_with_key_registry_bytes": 1565742,
+          "backend_with_datrie_key_index_bytes": 1499297,
+          "full_model_serving_artifact_bytes": 1860428,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9104368676447112,
+            "mean_cosine": 0.9998964605058549,
+            "p05_cosine": 0.9996822992536398,
+            "relative_l2_mean": 0.002769957707369786,
+            "relative_l2_p95": 0.025353362987667258,
+            "relative_l2_max": 0.42271188496719964,
+            "weighted_relative_l2_mean": 0.001349395227162131,
+            "weighted_relative_frobenius": 0.010513068014911243,
+            "weighted_mean_cosine": 0.9999485675167205,
+            "max_relative_norm_change": 0.010028110073227618
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9104365327066158,
+            "mean_cosine": 0.9998964807650583,
+            "p05_cosine": 0.9996831448565078,
+            "relative_l2_mean": 0.0025769816210947107,
+            "relative_l2_p95": 0.0253563989285597,
+            "relative_l2_max": 0.42269607197838727,
+            "weighted_relative_l2_mean": 0.0011690501394823313,
+            "weighted_relative_frobenius": 0.010511287974359379,
+            "weighted_mean_cosine": 0.9999485838283916,
+            "max_relative_norm_change": 0.009973852896569286
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.5006,
+            "warm_p50_ms": 0.14146350000000002,
+            "warm_p95_ms": 0.14599649999999997,
+            "warm_p99_ms": 0.16652199999999998,
+            "samples_ms": [
+              0.17167,
+              0.14534,
+              0.143314,
+              0.142826,
+              0.143384,
+              0.143803,
+              0.142406,
+              0.141499,
+              0.141918,
+              0.141917,
+              0.141009,
+              0.141918,
+              0.140521,
+              0.141847,
+              0.14101,
+              0.14101,
+              0.140521,
+              0.14094,
+              0.141428,
+              0.139124,
+              0.14094,
+              0.139543,
+              0.14101,
+              0.141498,
+              0.141429,
+              0.14101,
+              0.141568,
+              0.15847,
+              0.142895,
+              0.140101,
+              0.141429,
+              0.141429,
+              0.141009,
+              0.141498,
+              0.140521,
+              0.140939,
+              0.141499,
+              0.141499,
+              0.142337,
+              0.140032
+            ],
+            "warm_rows_per_second": 3619308.160762316
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7521656517845516,
+            "character_perplexity": 5.767078645987661,
+            "next_character_accuracy": 0.5007667535654041,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0002565734565024768,
+            "mean_prediction_kl_nats": 2.7694690963231373e-05,
+            "prediction_kl_p99_nats": 6.599084822732549e-05,
+            "maximum_prediction_kl_nats": 0.05519350090312892,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.6659965515136719,
+            "maximum_per_target_cross_entropy_increase": 0.85483717918396
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00025694621972601253,
+            "mean_prediction_kl_nats": 2.7696791556825498e-05,
+            "prediction_kl_p99_nats": 6.66065197807943e-05,
+            "maximum_prediction_kl_nats": 0.055230586414404835,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.666330099105835,
+            "maximum_per_target_cross_entropy_increase": 0.8547048568725586
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 799680,
+              "unique_rows": 11760,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "c24044479e6740e64c7477e0129737cf3fc9833330c87891041560fc8979c289",
+            "table_sha256": "33f22b0adf51608d72dafdd55c404069b6392555fde3ce9cbe2da3193605ee03",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.015448767226189375,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 800527,
+          "backend_with_key_registry_bytes": 962252,
+          "backend_with_datrie_key_index_bytes": 895807,
+          "full_model_serving_artifact_bytes": 1256938,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999476717268412,
+            "mean_cosine": 0.9999868747051318,
+            "p05_cosine": 0.9999750305769112,
+            "relative_l2_mean": 0.005015239779976406,
+            "relative_l2_p95": 0.007111025857858184,
+            "relative_l2_max": 0.010230223191756224,
+            "weighted_relative_l2_mean": 0.005115351005261811,
+            "weighted_relative_frobenius": 0.005551393829243131,
+            "weighted_mean_cosine": 0.9999853386526664,
+            "max_relative_norm_change": 0.0028514043963567587
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.353886,
+            "warm_p50_ms": 0.098895,
+            "warm_p95_ms": 0.10071545,
+            "warm_p99_ms": 0.11117661999999999,
+            "samples_ms": [
+              0.100781,
+              0.099873,
+              0.098337,
+              0.098895,
+              0.098826,
+              0.100292,
+              0.098406,
+              0.098895,
+              0.097917,
+              0.098406,
+              0.099314,
+              0.099314,
+              0.099454,
+              0.099315,
+              0.117823,
+              0.100712,
+              0.100292,
+              0.098476,
+              0.09701,
+              0.097499,
+              0.098476,
+              0.097009,
+              0.096451,
+              0.098896,
+              0.098966,
+              0.099315,
+              0.09701,
+              0.098407,
+              0.098895,
+              0.098406,
+              0.097498,
+              0.098895,
+              0.098895,
+              0.099315,
+              0.098477,
+              0.099315,
+              0.098476,
+              0.09701,
+              0.098896,
+              0.099315
+            ],
+            "warm_rows_per_second": 5177208.150058143
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751896889463768,
+            "character_perplexity": 5.765528880815196,
+            "next_character_accuracy": 0.5011501303481061,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.2221698935909417e-05,
+            "mean_prediction_kl_nats": 3.718427634436085e-06,
+            "prediction_kl_p99_nats": 2.5791119079547005e-05,
+            "maximum_prediction_kl_nats": 0.00010015670638372724,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00046005213924238397,
+            "maximum_absolute_logit_change": 0.03807401657104492,
+            "maximum_per_target_cross_entropy_increase": 0.018783092498779297
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893276,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 87,
+              "zlib_blocks": 87,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "c24044479e6740e64c7477e0129737cf3fc9833330c87891041560fc8979c289",
+            "table_sha256": "afcbb7c49277c72201ff209b1943a53df7ed001404730910419901465c8bb252",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08559812000021338,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894522,
+          "backend_with_key_registry_bytes": 1056247,
+          "backend_with_datrie_key_index_bytes": 989802,
+          "full_model_serving_artifact_bytes": 1350933,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999476717268412,
+            "mean_cosine": 0.9999868747051318,
+            "p05_cosine": 0.9999750305769112,
+            "relative_l2_mean": 0.005015239779976406,
+            "relative_l2_p95": 0.007111025857858184,
+            "relative_l2_max": 0.010230223191756224,
+            "weighted_relative_l2_mean": 0.005115351005261811,
+            "weighted_relative_frobenius": 0.005551393829243131,
+            "weighted_mean_cosine": 0.9999853386526664,
+            "max_relative_norm_change": 0.0028514043963567587
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.958247,
+            "warm_p50_ms": 0.11028,
+            "warm_p95_ms": 0.13255535,
+            "warm_p99_ms": 0.15865397999999997,
+            "samples_ms": [
+              0.11447,
+              0.174534,
+              0.132489,
+              0.112165,
+              0.111188,
+              0.111607,
+              0.110699,
+              0.110279,
+              0.10979,
+              0.111188,
+              0.110838,
+              0.108813,
+              0.108882,
+              0.11028,
+              0.109232,
+              0.109301,
+              0.109721,
+              0.110769,
+              0.111188,
+              0.107905,
+              0.11021,
+              0.11021,
+              0.109791,
+              0.10972,
+              0.110699,
+              0.110699,
+              0.109791,
+              0.110628,
+              0.109371,
+              0.11021,
+              0.109721,
+              0.109301,
+              0.109721,
+              0.110698,
+              0.11028,
+              0.11028,
+              0.133816,
+              0.112165,
+              0.109721,
+              0.110699
+            ],
+            "warm_rows_per_second": 4642727.602466449
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751896889463768,
+            "character_perplexity": 5.765528880815196,
+            "next_character_accuracy": 0.5011501303481061,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.2221698935909417e-05,
+            "mean_prediction_kl_nats": 3.718427634436085e-06,
+            "prediction_kl_p99_nats": 2.5791119079547005e-05,
+            "maximum_prediction_kl_nats": 0.00010015670638372724,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00046005213924238397,
+            "maximum_absolute_logit_change": 0.03807401657104492,
+            "maximum_per_target_cross_entropy_increase": 0.018783092498779297
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893276,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 87,
+              "zlib_blocks": 87,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "c24044479e6740e64c7477e0129737cf3fc9833330c87891041560fc8979c289",
+            "table_sha256": "afcbb7c49277c72201ff209b1943a53df7ed001404730910419901465c8bb252",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.15985735692083836,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894521,
+          "backend_with_key_registry_bytes": 1056246,
+          "backend_with_datrie_key_index_bytes": 989801,
+          "full_model_serving_artifact_bytes": 1350932,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999476717268412,
+            "mean_cosine": 0.9999868747051318,
+            "p05_cosine": 0.9999750305769112,
+            "relative_l2_mean": 0.005015239779976406,
+            "relative_l2_p95": 0.007111025857858184,
+            "relative_l2_max": 0.010230223191756224,
+            "weighted_relative_l2_mean": 0.005115351005261811,
+            "weighted_relative_frobenius": 0.005551393829243131,
+            "weighted_mean_cosine": 0.9999853386526664,
+            "max_relative_norm_change": 0.0028514043963567587
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.958736,
+            "warm_p50_ms": 0.11024500000000001,
+            "warm_p95_ms": 0.11549685,
+            "warm_p99_ms": 0.13627805999999998,
+            "samples_ms": [
+              0.115448,
+              0.111188,
+              0.111606,
+              0.112165,
+              0.11021,
+              0.110209,
+              0.111606,
+              0.111676,
+              0.110768,
+              0.111187,
+              0.148971,
+              0.111188,
+              0.110768,
+              0.110768,
+              0.111606,
+              0.110698,
+              0.116425,
+              0.11021,
+              0.11028,
+              0.110699,
+              0.109302,
+              0.109301,
+              0.109302,
+              0.10979,
+              0.108813,
+              0.11014,
+              0.111188,
+              0.108813,
+              0.109232,
+              0.109302,
+              0.108254,
+              0.109302,
+              0.109651,
+              0.108883,
+              0.109302,
+              0.111188,
+              0.109302,
+              0.110698,
+              0.109301,
+              0.11021
+            ],
+            "warm_rows_per_second": 4644201.551090752
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751896889463768,
+            "character_perplexity": 5.765528880815196,
+            "next_character_accuracy": 0.5011501303481061,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.2221698935909417e-05,
+            "mean_prediction_kl_nats": 3.718427634436085e-06,
+            "prediction_kl_p99_nats": 2.5791119079547005e-05,
+            "maximum_prediction_kl_nats": 0.00010015670638372724,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00046005213924238397,
+            "maximum_absolute_logit_change": 0.03807401657104492,
+            "maximum_per_target_cross_entropy_increase": 0.018783092498779297
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 893276,
+              "unique_rows": 11760,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 98,
+              "max_block_bytes": 8192,
+              "raw_blocks": 11,
+              "compressed_blocks": 87,
+              "zlib_blocks": 87,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 11760
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "c24044479e6740e64c7477e0129737cf3fc9833330c87891041560fc8979c289",
+            "table_sha256": "afcbb7c49277c72201ff209b1943a53df7ed001404730910419901465c8bb252",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08475534385070205,
+          "representatives_sha256": "1f725dc17215df73ba41553c18f5027884a4b6b9c5f2e739cad9878427946916",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 894521,
+          "backend_with_key_registry_bytes": 1056246,
+          "backend_with_datrie_key_index_bytes": 989801,
+          "full_model_serving_artifact_bytes": 1350932,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999476717268412,
+            "mean_cosine": 0.9999868747051318,
+            "p05_cosine": 0.9999750305769112,
+            "relative_l2_mean": 0.005015239779976406,
+            "relative_l2_p95": 0.007111025857858184,
+            "relative_l2_max": 0.010230223191756224,
+            "weighted_relative_l2_mean": 0.005115351005261811,
+            "weighted_relative_frobenius": 0.005551393829243131,
+            "weighted_mean_cosine": 0.9999853386526664,
+            "max_relative_norm_change": 0.0028514043963567587
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.976685,
+            "warm_p50_ms": 0.109302,
+            "warm_p95_ms": 0.11582514999999997,
+            "warm_p99_ms": 0.13777435,
+            "samples_ms": [
+              0.115448,
+              0.112095,
+              0.10986,
+              0.110768,
+              0.147226,
+              0.112584,
+              0.111257,
+              0.109721,
+              0.108953,
+              0.109721,
+              0.111117,
+              0.110698,
+              0.110349,
+              0.109302,
+              0.108812,
+              0.110698,
+              0.111118,
+              0.108813,
+              0.109301,
+              0.108394,
+              0.108813,
+              0.108813,
+              0.108813,
+              0.109301,
+              0.109302,
+              0.10986,
+              0.109791,
+              0.108813,
+              0.108812,
+              0.108324,
+              0.109301,
+              0.108324,
+              0.109231,
+              0.107835,
+              0.109302,
+              0.10986,
+              0.109301,
+              0.108813,
+              0.107904,
+              0.122991
+            ],
+            "warm_rows_per_second": 4684269.27229145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.751896889463768,
+            "character_perplexity": 5.765528880815196,
+            "next_character_accuracy": 0.5011501303481061,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.2221698935909417e-05,
+            "mean_prediction_kl_nats": 3.718427634436085e-06,
+            "prediction_kl_p99_nats": 2.5791119079547005e-05,
+            "maximum_prediction_kl_nats": 0.00010015670638372724,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00046005213924238397,
+            "maximum_absolute_logit_change": 0.03807401657104492,
+            "maximum_per_target_cross_entropy_increase": 0.018783092498779297
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 843031,
+              "unique_rows": 11027,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 9,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11027
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "6a76caf808febaa2918212471310dcc13a7e77c361da6fd749ffce6f8828f9c1",
+            "table_sha256": "8299fefb1df30f6d5c27208240446621e707cf8d79f5a9facd6586036618133c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08858914603479207,
+          "representatives_sha256": "ddc211604533e762af72c94b24f16feddf8ad1df483ca51a831f088fa4305c99",
+          "structurally_merged_rows": 733,
+          "backend_artifact_bytes": 844274,
+          "backend_with_key_registry_bytes": 1005999,
+          "backend_with_datrie_key_index_bytes": 939554,
+          "full_model_serving_artifact_bytes": 1300685,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9935234690476181,
+            "mean_cosine": 0.9999448499062227,
+            "p05_cosine": 0.9996907266797578,
+            "relative_l2_mean": 0.0069153334884845775,
+            "relative_l2_p95": 0.02504314859298606,
+            "relative_l2_max": 0.11380766731945188,
+            "weighted_relative_l2_mean": 0.00590098430130065,
+            "weighted_relative_frobenius": 0.007915395391086759,
+            "weighted_mean_cosine": 0.9999694724828936,
+            "max_relative_norm_change": 0.01026371520134981
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9935668397229672,
+            "mean_cosine": 0.9999565796102982,
+            "p05_cosine": 0.9996795632367155,
+            "relative_l2_mean": 0.002210186691108473,
+            "relative_l2_p95": 0.025412558685815156,
+            "relative_l2_max": 0.11350018007565987,
+            "weighted_relative_l2_mean": 0.0009643804186688708,
+            "weighted_relative_frobenius": 0.005829303558166024,
+            "weighted_mean_cosine": 0.9999832783732631,
+            "max_relative_norm_change": 0.01000756191502061
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.904329,
+            "warm_p50_ms": 0.109302,
+            "warm_p95_ms": 0.11434419999999995,
+            "warm_p99_ms": 0.13555426999999998,
+            "samples_ms": [
+              0.113562,
+              0.111257,
+              0.129206,
+              0.110698,
+              0.109721,
+              0.11028,
+              0.111188,
+              0.110629,
+              0.110209,
+              0.109301,
+              0.109232,
+              0.109372,
+              0.109232,
+              0.109861,
+              0.108813,
+              0.108882,
+              0.109302,
+              0.109231,
+              0.109791,
+              0.108813,
+              0.109302,
+              0.109721,
+              0.108813,
+              0.107346,
+              0.108393,
+              0.109302,
+              0.109721,
+              0.108812,
+              0.109302,
+              0.109232,
+              0.109302,
+              0.109232,
+              0.109301,
+              0.108812,
+              0.109302,
+              0.10979,
+              0.109231,
+              0.139613,
+              0.112095,
+              0.109371
+            ],
+            "warm_rows_per_second": 4684269.27229145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519973031897105,
+            "character_perplexity": 5.766107848119792,
+            "next_character_accuracy": 0.5010734549915657,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.819584134555916e-05,
+            "mean_prediction_kl_nats": 6.619619213553747e-06,
+            "prediction_kl_p99_nats": 5.8379613657389136e-05,
+            "maximum_prediction_kl_nats": 0.004350244493226012,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.24921925365924835,
+            "maximum_per_target_cross_entropy_increase": 0.1248863935470581
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00010041876756941332,
+            "mean_prediction_kl_nats": 2.8241785271275015e-06,
+            "prediction_kl_p99_nats": 4.790040985163771e-05,
+            "maximum_prediction_kl_nats": 0.0042292557678851525,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": -7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.2476276308298111,
+            "maximum_per_target_cross_entropy_increase": 0.12327206134796143
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842884,
+              "unique_rows": 11025,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 9,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11025
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "9cb793383faafe69621c29fbedcf09935e833a5ca1b6577e6e07b5d37f681ffc",
+            "table_sha256": "8a1a378e6c7409e01657aaf8952035ab62ab1d557ce09457130e1fe5f8fa3697",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.09192413999699056,
+          "representatives_sha256": "4e96ec63a944015daeb56d59750a418a1355cb8ec5e00be7bb61faf9c69dbac5",
+          "structurally_merged_rows": 735,
+          "backend_artifact_bytes": 844127,
+          "backend_with_key_registry_bytes": 1005852,
+          "backend_with_datrie_key_index_bytes": 939407,
+          "full_model_serving_artifact_bytes": 1300538,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9835967725835124,
+            "mean_cosine": 0.9999424895823382,
+            "p05_cosine": 0.9996906107736135,
+            "relative_l2_mean": 0.006942767588978875,
+            "relative_l2_p95": 0.025062895425252696,
+            "relative_l2_max": 0.18093346744696945,
+            "weighted_relative_l2_mean": 0.00591965234573629,
+            "weighted_relative_frobenius": 0.008169246504612586,
+            "weighted_mean_cosine": 0.9999680270419147,
+            "max_relative_norm_change": 0.01026371520134981
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9835349675861836,
+            "mean_cosine": 0.9999542193719191,
+            "p05_cosine": 0.9996786278128243,
+            "relative_l2_mean": 0.0022384190422566168,
+            "relative_l2_p95": 0.02552355952616013,
+            "relative_l2_max": 0.18129729136883532,
+            "weighted_relative_l2_mean": 0.0009835451344865425,
+            "weighted_relative_frobenius": 0.006167469880755982,
+            "weighted_mean_cosine": 0.9999818425792947,
+            "max_relative_norm_change": 0.01000756191502061
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.951193,
+            "warm_p50_ms": 0.110209,
+            "warm_p95_ms": 0.11635505,
+            "warm_p99_ms": 0.13429182999999997,
+            "samples_ms": [
+              0.116356,
+              0.11447,
+              0.110628,
+              0.112165,
+              0.111187,
+              0.145759,
+              0.113562,
+              0.116355,
+              0.111117,
+              0.110209,
+              0.108255,
+              0.109791,
+              0.109721,
+              0.10979,
+              0.110209,
+              0.109721,
+              0.11028,
+              0.11028,
+              0.11028,
+              0.109791,
+              0.109791,
+              0.10972,
+              0.107835,
+              0.109372,
+              0.113562,
+              0.10986,
+              0.109791,
+              0.112585,
+              0.109302,
+              0.107835,
+              0.108883,
+              0.114959,
+              0.107486,
+              0.115377,
+              0.109232,
+              0.109791,
+              0.111118,
+              0.11028,
+              0.109721,
+              0.110698
+            ],
+            "warm_rows_per_second": 4645718.5892259255
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7519882733825372,
+            "character_perplexity": 5.7660557815128595,
+            "next_character_accuracy": 0.5010734549915657,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.916527855288511e-05,
+            "mean_prediction_kl_nats": 6.8057714999284804e-06,
+            "prediction_kl_p99_nats": 5.931262572062106e-05,
+            "maximum_prediction_kl_nats": 0.004350244493226012,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.28000450134277344,
+            "maximum_per_target_cross_entropy_increase": 0.1248863935470581
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.138809440657068e-05,
+            "mean_prediction_kl_nats": 2.987786397601086e-06,
+            "prediction_kl_p99_nats": 4.9591083932686315e-05,
+            "maximum_prediction_kl_nats": 0.0042292557678851525,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": -7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.27948784828186035,
+            "maximum_per_target_cross_entropy_increase": 0.12327206134796143
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842733,
+              "unique_rows": 11022,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 9,
+              "compressed_blocks": 83,
+              "zlib_blocks": 83,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11022
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "afdcfa804544bb5565cfcf55b990cabf7227427470bf7cc4d63800b7ed0fc753",
+            "table_sha256": "c62a96eadafd51f8dcb0c91248fa0e36f659ea93e1b913ca467a1bb449932ead",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.08975822012871504,
+          "representatives_sha256": "7b6b25be7c4910dfee752a11a070d4486390bdf7141b916423109360b2624506",
+          "structurally_merged_rows": 738,
+          "backend_artifact_bytes": 843976,
+          "backend_with_key_registry_bytes": 1005701,
+          "backend_with_datrie_key_index_bytes": 939256,
+          "full_model_serving_artifact_bytes": 1300387,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9718039636632881,
+            "mean_cosine": 0.9999338860458784,
+            "p05_cosine": 0.9996873580129493,
+            "relative_l2_mean": 0.007016172763185574,
+            "relative_l2_p95": 0.02536507624210821,
+            "relative_l2_max": 0.2384614203989659,
+            "weighted_relative_l2_mean": 0.005996171242510425,
+            "weighted_relative_frobenius": 0.009804938310251428,
+            "weighted_mean_cosine": 0.9999590152236963,
+            "max_relative_norm_change": 0.01026371520134981
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9718008085430542,
+            "mean_cosine": 0.9999455606719624,
+            "p05_cosine": 0.999675080030134,
+            "relative_l2_mean": 0.0023132668469809654,
+            "relative_l2_p95": 0.025674210231420577,
+            "relative_l2_max": 0.23839006453365424,
+            "weighted_relative_l2_mean": 0.0010616306996878465,
+            "weighted_relative_frobenius": 0.00822429441213463,
+            "weighted_mean_cosine": 0.9999727704685598,
+            "max_relative_norm_change": 0.01000756191502061
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.884914,
+            "warm_p50_ms": 0.110768,
+            "warm_p95_ms": 0.114959,
+            "warm_p99_ms": 0.13511034999999996,
+            "samples_ms": [
+              0.113562,
+              0.112165,
+              0.112654,
+              0.114959,
+              0.111676,
+              0.10979,
+              0.110139,
+              0.108882,
+              0.11021,
+              0.113143,
+              0.109721,
+              0.111117,
+              0.114959,
+              0.113562,
+              0.109302,
+              0.110699,
+              0.110629,
+              0.112585,
+              0.147994,
+              0.114959,
+              0.113073,
+              0.111677,
+              0.111746,
+              0.111188,
+              0.110629,
+              0.110629,
+              0.110699,
+              0.11028,
+              0.110699,
+              0.110209,
+              0.110768,
+              0.110768,
+              0.110279,
+              0.111117,
+              0.111677,
+              0.110769,
+              0.109232,
+              0.110699,
+              0.108883,
+              0.110699
+            ],
+            "warm_rows_per_second": 4622273.580817564
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7520058149132827,
+            "character_perplexity": 5.766156927844759,
+            "next_character_accuracy": 0.5010734549915657,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.670835184437542e-05,
+            "mean_prediction_kl_nats": 8.68630843041024e-06,
+            "prediction_kl_p99_nats": 6.698481101176636e-05,
+            "maximum_prediction_kl_nats": 0.004350244493226012,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.6081280708312988,
+            "maximum_per_target_cross_entropy_increase": 0.2908320426940918
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00010893138210684163,
+            "mean_prediction_kl_nats": 4.882093484277991e-06,
+            "prediction_kl_p99_nats": 5.806587418914549e-05,
+            "maximum_prediction_kl_nats": 0.0042292557678851525,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": -7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.6147077083587646,
+            "maximum_per_target_cross_entropy_increase": 0.2929689884185791
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842471,
+              "unique_rows": 11018,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 10,
+              "compressed_blocks": 82,
+              "zlib_blocks": 82,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11018
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "5e41082603ecc688e3cc05634d6e7a6044a3a438e4063411ccbeffef81325252",
+            "table_sha256": "ae1726ef666d6da487989aa18a00505498337f464d207029fd296a40a6de824d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.09176189918071032,
+          "representatives_sha256": "ee184d53d92e5c9169984d9036ccbafab348e0ccd49bbd1e5093ef78e80edfc3",
+          "structurally_merged_rows": 742,
+          "backend_artifact_bytes": 843715,
+          "backend_with_key_registry_bytes": 1005440,
+          "backend_with_datrie_key_index_bytes": 938995,
+          "full_model_serving_artifact_bytes": 1300126,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9540646943538107,
+            "mean_cosine": 0.999920735356232,
+            "p05_cosine": 0.9996827920998723,
+            "relative_l2_mean": 0.007108773236785336,
+            "relative_l2_p95": 0.025441315375941905,
+            "relative_l2_max": 0.3043084476945251,
+            "weighted_relative_l2_mean": 0.006044384000095293,
+            "weighted_relative_frobenius": 0.010989243866715627,
+            "weighted_mean_cosine": 0.9999521938288747,
+            "max_relative_norm_change": 0.01026371520134981
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9540093139944557,
+            "mean_cosine": 0.9999324396874711,
+            "p05_cosine": 0.9996720616019498,
+            "relative_l2_mean": 0.002407608216982624,
+            "relative_l2_p95": 0.025857957969630616,
+            "relative_l2_max": 0.30465804372306293,
+            "weighted_relative_l2_mean": 0.0011107527975362252,
+            "weighted_relative_frobenius": 0.009598739438612783,
+            "weighted_mean_cosine": 0.9999659814284537,
+            "max_relative_norm_change": 0.01000756191502061
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.846711,
+            "warm_p50_ms": 0.112095,
+            "warm_p95_ms": 0.11526974999999999,
+            "warm_p99_ms": 0.12232507000000001,
+            "samples_ms": [
+              0.121174,
+              0.114959,
+              0.114051,
+              0.113073,
+              0.113073,
+              0.113981,
+              0.112095,
+              0.123061,
+              0.113563,
+              0.112165,
+              0.111676,
+              0.113562,
+              0.111188,
+              0.110769,
+              0.112026,
+              0.111607,
+              0.111676,
+              0.111188,
+              0.11028,
+              0.111677,
+              0.110838,
+              0.111676,
+              0.111187,
+              0.111187,
+              0.112095,
+              0.111676,
+              0.112514,
+              0.111117,
+              0.112165,
+              0.112095,
+              0.112584,
+              0.11028,
+              0.112654,
+              0.112584,
+              0.112654,
+              0.111187,
+              0.112165,
+              0.112166,
+              0.110699,
+              0.111188
+            ],
+            "warm_rows_per_second": 4567554.306614925
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7521137930062571,
+            "character_perplexity": 5.766779580089415,
+            "next_character_accuracy": 0.5010734549915657,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0002047027176100909,
+            "mean_prediction_kl_nats": 1.4025727395657766e-05,
+            "prediction_kl_p99_nats": 7.21927144228074e-05,
+            "maximum_prediction_kl_nats": 0.01307531830417566,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.6094646453857422,
+            "maximum_per_target_cross_entropy_increase": 0.8497684001922607
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00021692706776331357,
+            "mean_prediction_kl_nats": 1.0307647465465827e-05,
+            "prediction_kl_p99_nats": 6.713816086402037e-05,
+            "maximum_prediction_kl_nats": 0.013614929907800971,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": -7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.6147077083587646,
+            "maximum_per_target_cross_entropy_increase": 0.8540303707122803
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              11760,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 799680,
+              "artifact_bytes": 842173,
+              "unique_rows": 11013,
+              "row_map_bytes": 94080,
+              "n_rows": 11760,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 92,
+              "max_block_bytes": 8192,
+              "raw_blocks": 10,
+              "compressed_blocks": 82,
+              "zlib_blocks": 82,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 11013
+            },
+            "source_float32_sha256": "bde6cf8c4371179f9154641977abf83991df8fdcbb9201ab5fd060bcc3a7ee50",
+            "decoded_float32_sha256": "09b9bc1131925f72342138a773ee0125b11fa4c5913f814ee0264d1dead7d97e",
+            "table_sha256": "c0deda1dc4ffcee3a546e61bf1674f41729ac473d1467336a7d9037e9762bd0b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.09217452094890177,
+          "representatives_sha256": "bd7cc8a0a8c819f2056e2c826f7d6d16ac9fbf79d051fc4e754ffdc8469054a3",
+          "structurally_merged_rows": 747,
+          "backend_artifact_bytes": 843417,
+          "backend_with_key_registry_bytes": 1005142,
+          "backend_with_datrie_key_index_bytes": 938697,
+          "full_model_serving_artifact_bytes": 1299828,
+          "fidelity_vs_float32": {
+            "rows": 11760,
+            "minimum_cosine": 0.9103325952842204,
+            "mean_cosine": 0.9998838947959986,
+            "p05_cosine": 0.999673700062979,
+            "relative_l2_mean": 0.0072978531059799965,
+            "relative_l2_p95": 0.02584965811696233,
+            "relative_l2_max": 0.42304636127986717,
+            "weighted_relative_l2_mean": 0.006134540240910108,
+            "weighted_relative_frobenius": 0.011902670014672963,
+            "weighted_mean_cosine": 0.9999337846253813,
+            "max_relative_norm_change": 0.01026371520134981
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 11760,
+            "minimum_cosine": 0.9106898404260163,
+            "mean_cosine": 0.9998956056307285,
+            "p05_cosine": 0.9996645558119033,
+            "relative_l2_mean": 0.0025988416498503963,
+            "relative_l2_p95": 0.026044948848024656,
+            "relative_l2_max": 0.42225185957192496,
+            "weighted_relative_l2_mean": 0.0012021179656445894,
+            "weighted_relative_frobenius": 0.010629060788327762,
+            "weighted_mean_cosine": 0.9999476288907098,
+            "max_relative_norm_change": 0.01000756191502061
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.888685,
+            "warm_p50_ms": 0.1116415,
+            "warm_p95_ms": 0.12813784999999994,
+            "warm_p99_ms": 0.15508908,
+            "samples_ms": [
+              0.116845,
+              0.113493,
+              0.154279,
+              0.116426,
+              0.112095,
+              0.113073,
+              0.113004,
+              0.111118,
+              0.113073,
+              0.113003,
+              0.112515,
+              0.109791,
+              0.113562,
+              0.112584,
+              0.111117,
+              0.109791,
+              0.111188,
+              0.109232,
+              0.111188,
+              0.109302,
+              0.111187,
+              0.115867,
+              0.110629,
+              0.117264,
+              0.110769,
+              0.111118,
+              0.111607,
+              0.11021,
+              0.109302,
+              0.11014,
+              0.110769,
+              0.116356,
+              0.155607,
+              0.122083,
+              0.11028,
+              0.11028,
+              0.126762,
+              0.116844,
+              0.111676,
+              0.111257
+            ],
+            "warm_rows_per_second": 4586108.21244788
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.7521727945856924,
+            "character_perplexity": 5.767119839230711,
+            "next_character_accuracy": 0.5010734549915657,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00026371811581273876,
+            "mean_prediction_kl_nats": 3.147875233721867e-05,
+            "prediction_kl_p99_nats": 7.920611986419741e-05,
+            "maximum_prediction_kl_nats": 0.05457426993193903,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.6681852340698242,
+            "maximum_per_target_cross_entropy_increase": 0.8497684001922607
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0002759431872432061,
+            "mean_prediction_kl_nats": 2.771713403775436e-05,
+            "prediction_kl_p99_nats": 7.474973083541969e-05,
+            "maximum_prediction_kl_nats": 0.05451500133355573,
+            "top1_changed_fraction": 0.0005367274957828554,
+            "accuracy_change": -7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.6665081977844238,
+            "maximum_per_target_cross_entropy_increase": 0.8540303707122803
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.7519091112373895,
+          "character_perplexity": 5.765599346234589,
+          "next_character_accuracy": 0.5006900782088637,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6054999464765443,
+          "character_perplexity": 4.980348888311733,
+          "next_character_accuracy": 0.531089473280687,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.9",
+          "backend_with_key_registry_bytes": 2891408,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.605444559273432,
+            "character_perplexity": 4.98007304835536,
+            "next_character_accuracy": 0.5310128038028061,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -5.5385669269262635e-05,
+            "mean_prediction_kl_nats": 2.0394254485204406e-05,
+            "prediction_kl_p99_nats": 6.292058917393448e-05,
+            "maximum_prediction_kl_nats": 0.028937972454724202,
+            "top1_changed_fraction": 0.00038334738940427816,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.6746394634246826,
+            "maximum_per_target_cross_entropy_increase": 0.259132981300354
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00013110323318399718,
+              2.8910119316644106e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.9",
+          "backend_with_key_registry_bytes": 1565742,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6054448741033316,
+            "character_perplexity": 4.980074616231503,
+            "next_character_accuracy": 0.5310128038028061,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -5.5070856757365275e-05,
+            "mean_prediction_kl_nats": 2.0374639076691894e-05,
+            "prediction_kl_p99_nats": 6.243811826060971e-05,
+            "maximum_prediction_kl_nats": 0.028911209971021787,
+            "top1_changed_fraction": 0.00038334738940427816,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.67431640625,
+            "maximum_per_target_cross_entropy_increase": 0.2590094804763794
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00012999504614585823,
+              2.8694272122474748e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-raw",
+          "backend_with_key_registry_bytes": 962252,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6055288730005035,
+            "character_perplexity": 4.980492954576834,
+            "next_character_accuracy": 0.5311661427585678,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 2.8926942335284213e-05,
+            "mean_prediction_kl_nats": 3.594473232078083e-06,
+            "prediction_kl_p99_nats": 2.5250991242415894e-05,
+            "maximum_prediction_kl_nats": 9.39906069725258e-05,
+            "top1_changed_fraction": 0.0011500421682128345,
+            "accuracy_change": 7.666947788076417e-05,
+            "maximum_absolute_logit_change": 0.03656506538391113,
+            "maximum_per_target_cross_entropy_increase": 0.019799232482910156
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -2.5258228333548203e-05,
+              8.626173798269781e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6054995762185011,
+            "character_perplexity": 4.980347044297841,
+            "next_character_accuracy": 0.531089473280687,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -3.702579744376222e-07,
+            "mean_prediction_kl_nats": 3.891884622922279e-09,
+            "prediction_kl_p99_nats": 2.3866377594231902e-08,
+            "maximum_prediction_kl_nats": 1.3001873063553263e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010790824890136719,
+            "maximum_per_target_cross_entropy_increase": 0.0006437301635742188
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.6055288730005035,
+            "character_perplexity": 4.980492954576834,
+            "next_character_accuracy": 0.5311661427585678,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 2.8926942335284213e-05,
+            "mean_prediction_kl_nats": 3.594473232078083e-06,
+            "prediction_kl_p99_nats": 2.5250991242415894e-05,
+            "maximum_prediction_kl_nats": 9.39906069725258e-05,
+            "top1_changed_fraction": 0.0011500421682128345,
+            "accuracy_change": 7.666947788076417e-05,
+            "maximum_absolute_logit_change": 0.03656506538391113,
+            "maximum_per_target_cross_entropy_increase": 0.019799232482910156
+          }
+        }
+      },
+      "checkpoint_sha256": "6f98acbd06c462d38cca0009605daa5986430f75993f62e281fc35ba0be9f1eb",
+      "registry_sha256": "7fa792a7a13db17dc47320b6a65018697d338beda3b6328e9775d68716636b54"
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "rows": 36778,
+      "dim": 64,
+      "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+      "source_float32_bytes": 9415168,
+      "key_registry_bytes": 597521,
+      "unchanged_backbone_artifact_bytes": 699998,
+      "alternative_datrie_key_index_bytes": 294960,
+      "query_rows": 512,
+      "query_ids_sha256": "c0a9c7f836d519eda638b9a28093508b2d62873b170686d55b9ec727411573db",
+      "frequency_trace_sha256": "efa6b79677263433708f5d18746f076a51a377d034e599be829419ac6115bd49",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 9415168,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "table_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.050667806062847376,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9415972,
+          "backend_with_key_registry_bytes": 10013493,
+          "backend_with_datrie_key_index_bytes": 9710932,
+          "full_model_serving_artifact_bytes": 10713491,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.292845,
+            "warm_p50_ms": 0.0478065,
+            "warm_p95_ms": 0.048795399999999996,
+            "warm_p99_ms": 0.07334490999999997,
+            "samples_ms": [
+              0.049658,
+              0.04826,
+              0.047353,
+              0.048261,
+              0.048191,
+              0.048331,
+              0.046864,
+              0.047282,
+              0.047771,
+              0.047212,
+              0.048749,
+              0.04819,
+              0.04826,
+              0.047353,
+              0.048261,
+              0.047841,
+              0.046864,
+              0.047772,
+              0.047282,
+              0.048749,
+              0.047771,
+              0.048679,
+              0.047282,
+              0.047352,
+              0.047771,
+              0.048749,
+              0.047771,
+              0.047353,
+              0.04875,
+              0.047772,
+              0.047772,
+              0.046794,
+              0.048679,
+              0.048191,
+              0.04826,
+              0.047283,
+              0.046374,
+              0.04826,
+              0.04833,
+              0.088489
+            ],
+            "warm_rows_per_second": 10709840.712037066
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594409488138681,
+            "character_perplexity": 6.420146577412286,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082790,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "table_sha256": "950b8a20eb569b5f57c76c89f3e6cd1589ac55e0a5e135e564bfce53733c02e8",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.8069775030016899,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9084000,
+          "backend_with_key_registry_bytes": 9681521,
+          "backend_with_datrie_key_index_bytes": 9378960,
+          "full_model_serving_artifact_bytes": 10381519,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 13.541539,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.06284309999999997,
+            "warm_p99_ms": 0.08353361,
+            "samples_ms": [
+              0.062438,
+              0.059645,
+              0.059156,
+              0.05734,
+              0.055803,
+              0.057759,
+              0.05727,
+              0.055803,
+              0.055803,
+              0.054895,
+              0.0572,
+              0.056711,
+              0.05727,
+              0.055804,
+              0.055384,
+              0.0616,
+              0.056851,
+              0.091841,
+              0.060133,
+              0.07054,
+              0.057759,
+              0.056781,
+              0.0572,
+              0.056292,
+              0.056292,
+              0.056293,
+              0.055873,
+              0.056292,
+              0.056292,
+              0.055873,
+              0.056292,
+              0.056292,
+              0.055803,
+              0.056223,
+              0.056292,
+              0.056362,
+              0.055803,
+              0.054895,
+              0.056292,
+              0.055804
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594409488138681,
+            "character_perplexity": 6.420146577412286,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082790,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "table_sha256": "950b8a20eb569b5f57c76c89f3e6cd1589ac55e0a5e135e564bfce53733c02e8",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.923841570969671,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083999,
+          "backend_with_key_registry_bytes": 9681520,
+          "backend_with_datrie_key_index_bytes": 9378959,
+          "full_model_serving_artifact_bytes": 10381518,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.505699,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.06108735,
+            "warm_p99_ms": 0.06655022999999999,
+            "samples_ms": [
+              0.061042,
+              0.057689,
+              0.057689,
+              0.05727,
+              0.05727,
+              0.057269,
+              0.061949,
+              0.069492,
+              0.056781,
+              0.055315,
+              0.05727,
+              0.055803,
+              0.055803,
+              0.055315,
+              0.055804,
+              0.055733,
+              0.055314,
+              0.055384,
+              0.055803,
+              0.055873,
+              0.055873,
+              0.054895,
+              0.054337,
+              0.055803,
+              0.055873,
+              0.056292,
+              0.056781,
+              0.056292,
+              0.054895,
+              0.056292,
+              0.055385,
+              0.056362,
+              0.055873,
+              0.055803,
+              0.056222,
+              0.056223,
+              0.056292,
+              0.055803,
+              0.055803,
+              0.055873
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594409488138681,
+            "character_perplexity": 6.420146577412286,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082790,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "table_sha256": "950b8a20eb569b5f57c76c89f3e6cd1589ac55e0a5e135e564bfce53733c02e8",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.803027834976092,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083999,
+          "backend_with_key_registry_bytes": 9681520,
+          "backend_with_datrie_key_index_bytes": 9378959,
+          "full_model_serving_artifact_bytes": 10381518,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.480696,
+            "warm_p50_ms": 0.056257,
+            "warm_p95_ms": 0.058739349999999996,
+            "warm_p99_ms": 0.060133,
+            "samples_ms": [
+              0.060133,
+              0.058178,
+              0.055804,
+              0.05727,
+              0.056292,
+              0.056781,
+              0.05727,
+              0.056292,
+              0.060133,
+              0.056362,
+              0.055873,
+              0.055384,
+              0.055384,
+              0.055384,
+              0.056292,
+              0.056292,
+              0.054407,
+              0.055803,
+              0.056292,
+              0.056781,
+              0.056222,
+              0.055803,
+              0.058666,
+              0.056292,
+              0.056292,
+              0.055873,
+              0.057688,
+              0.056292,
+              0.055873,
+              0.055873,
+              0.055384,
+              0.055384,
+              0.055873,
+              0.056711,
+              0.055874,
+              0.056292,
+              0.055314,
+              0.055314,
+              0.055803,
+              0.055315
+            ],
+            "warm_rows_per_second": 9101089.642177863
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594409488138681,
+            "character_perplexity": 6.420146577412286,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6841588,
+              "unique_rows": 27388,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 856,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 856,
+              "zlib_blocks": 856,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27388
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "1c7725661f8317f50934a7e4659676736e50fcebf3e970b34f60492a87da20f2",
+            "table_sha256": "827e27d0a480b2dbb2a7508ffea4f56bad0ab6418aabf25ac7e2504fb1027770",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6645706370472908,
+          "representatives_sha256": "14c4fe0f85f8aa238dae85b33062eeebc5d7436acdac3c94b2ed38d87d09f339",
+          "structurally_merged_rows": 9390,
+          "backend_artifact_bytes": 6842794,
+          "backend_with_key_registry_bytes": 7440315,
+          "backend_with_datrie_key_index_bytes": 7137754,
+          "full_model_serving_artifact_bytes": 8140313,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900855318746704,
+            "mean_cosine": 0.9997854104245398,
+            "p05_cosine": 0.9988759100134763,
+            "relative_l2_mean": 0.009961789294431892,
+            "relative_l2_p95": 0.0476501269778969,
+            "relative_l2_max": 0.1407557896887402,
+            "weighted_relative_l2_mean": 0.0024695631320877207,
+            "weighted_relative_frobenius": 0.011433905190859801,
+            "weighted_mean_cosine": 0.9999525446836851,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900855318746704,
+            "mean_cosine": 0.9997854104245398,
+            "p05_cosine": 0.9988759100134763,
+            "relative_l2_mean": 0.009961789294431892,
+            "relative_l2_p95": 0.0476501269778969,
+            "relative_l2_max": 0.1407557896887402,
+            "weighted_relative_l2_mean": 0.0024695631320877207,
+            "weighted_relative_frobenius": 0.011433905190859801,
+            "weighted_mean_cosine": 0.9999525446836851,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.637082,
+            "warm_p50_ms": 0.056781,
+            "warm_p95_ms": 0.0581815,
+            "warm_p99_ms": 0.060548309999999994,
+            "samples_ms": [
+              0.057689,
+              0.056292,
+              0.057759,
+              0.057689,
+              0.056781,
+              0.058248,
+              0.0572,
+              0.056851,
+              0.055873,
+              0.057689,
+              0.062019,
+              0.058178,
+              0.058178,
+              0.056851,
+              0.056781,
+              0.056851,
+              0.056292,
+              0.056781,
+              0.055873,
+              0.056781,
+              0.058177,
+              0.056781,
+              0.05727,
+              0.056711,
+              0.054406,
+              0.056781,
+              0.057269,
+              0.056292,
+              0.055733,
+              0.054895,
+              0.055803,
+              0.055734,
+              0.055315,
+              0.055873,
+              0.055873,
+              0.054895,
+              0.054895,
+              0.055385,
+              0.055873,
+              0.054476
+            ],
+            "warm_rows_per_second": 9017100.790757472
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594526840220023,
+            "character_perplexity": 6.4202219196107,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.173527699198737e-05,
+            "mean_prediction_kl_nats": 9.793462390566502e-06,
+            "prediction_kl_p99_nats": 0.0001375510538455611,
+            "maximum_prediction_kl_nats": 0.0022487753052020452,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.24757981300354004,
+            "maximum_per_target_cross_entropy_increase": 0.11480426788330078
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.173527699198737e-05,
+            "mean_prediction_kl_nats": 9.793462390566502e-06,
+            "prediction_kl_p99_nats": 0.0001375510538455611,
+            "maximum_prediction_kl_nats": 0.0022487753052020452,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.24757981300354004,
+            "maximum_per_target_cross_entropy_increase": 0.11480426788330078
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6836319,
+              "unique_rows": 27366,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 856,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 856,
+              "zlib_blocks": 856,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27366
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "7331d2cf862a77d49588d7ee907cd2df6d09fd45b772ea2b61fa7edd101d475a",
+            "table_sha256": "20a62a52705ab3bf59373bc4f11f72c5620a328bf0773ca3c8d17e3d9a2ef639",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6232985178939998,
+          "representatives_sha256": "8cf46e582cc093f33c06dffa9aca7893e63093ea1e335d018671c59372c2cb08",
+          "structurally_merged_rows": 9412,
+          "backend_artifact_bytes": 6837525,
+          "backend_with_key_registry_bytes": 7435046,
+          "backend_with_datrie_key_index_bytes": 7132485,
+          "full_model_serving_artifact_bytes": 8135044,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9815629527553452,
+            "mean_cosine": 0.9997748831084752,
+            "p05_cosine": 0.9988684734369433,
+            "relative_l2_mean": 0.010080787616436045,
+            "relative_l2_p95": 0.047799700327254446,
+            "relative_l2_max": 0.1924942487658696,
+            "weighted_relative_l2_mean": 0.002527352749144715,
+            "weighted_relative_frobenius": 0.01240934828812918,
+            "weighted_mean_cosine": 0.9999474112652121,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9815629527553452,
+            "mean_cosine": 0.9997748831084752,
+            "p05_cosine": 0.9988684734369433,
+            "relative_l2_mean": 0.010080787616436045,
+            "relative_l2_p95": 0.047799700327254446,
+            "relative_l2_max": 0.1924942487658696,
+            "weighted_relative_l2_mean": 0.002527352749144715,
+            "weighted_relative_frobenius": 0.01240934828812918,
+            "weighted_mean_cosine": 0.9999474112652121,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.505699,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.060979,
+            "warm_p99_ms": 0.08241319999999998,
+            "samples_ms": [
+              0.060972,
+              0.058178,
+              0.058247,
+              0.056292,
+              0.056781,
+              0.05727,
+              0.056292,
+              0.055873,
+              0.055873,
+              0.055804,
+              0.056292,
+              0.057759,
+              0.056293,
+              0.055803,
+              0.056292,
+              0.058108,
+              0.056292,
+              0.056292,
+              0.055803,
+              0.056292,
+              0.055804,
+              0.055803,
+              0.096032,
+              0.061112,
+              0.057759,
+              0.056711,
+              0.056292,
+              0.056292,
+              0.056362,
+              0.055873,
+              0.0572,
+              0.056292,
+              0.056292,
+              0.056712,
+              0.056781,
+              0.055873,
+              0.056292,
+              0.054896,
+              0.056292,
+              0.056292
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595709047205486,
+            "character_perplexity": 6.4209809675975675,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001299643513152377,
+            "mean_prediction_kl_nats": 4.298913405109953e-05,
+            "prediction_kl_p99_nats": 0.00014861154754934762,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.4670448303222656,
+            "maximum_per_target_cross_entropy_increase": 0.47715890407562256
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0001299643513152377,
+            "mean_prediction_kl_nats": 4.298913405109953e-05,
+            "prediction_kl_p99_nats": 0.00014861154754934762,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.4670448303222656,
+            "maximum_per_target_cross_entropy_increase": 0.47715890407562256
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6833902,
+              "unique_rows": 27356,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27356
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "3e65e968b6f9c8c19e9e2fcf08419f134b7a766ac9a337605696d2e1d5544614",
+            "table_sha256": "e6304456dbdd714753cc346a1bbeca47482e1cc1cad71c033617df5da5224d15",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6291723160538822,
+          "representatives_sha256": "5aea254d1caa9587a4332f8b2ec364b79e79fcf03275a6bcdaff86caa6d063df",
+          "structurally_merged_rows": 9422,
+          "backend_artifact_bytes": 6835108,
+          "backend_with_key_registry_bytes": 7432629,
+          "backend_with_datrie_key_index_bytes": 7130068,
+          "full_model_serving_artifact_bytes": 8132627,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9708261475735659,
+            "mean_cosine": 0.9997643298302546,
+            "p05_cosine": 0.9988642210195045,
+            "relative_l2_mean": 0.010171123678658016,
+            "relative_l2_p95": 0.04787809944360828,
+            "relative_l2_max": 0.24111852823659694,
+            "weighted_relative_l2_mean": 0.002545748913655022,
+            "weighted_relative_frobenius": 0.01270578130435524,
+            "weighted_mean_cosine": 0.9999451854429472,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9708261475735659,
+            "mean_cosine": 0.9997643298302546,
+            "p05_cosine": 0.9988642210195045,
+            "relative_l2_mean": 0.010171123678658016,
+            "relative_l2_p95": 0.04787809944360828,
+            "relative_l2_max": 0.24111852823659694,
+            "weighted_relative_l2_mean": 0.002545748913655022,
+            "weighted_relative_frobenius": 0.01270578130435524,
+            "weighted_mean_cosine": 0.9999451854429472,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.979584,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.059602,
+            "warm_p99_ms": 0.06967683999999999,
+            "samples_ms": [
+              0.059574,
+              0.075778,
+              0.057758,
+              0.056362,
+              0.05727,
+              0.055385,
+              0.056362,
+              0.054755,
+              0.056711,
+              0.056292,
+              0.055804,
+              0.055873,
+              0.055873,
+              0.056711,
+              0.055873,
+              0.060134,
+              0.056851,
+              0.055873,
+              0.055873,
+              0.055384,
+              0.054895,
+              0.054477,
+              0.054896,
+              0.054407,
+              0.058248,
+              0.059156,
+              0.058667,
+              0.056781,
+              0.055734,
+              0.056292,
+              0.054826,
+              0.055244,
+              0.055803,
+              0.055873,
+              0.053918,
+              0.055245,
+              0.056292,
+              0.054826,
+              0.056223,
+              0.056292
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.859591477530857,
+            "character_perplexity": 6.421113066579826,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001505400470049534,
+            "mean_prediction_kl_nats": 5.1810581690064186e-05,
+            "prediction_kl_p99_nats": 0.00015809382505059693,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5190249681472778,
+            "maximum_per_target_cross_entropy_increase": 0.47715890407562256
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0001505400470049534,
+            "mean_prediction_kl_nats": 5.1810581690064186e-05,
+            "prediction_kl_p99_nats": 0.00015809382505059693,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5190249681472778,
+            "maximum_per_target_cross_entropy_increase": 0.47715890407562256
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6831433,
+              "unique_rows": 27346,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27346
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "2817d1a62870bf8b0354d9c58a89ba05eaed78cf769b7a1ccb2aca44086c3cb9",
+            "table_sha256": "3a1a8af8cb07bb4b211d74757b973aeb9a29f85fabbebb8c09cb1444107ea2fc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6161359390243888,
+          "representatives_sha256": "f1adb58e0494cb4956a844dc77f063a86c7e9f0926f9c1f4f5315224bdf29a43",
+          "structurally_merged_rows": 9432,
+          "backend_artifact_bytes": 6832639,
+          "backend_with_key_registry_bytes": 7430160,
+          "backend_with_datrie_key_index_bytes": 7127599,
+          "full_model_serving_artifact_bytes": 8130158,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9504960047174151,
+            "mean_cosine": 0.9997458119066871,
+            "p05_cosine": 0.9988581501771227,
+            "relative_l2_mean": 0.010295763089467157,
+            "relative_l2_p95": 0.048060017629512716,
+            "relative_l2_max": 0.3161439583806123,
+            "weighted_relative_l2_mean": 0.0026566571157003198,
+            "weighted_relative_frobenius": 0.01450411579453141,
+            "weighted_mean_cosine": 0.9999284265720063,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9504960047174151,
+            "mean_cosine": 0.9997458119066871,
+            "p05_cosine": 0.9988581501771227,
+            "relative_l2_mean": 0.010295763089467157,
+            "relative_l2_p95": 0.048060017629512716,
+            "relative_l2_max": 0.3161439583806123,
+            "weighted_relative_l2_mean": 0.0026566571157003198,
+            "weighted_relative_frobenius": 0.01450411579453141,
+            "weighted_mean_cosine": 0.9999284265720063,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.883203,
+            "warm_p50_ms": 0.056781,
+            "warm_p95_ms": 0.060175849999999996,
+            "warm_p99_ms": 0.0610137,
+            "samples_ms": [
+              0.060134,
+              0.061041,
+              0.059994,
+              0.059155,
+              0.060971,
+              0.059645,
+              0.059575,
+              0.058667,
+              0.058247,
+              0.057759,
+              0.058177,
+              0.059086,
+              0.059156,
+              0.058666,
+              0.057759,
+              0.055804,
+              0.055804,
+              0.055733,
+              0.056222,
+              0.056781,
+              0.055384,
+              0.055384,
+              0.055873,
+              0.055873,
+              0.056292,
+              0.055873,
+              0.056781,
+              0.05727,
+              0.059225,
+              0.0572,
+              0.056781,
+              0.056292,
+              0.056222,
+              0.056781,
+              0.056362,
+              0.0572,
+              0.056781,
+              0.055803,
+              0.055803,
+              0.056711
+            ],
+            "warm_rows_per_second": 9017100.790757472
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595670320928694,
+            "character_perplexity": 6.420956101577093,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00012609122783208918,
+            "mean_prediction_kl_nats": 7.923554484544588e-05,
+            "prediction_kl_p99_nats": 0.00022168504694244006,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.001763533200429382,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 1.0080201625823975,
+            "maximum_per_target_cross_entropy_increase": 0.5376654863357544
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00012609122783208918,
+            "mean_prediction_kl_nats": 7.923554484544588e-05,
+            "prediction_kl_p99_nats": 0.00022168504694244006,
+            "maximum_prediction_kl_nats": 0.08667454145389028,
+            "top1_changed_fraction": 0.001763533200429382,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 1.0080201625823975,
+            "maximum_per_target_cross_entropy_increase": 0.5376654863357544
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6824522,
+              "unique_rows": 27317,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 854,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 854,
+              "zlib_blocks": 854,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27317
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "6de322ddb4331af83dcbdc2158eb6864b715c23dcb4c13332cc3d5095353b99b",
+            "table_sha256": "e4dfd9fcbe9440fc94361faefca737f02ff988fd9a01d218963ee1b02ff1e1b8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6603471210692078,
+          "representatives_sha256": "c4a6dd1f891ac302499bb67441a2d36b9b204d1c13dbde9ee157bb130b9eed09",
+          "structurally_merged_rows": 9461,
+          "backend_artifact_bytes": 6825728,
+          "backend_with_key_registry_bytes": 7423249,
+          "backend_with_datrie_key_index_bytes": 7120688,
+          "full_model_serving_artifact_bytes": 8123247,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9003755707401346,
+            "mean_cosine": 0.9996617371942216,
+            "p05_cosine": 0.998843291457119,
+            "relative_l2_mean": 0.010714793843897417,
+            "relative_l2_p95": 0.04834942152870287,
+            "relative_l2_max": 0.4471091219856128,
+            "weighted_relative_l2_mean": 0.00280477823538223,
+            "weighted_relative_frobenius": 0.017512481898731582,
+            "weighted_mean_cosine": 0.9998992199370661,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9003755707401346,
+            "mean_cosine": 0.9996617371942216,
+            "p05_cosine": 0.998843291457119,
+            "relative_l2_mean": 0.010714793843897417,
+            "relative_l2_p95": 0.04834942152870287,
+            "relative_l2_max": 0.4471091219856128,
+            "weighted_relative_l2_mean": 0.00280477823538223,
+            "weighted_relative_frobenius": 0.017512481898731582,
+            "weighted_mean_cosine": 0.9998992199370661,
+            "max_relative_norm_change": 0.010100686111549882
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.336334,
+            "warm_p50_ms": 0.0569905,
+            "warm_p95_ms": 0.05968945,
+            "warm_p99_ms": 0.062043839999999996,
+            "samples_ms": [
+              0.062997,
+              0.057758,
+              0.058737,
+              0.060553,
+              0.058667,
+              0.057759,
+              0.058178,
+              0.056292,
+              0.057759,
+              0.056292,
+              0.057689,
+              0.0572,
+              0.058108,
+              0.05727,
+              0.05727,
+              0.056292,
+              0.057759,
+              0.0572,
+              0.056292,
+              0.056781,
+              0.056292,
+              0.054826,
+              0.055803,
+              0.056222,
+              0.0572,
+              0.056781,
+              0.056711,
+              0.058247,
+              0.056781,
+              0.057689,
+              0.056781,
+              0.054965,
+              0.056292,
+              0.055873,
+              0.05727,
+              0.054825,
+              0.056781,
+              0.055454,
+              0.056781,
+              0.059644
+            ],
+            "warm_rows_per_second": 8983953.465928532
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8597678277036642,
+            "character_perplexity": 6.4222455308309305,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0003269323205221838,
+            "mean_prediction_kl_nats": 0.00018569737129286721,
+            "prediction_kl_p99_nats": 0.0003782698632015452,
+            "maximum_prediction_kl_nats": 0.364815827427902,
+            "top1_changed_fraction": 0.0020702346265910137,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 1.1867132186889648,
+            "maximum_per_target_cross_entropy_increase": 0.9962930083274841
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0003269323205221838,
+            "mean_prediction_kl_nats": 0.00018569737129286721,
+            "prediction_kl_p99_nats": 0.0003782698632015452,
+            "maximum_prediction_kl_nats": 0.364815827427902,
+            "top1_changed_fraction": 0.0020702346265910137,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 1.1867132186889648,
+            "maximum_per_target_cross_entropy_increase": 0.9962930083274841
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 4707584,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "bac7d3501f88195092d63ba68dffadd151fe5e79cbc8b496139da8f07b095ef3",
+            "table_sha256": "633749180e09d591673ccc3cf1af107d9c7a628d9e13375f718a588d76d8dfc8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06076218606904149,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4708389,
+          "backend_with_key_registry_bytes": 5305910,
+          "backend_with_datrie_key_index_bytes": 5003349,
+          "full_model_serving_artifact_bytes": 6005908,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999541484265,
+            "mean_cosine": 0.9999999792144507,
+            "p05_cosine": 0.9999999715937654,
+            "relative_l2_mean": 0.00020648124862410823,
+            "relative_l2_p95": 0.00024227354853237684,
+            "relative_l2_max": 0.0003216770229553896,
+            "weighted_relative_l2_mean": 0.00011706746574026251,
+            "weighted_relative_frobenius": 0.00020782228325645768,
+            "weighted_mean_cosine": 0.9999999883375167,
+            "max_relative_norm_change": 0.00018137923830007608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.352559,
+            "warm_p50_ms": 0.1376575,
+            "warm_p95_ms": 0.14418384999999995,
+            "warm_p99_ms": 0.16755114,
+            "samples_ms": [
+              0.139543,
+              0.137727,
+              0.137728,
+              0.137169,
+              0.138705,
+              0.137168,
+              0.137238,
+              0.136679,
+              0.137587,
+              0.173625,
+              0.140521,
+              0.138635,
+              0.137238,
+              0.137657,
+              0.136749,
+              0.136749,
+              0.138216,
+              0.138635,
+              0.137727,
+              0.138216,
+              0.138635,
+              0.137657,
+              0.137727,
+              0.137727,
+              0.143454,
+              0.136609,
+              0.137168,
+              0.138635,
+              0.137658,
+              0.13668,
+              0.137168,
+              0.136749,
+              0.137238,
+              0.136749,
+              0.137727,
+              0.13675,
+              0.136191,
+              0.137658,
+              0.158051,
+              0.137308
+            ],
+            "warm_rows_per_second": 3719375.9875052213
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594393890174032,
+            "character_perplexity": 6.42013656329816,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.5597952482588541e-06,
+            "mean_prediction_kl_nats": 4.213260959177702e-09,
+            "prediction_kl_p99_nats": 2.854386703663781e-08,
+            "maximum_prediction_kl_nats": 1.3921878729996988e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011134147644042969,
+            "maximum_per_target_cross_entropy_increase": 0.0008730888366699219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4649895,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "bac7d3501f88195092d63ba68dffadd151fe5e79cbc8b496139da8f07b095ef3",
+            "table_sha256": "b6d46b5f2b902dd35a8345e7b1b572239da9cd3d5f289262b8ad5a719e8c5a7d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4254511680919677,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651103,
+          "backend_with_key_registry_bytes": 5248624,
+          "backend_with_datrie_key_index_bytes": 4946063,
+          "full_model_serving_artifact_bytes": 5948622,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999541484265,
+            "mean_cosine": 0.9999999792144507,
+            "p05_cosine": 0.9999999715937654,
+            "relative_l2_mean": 0.00020648124862410823,
+            "relative_l2_p95": 0.00024227354853237684,
+            "relative_l2_max": 0.0003216770229553896,
+            "weighted_relative_l2_mean": 0.00011706746574026251,
+            "weighted_relative_frobenius": 0.00020782228325645768,
+            "weighted_mean_cosine": 0.9999999883375167,
+            "max_relative_norm_change": 0.00018137923830007608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.82307,
+            "warm_p50_ms": 0.146737,
+            "warm_p95_ms": 0.15446759999999998,
+            "warm_p99_ms": 0.16009572,
+            "samples_ms": [
+              0.148553,
+              0.154279,
+              0.147575,
+              0.147086,
+              0.146666,
+              0.147156,
+              0.148553,
+              0.161403,
+              0.152324,
+              0.148064,
+              0.146247,
+              0.146737,
+              0.146178,
+              0.146737,
+              0.146736,
+              0.147156,
+              0.147086,
+              0.146178,
+              0.146178,
+              0.14527,
+              0.149041,
+              0.147155,
+              0.148063,
+              0.148134,
+              0.146667,
+              0.147086,
+              0.146667,
+              0.146597,
+              0.145619,
+              0.146667,
+              0.146178,
+              0.146178,
+              0.146178,
+              0.146597,
+              0.158051,
+              0.148064,
+              0.146666,
+              0.147156,
+              0.146667,
+              0.145689
+            ],
+            "warm_rows_per_second": 3489235.843720398
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594393890174032,
+            "character_perplexity": 6.42013656329816,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.5597952482588541e-06,
+            "mean_prediction_kl_nats": 4.213260959177702e-09,
+            "prediction_kl_p99_nats": 2.854386703663781e-08,
+            "maximum_prediction_kl_nats": 1.3921878729996988e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011134147644042969,
+            "maximum_per_target_cross_entropy_increase": 0.0008730888366699219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4649895,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "bac7d3501f88195092d63ba68dffadd151fe5e79cbc8b496139da8f07b095ef3",
+            "table_sha256": "b6d46b5f2b902dd35a8345e7b1b572239da9cd3d5f289262b8ad5a719e8c5a7d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6825302711222321,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651102,
+          "backend_with_key_registry_bytes": 5248623,
+          "backend_with_datrie_key_index_bytes": 4946062,
+          "full_model_serving_artifact_bytes": 5948621,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999541484265,
+            "mean_cosine": 0.9999999792144507,
+            "p05_cosine": 0.9999999715937654,
+            "relative_l2_mean": 0.00020648124862410823,
+            "relative_l2_p95": 0.00024227354853237684,
+            "relative_l2_max": 0.0003216770229553896,
+            "weighted_relative_l2_mean": 0.00011706746574026251,
+            "weighted_relative_frobenius": 0.00020782228325645768,
+            "weighted_mean_cosine": 0.9999999883375167,
+            "max_relative_norm_change": 0.00018137923830007608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.766778,
+            "warm_p50_ms": 0.1471205,
+            "warm_p95_ms": 0.15076294999999998,
+            "warm_p99_ms": 0.1582056,
+            "samples_ms": [
+              0.150508,
+              0.147156,
+              0.149041,
+              0.147156,
+              0.146667,
+              0.147644,
+              0.148064,
+              0.145271,
+              0.148134,
+              0.147156,
+              0.147155,
+              0.145689,
+              0.14527,
+              0.146667,
+              0.145689,
+              0.146667,
+              0.146178,
+              0.147155,
+              0.147156,
+              0.147086,
+              0.147086,
+              0.1452,
+              0.146527,
+              0.159867,
+              0.147644,
+              0.147645,
+              0.155607,
+              0.14995,
+              0.148064,
+              0.146178,
+              0.145619,
+              0.146597,
+              0.147156,
+              0.145131,
+              0.146597,
+              0.146177,
+              0.14946,
+              0.146737,
+              0.146667,
+              0.147156
+            ],
+            "warm_rows_per_second": 3480140.429104034
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594393890174032,
+            "character_perplexity": 6.42013656329816,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.5597952482588541e-06,
+            "mean_prediction_kl_nats": 4.213260959177702e-09,
+            "prediction_kl_p99_nats": 2.854386703663781e-08,
+            "maximum_prediction_kl_nats": 1.3921878729996988e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011134147644042969,
+            "maximum_per_target_cross_entropy_increase": 0.0008730888366699219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4649895,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "bac7d3501f88195092d63ba68dffadd151fe5e79cbc8b496139da8f07b095ef3",
+            "table_sha256": "b6d46b5f2b902dd35a8345e7b1b572239da9cd3d5f289262b8ad5a719e8c5a7d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4385594120249152,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651102,
+          "backend_with_key_registry_bytes": 5248623,
+          "backend_with_datrie_key_index_bytes": 4946062,
+          "full_model_serving_artifact_bytes": 5948621,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999541484265,
+            "mean_cosine": 0.9999999792144507,
+            "p05_cosine": 0.9999999715937654,
+            "relative_l2_mean": 0.00020648124862410823,
+            "relative_l2_p95": 0.00024227354853237684,
+            "relative_l2_max": 0.0003216770229553896,
+            "weighted_relative_l2_mean": 0.00011706746574026251,
+            "weighted_relative_frobenius": 0.00020782228325645768,
+            "weighted_mean_cosine": 0.9999999883375167,
+            "max_relative_norm_change": 0.00018137923830007608
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.819718,
+            "warm_p50_ms": 0.14670149999999998,
+            "warm_p95_ms": 0.15149619999999997,
+            "warm_p99_ms": 0.16776439999999998,
+            "samples_ms": [
+              0.149949,
+              0.148133,
+              0.148553,
+              0.147575,
+              0.162311,
+              0.148623,
+              0.147575,
+              0.148064,
+              0.147086,
+              0.147155,
+              0.146667,
+              0.146178,
+              0.147645,
+              0.146597,
+              0.1452,
+              0.146667,
+              0.146108,
+              0.147156,
+              0.145689,
+              0.146597,
+              0.145759,
+              0.146667,
+              0.147156,
+              0.146248,
+              0.14534,
+              0.146247,
+              0.147226,
+              0.146736,
+              0.146248,
+              0.145689,
+              0.171251,
+              0.150927,
+              0.146597,
+              0.148063,
+              0.146737,
+              0.147574,
+              0.146667,
+              0.146178,
+              0.146667,
+              0.146667
+            ],
+            "warm_rows_per_second": 3490080.1968623362
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594393890174032,
+            "character_perplexity": 6.42013656329816,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.5597952482588541e-06,
+            "mean_prediction_kl_nats": 4.213260959177702e-09,
+            "prediction_kl_p99_nats": 2.854386703663781e-08,
+            "maximum_prediction_kl_nats": 1.3921878729996988e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011134147644042969,
+            "maximum_per_target_cross_entropy_increase": 0.0008730888366699219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3542370,
+              "unique_rows": 27385,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27385
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "0694fbbb70e23e1f2330f4e4a4bd67e90524d754e1f7814d7d30e1fdccb6ab54",
+            "table_sha256": "9dc33891ac3391dad255582baca52071e1a01ae67e1858a6afc3099dd7c541ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.35916201607324183,
+          "representatives_sha256": "db04327588f9a3aa5cc31d2f0c093936e74a790de83f31538f13a3dfc326e268",
+          "structurally_merged_rows": 9393,
+          "backend_artifact_bytes": 3543576,
+          "backend_with_key_registry_bytes": 4141097,
+          "backend_with_datrie_key_index_bytes": 3838536,
+          "full_model_serving_artifact_bytes": 4841095,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900865899339991,
+            "mean_cosine": 0.9997853877044258,
+            "p05_cosine": 0.9988764796096378,
+            "relative_l2_mean": 0.010117944363448678,
+            "relative_l2_p95": 0.04765732889351271,
+            "relative_l2_max": 0.1407469103080355,
+            "weighted_relative_l2_mean": 0.0025720274252035076,
+            "weighted_relative_frobenius": 0.011436593582149768,
+            "weighted_mean_cosine": 0.999952534177041,
+            "max_relative_norm_change": 0.010205182003499553
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900863895097766,
+            "mean_cosine": 0.9997853991215832,
+            "p05_cosine": 0.9988759034487058,
+            "relative_l2_mean": 0.009964370503308997,
+            "relative_l2_p95": 0.04766672712855255,
+            "relative_l2_max": 0.14074909543199726,
+            "weighted_relative_l2_mean": 0.002469979984095149,
+            "weighted_relative_frobenius": 0.011436043946536932,
+            "weighted_mean_cosine": 0.9999525401329082,
+            "max_relative_norm_change": 0.010100744870441596
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.549571,
+            "warm_p50_ms": 0.146667,
+            "warm_p95_ms": 0.15252289999999996,
+            "warm_p99_ms": 0.17079081,
+            "samples_ms": [
+              0.150997,
+              0.151835,
+              0.149461,
+              0.148134,
+              0.147225,
+              0.146247,
+              0.147156,
+              0.165593,
+              0.148971,
+              0.147645,
+              0.146666,
+              0.146178,
+              0.145689,
+              0.145759,
+              0.146667,
+              0.146248,
+              0.144781,
+              0.147155,
+              0.146667,
+              0.146178,
+              0.1452,
+              0.147155,
+              0.146667,
+              0.146666,
+              0.146667,
+              0.146667,
+              0.147994,
+              0.146248,
+              0.146666,
+              0.147156,
+              0.146667,
+              0.146667,
+              0.146248,
+              0.174114,
+              0.150857,
+              0.146666,
+              0.149041,
+              0.148553,
+              0.148623,
+              0.150927
+            ],
+            "warm_rows_per_second": 3490901.157042825
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594520654432896,
+            "character_perplexity": 6.420217948199318,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.1116691211380284e-05,
+            "mean_prediction_kl_nats": 9.825111773194992e-06,
+            "prediction_kl_p99_nats": 0.00013710213579112544,
+            "maximum_prediction_kl_nats": 0.0022618663058666774,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.24773406982421875,
+            "maximum_per_target_cross_entropy_increase": 0.11475634574890137
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.2676506232393324e-05,
+            "mean_prediction_kl_nats": 9.825667869041563e-06,
+            "prediction_kl_p99_nats": 0.00013732140618753075,
+            "maximum_prediction_kl_nats": 0.0022635538646430566,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.24774503707885742,
+            "maximum_per_target_cross_entropy_increase": 0.11481094360351562
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3539851,
+              "unique_rows": 27363,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27363
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "b4b13434b713229f49673aed4779bc9357dc31162eaf3f85fcb08abf2dfe92f7",
+            "table_sha256": "fbbea0d2c93d4326946256178b4c0eb6be8bcbb59597482b19bc9d1e47d6415f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3622098241467029,
+          "representatives_sha256": "e915520c3051aec64f3383aa90753a5e554c370c05985bb432d2ccd9933afa9f",
+          "structurally_merged_rows": 9415,
+          "backend_artifact_bytes": 3541057,
+          "backend_with_key_registry_bytes": 4138578,
+          "backend_with_datrie_key_index_bytes": 3836017,
+          "full_model_serving_artifact_bytes": 4838576,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9815501946545637,
+            "mean_cosine": 0.9997748591525092,
+            "p05_cosine": 0.9988684684285702,
+            "relative_l2_mean": 0.010236830526590428,
+            "relative_l2_p95": 0.0477853131292943,
+            "relative_l2_max": 0.19247651088946513,
+            "weighted_relative_l2_mean": 0.0026297548699123043,
+            "weighted_relative_frobenius": 0.012411801737386293,
+            "weighted_mean_cosine": 0.9999474011934931,
+            "max_relative_norm_change": 0.010205182003499553
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9815500673213043,
+            "mean_cosine": 0.9997748709067246,
+            "p05_cosine": 0.9988685995725132,
+            "relative_l2_mean": 0.010083375224941304,
+            "relative_l2_p95": 0.04778673273894737,
+            "relative_l2_max": 0.1924785660982116,
+            "weighted_relative_l2_mean": 0.002527764750321193,
+            "weighted_relative_frobenius": 0.012411215838177433,
+            "weighted_mean_cosine": 0.9999474077045158,
+            "max_relative_norm_change": 0.010100744870441596
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.189468,
+            "warm_p50_ms": 0.146702,
+            "warm_p95_ms": 0.1501133,
+            "warm_p99_ms": 0.15735839999999998,
+            "samples_ms": [
+              0.151905,
+              0.148483,
+              0.148622,
+              0.147645,
+              0.147575,
+              0.147225,
+              0.147086,
+              0.147156,
+              0.145759,
+              0.150019,
+              0.148622,
+              0.147575,
+              0.147156,
+              0.146178,
+              0.145689,
+              0.146667,
+              0.148064,
+              0.147644,
+              0.160845,
+              0.148134,
+              0.146248,
+              0.144781,
+              0.14527,
+              0.146178,
+              0.1452,
+              0.146666,
+              0.147086,
+              0.147155,
+              0.146667,
+              0.147156,
+              0.14534,
+              0.145829,
+              0.145759,
+              0.145759,
+              0.146667,
+              0.146248,
+              0.146737,
+              0.146667,
+              0.146667,
+              0.146178
+            ],
+            "warm_rows_per_second": 3490068.301727311
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595702675941401,
+            "character_perplexity": 6.420976876622327,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00012932714230602158,
+            "mean_prediction_kl_nats": 4.3033201686805616e-05,
+            "prediction_kl_p99_nats": 0.0001490815844712177,
+            "maximum_prediction_kl_nats": 0.08671272076410663,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.46732473373413086,
+            "maximum_per_target_cross_entropy_increase": 0.47728192806243896
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00013088714171142216,
+            "mean_prediction_kl_nats": 4.3025091672299196e-05,
+            "prediction_kl_p99_nats": 0.00014879088700169135,
+            "maximum_prediction_kl_nats": 0.08669032413353486,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.46715736389160156,
+            "maximum_per_target_cross_entropy_increase": 0.477230966091156
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3538665,
+              "unique_rows": 27353,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27353
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "73fbf3e81b31d9ebc64e3faa28792d2de5001aff0a38b0a24c7abc32e86b1726",
+            "table_sha256": "ca8169d6a027dca645927287981415c86193c1765f9d390c238e4979702823ab",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.35938104009255767,
+          "representatives_sha256": "2db618c1abe835b770e2a465ebca6f5ff9cefbd274bb379a2f47e97ba8554502",
+          "structurally_merged_rows": 9425,
+          "backend_artifact_bytes": 3539871,
+          "backend_with_key_registry_bytes": 4137392,
+          "backend_with_datrie_key_index_bytes": 3834831,
+          "full_model_serving_artifact_bytes": 4837390,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9708309883932715,
+            "mean_cosine": 0.9997643074180224,
+            "p05_cosine": 0.9988638168652845,
+            "relative_l2_mean": 0.01032710216882639,
+            "relative_l2_p95": 0.04787850560692622,
+            "relative_l2_max": 0.24109966425724155,
+            "weighted_relative_l2_mean": 0.002648136997974743,
+            "weighted_relative_frobenius": 0.012708131555205573,
+            "weighted_mean_cosine": 0.9999451757415506,
+            "max_relative_norm_change": 0.010205182003499553
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9708361119773989,
+            "mean_cosine": 0.9997643183447282,
+            "p05_cosine": 0.9988642426036147,
+            "relative_l2_mean": 0.01017370620197273,
+            "relative_l2_p95": 0.04788957832527853,
+            "relative_l2_max": 0.24108222725641676,
+            "weighted_relative_l2_mean": 0.0025461581452442426,
+            "weighted_relative_frobenius": 0.01270749710197277,
+            "weighted_mean_cosine": 0.9999451826424861,
+            "max_relative_norm_change": 0.010100744870441596
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.905144,
+            "warm_p50_ms": 0.1459685,
+            "warm_p95_ms": 0.1539962,
+            "warm_p99_ms": 0.15718058000000001,
+            "samples_ms": [
+              0.14953,
+              0.156584,
+              0.15386,
+              0.148064,
+              0.147086,
+              0.147575,
+              0.1452,
+              0.146666,
+              0.145689,
+              0.146178,
+              0.152324,
+              0.14946,
+              0.146178,
+              0.144712,
+              0.145689,
+              0.145689,
+              0.145689,
+              0.145759,
+              0.146178,
+              0.146178,
+              0.145759,
+              0.14527,
+              0.145759,
+              0.14534,
+              0.157562,
+              0.146667,
+              0.146177,
+              0.145759,
+              0.146178,
+              0.145689,
+              0.14527,
+              0.144851,
+              0.145829,
+              0.144362,
+              0.146108,
+              0.146178,
+              0.145689,
+              0.145689,
+              0.146178,
+              0.144223
+            ],
+            "warm_rows_per_second": 3507606.0930954283
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595908286842588,
+            "character_perplexity": 6.421108900263808,
+            "next_character_accuracy": 0.49509277718141387,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001498911029398651,
+            "mean_prediction_kl_nats": 5.18532733136159e-05,
+            "prediction_kl_p99_nats": 0.0001583106405913671,
+            "maximum_prediction_kl_nats": 0.08671272076410663,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5191551446914673,
+            "maximum_per_target_cross_entropy_increase": 0.47728192806243896
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015145113442088378,
+            "mean_prediction_kl_nats": 5.1843275615881814e-05,
+            "prediction_kl_p99_nats": 0.00015814003066883615,
+            "maximum_prediction_kl_nats": 0.08669032413353486,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5189602375030518,
+            "maximum_per_target_cross_entropy_increase": 0.477230966091156
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3537485,
+              "unique_rows": 27343,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27343
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "b5f977750c9cc4bfff19896be63ba2779a853aa1ea486ed4d1bbe54b751dbf3b",
+            "table_sha256": "bc7e6d5865c7e395ea55d498a9fca421c3e204562d97c57b21e069148f98f9d9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3649441129527986,
+          "representatives_sha256": "ecc53a425cfa97d6138f491f1e91e1a92379f83822f506c469ec39ef2d34416b",
+          "structurally_merged_rows": 9435,
+          "backend_artifact_bytes": 3538691,
+          "backend_with_key_registry_bytes": 4136212,
+          "backend_with_datrie_key_index_bytes": 3833651,
+          "full_model_serving_artifact_bytes": 4836210,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9504953761164726,
+            "mean_cosine": 0.9997457904811464,
+            "p05_cosine": 0.9988581478455986,
+            "relative_l2_mean": 0.010451682632623872,
+            "relative_l2_p95": 0.048061964801845554,
+            "relative_l2_max": 0.31614041843033924,
+            "weighted_relative_l2_mean": 0.002758998145107052,
+            "weighted_relative_frobenius": 0.014506072163270795,
+            "weighted_mean_cosine": 0.9999284180438613,
+            "max_relative_norm_change": 0.010205182003499553
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.950498967859504,
+            "mean_cosine": 0.9997458022570964,
+            "p05_cosine": 0.9988580421762674,
+            "relative_l2_mean": 0.010298339746944081,
+            "relative_l2_p95": 0.048069961827879114,
+            "relative_l2_max": 0.31613755897546153,
+            "weighted_relative_l2_mean": 0.0026570630640665033,
+            "weighted_relative_frobenius": 0.014505419604932797,
+            "weighted_mean_cosine": 0.9999284259934664,
+            "max_relative_norm_change": 0.010100744870441596
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.909405,
+            "warm_p50_ms": 0.146178,
+            "warm_p95_ms": 0.15272564999999996,
+            "warm_p99_ms": 0.17185356,
+            "samples_ms": [
+              0.150019,
+              0.147085,
+              0.147156,
+              0.146597,
+              0.146178,
+              0.146178,
+              0.146108,
+              0.147155,
+              0.145689,
+              0.168318,
+              0.147574,
+              0.146667,
+              0.146108,
+              0.1452,
+              0.1452,
+              0.145689,
+              0.146178,
+              0.1452,
+              0.1452,
+              0.144712,
+              0.1452,
+              0.146667,
+              0.144851,
+              0.14527,
+              0.144781,
+              0.147156,
+              0.151905,
+              0.149042,
+              0.149041,
+              0.146178,
+              0.146108,
+              0.145689,
+              0.14527,
+              0.1452,
+              0.144781,
+              0.146248,
+              0.174114,
+              0.14946,
+              0.146248,
+              0.14527
+            ],
+            "warm_rows_per_second": 3502579.0474626822
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595663824726743,
+            "character_perplexity": 6.420951930395692,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00012544152593662485,
+            "mean_prediction_kl_nats": 7.928011616664785e-05,
+            "prediction_kl_p99_nats": 0.00022322135069379742,
+            "maximum_prediction_kl_nats": 0.08671272076410663,
+            "top1_changed_fraction": 0.001763533200429382,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 1.0077931880950928,
+            "maximum_per_target_cross_entropy_increase": 0.5376447439193726
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00012700151928124998,
+            "mean_prediction_kl_nats": 7.927086675416382e-05,
+            "prediction_kl_p99_nats": 0.0002215309973247075,
+            "maximum_prediction_kl_nats": 0.08669032413353486,
+            "top1_changed_fraction": 0.001763533200429382,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 1.0080904960632324,
+            "maximum_per_target_cross_entropy_increase": 0.5377774238586426
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3533853,
+              "unique_rows": 27314,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 427,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 427,
+              "zlib_blocks": 427,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27314
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "e3e7f26162f4067923c05e65b37de65e3da42c896ff4778b65872707de2501a6",
+            "table_sha256": "698b7300fd5ff947d50097f6da6afd4e67705b130321a25074e3b4c4125a08cd",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3561051299329847,
+          "representatives_sha256": "58e57637a3c052278b4ce8afb52efc7e656cbfedd09f62f0197042726756758c",
+          "structurally_merged_rows": 9464,
+          "backend_artifact_bytes": 3535059,
+          "backend_with_key_registry_bytes": 4132580,
+          "backend_with_datrie_key_index_bytes": 3830019,
+          "full_model_serving_artifact_bytes": 4832578,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9003836142050164,
+            "mean_cosine": 0.9996617185665663,
+            "p05_cosine": 0.9988430210537634,
+            "relative_l2_mean": 0.010870543231925107,
+            "relative_l2_p95": 0.048348905670925466,
+            "relative_l2_max": 0.44709213369033746,
+            "weighted_relative_l2_mean": 0.00290703968431716,
+            "weighted_relative_frobenius": 0.017513905292490955,
+            "weighted_mean_cosine": 0.9998992124310611,
+            "max_relative_norm_change": 0.010205182003499553
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9003784435428869,
+            "mean_cosine": 0.9996617274141952,
+            "p05_cosine": 0.9988431173619823,
+            "relative_l2_mean": 0.01071737221999517,
+            "relative_l2_p95": 0.048325204758531096,
+            "relative_l2_max": 0.4471100803532612,
+            "weighted_relative_l2_mean": 0.0028051833016739594,
+            "weighted_relative_frobenius": 0.017513626537221234,
+            "weighted_mean_cosine": 0.999899218814722,
+            "max_relative_norm_change": 0.010100744870441596
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.170541,
+            "warm_p50_ms": 0.1471905,
+            "warm_p95_ms": 0.150858,
+            "warm_p99_ms": 0.15554401999999998,
+            "samples_ms": [
+              0.150858,
+              0.150438,
+              0.149041,
+              0.148971,
+              0.14946,
+              0.148063,
+              0.148063,
+              0.146667,
+              0.145758,
+              0.14534,
+              0.147086,
+              0.147575,
+              0.148064,
+              0.147645,
+              0.146597,
+              0.146248,
+              0.145759,
+              0.147156,
+              0.148064,
+              0.14995,
+              0.150858,
+              0.149461,
+              0.146248,
+              0.146248,
+              0.145759,
+              0.147226,
+              0.147575,
+              0.147645,
+              0.146597,
+              0.147156,
+              0.148134,
+              0.146247,
+              0.147156,
+              0.146666,
+              0.14534,
+              0.146247,
+              0.146178,
+              0.146666,
+              0.15854,
+              0.147225
+            ],
+            "warm_rows_per_second": 3478485.3642048906
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8597671584603643,
+            "character_perplexity": 6.422241232787577,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00032626285864902467,
+            "mean_prediction_kl_nats": 0.0001857141024099959,
+            "prediction_kl_p99_nats": 0.0003793403623519644,
+            "maximum_prediction_kl_nats": 0.36471007120037646,
+            "top1_changed_fraction": 0.0020702346265910137,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 1.1866064071655273,
+            "maximum_per_target_cross_entropy_increase": 0.9961137175559998
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00032782316523429894,
+            "mean_prediction_kl_nats": 0.00018572698214540625,
+            "prediction_kl_p99_nats": 0.00037744275644388547,
+            "maximum_prediction_kl_nats": 0.3647813022894302,
+            "top1_changed_fraction": 0.0020702346265910137,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 1.1867146492004395,
+            "maximum_per_target_cross_entropy_increase": 0.9962016940116882
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2500904,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "7a21ec1590d5c8c461d39c7936eefcd8c2a50245cde875af4712b68897f74de2",
+            "table_sha256": "23ed365ab52b2ccf14770d2c13290520d0466caddd4128ccac1db828a6843ff3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06059561506845057,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2501752,
+          "backend_with_key_registry_bytes": 3099273,
+          "backend_with_datrie_key_index_bytes": 2796712,
+          "full_model_serving_artifact_bytes": 3799271,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999235421852686,
+            "mean_cosine": 0.9999882155834846,
+            "p05_cosine": 0.9999769308878261,
+            "relative_l2_mean": 0.004745605336158613,
+            "relative_l2_p95": 0.006838408959516379,
+            "relative_l2_max": 0.012370012480415811,
+            "weighted_relative_l2_mean": 0.003092517752458587,
+            "weighted_relative_frobenius": 0.0053606944760871186,
+            "weighted_mean_cosine": 0.9999913748526958,
+            "max_relative_norm_change": 0.0033418314673439907
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.323505,
+            "warm_p50_ms": 0.09697449999999999,
+            "warm_p95_ms": 0.10129095,
+            "warm_p99_ms": 0.11442762999999999,
+            "samples_ms": [
+              0.099314,
+              0.097498,
+              0.097917,
+              0.097499,
+              0.122572,
+              0.097918,
+              0.098896,
+              0.097498,
+              0.097009,
+              0.096521,
+              0.09694,
+              0.096451,
+              0.09694,
+              0.098895,
+              0.09652,
+              0.09694,
+              0.096521,
+              0.096032,
+              0.096521,
+              0.096939,
+              0.096521,
+              0.097429,
+              0.096521,
+              0.096521,
+              0.096032,
+              0.097917,
+              0.101689,
+              0.096591,
+              0.097009,
+              0.097429,
+              0.096521,
+              0.098477,
+              0.097918,
+              0.097498,
+              0.095543,
+              0.096451,
+              0.10127,
+              0.096521,
+              0.096032,
+              0.097499
+            ],
+            "warm_rows_per_second": 5279738.487953019
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594522439986367,
+            "character_perplexity": 6.420219094563666,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.1295248559438053e-05,
+            "mean_prediction_kl_nats": 3.648268143178588e-06,
+            "prediction_kl_p99_nats": 2.577223089372882e-05,
+            "maximum_prediction_kl_nats": 0.00010449443355391112,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.031384944915771484,
+            "maximum_per_target_cross_entropy_increase": 0.028478145599365234
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802301,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 131,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "7a21ec1590d5c8c461d39c7936eefcd8c2a50245cde875af4712b68897f74de2",
+            "table_sha256": "fe1f98da27c853a902917702ab5d04fb502ae7236f0ac69e95da5273a0e4a755",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24412318295799196,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803554,
+          "backend_with_key_registry_bytes": 3401075,
+          "backend_with_datrie_key_index_bytes": 3098514,
+          "full_model_serving_artifact_bytes": 4101073,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999235421852686,
+            "mean_cosine": 0.9999882155834846,
+            "p05_cosine": 0.9999769308878261,
+            "relative_l2_mean": 0.004745605336158613,
+            "relative_l2_p95": 0.006838408959516379,
+            "relative_l2_max": 0.012370012480415811,
+            "weighted_relative_l2_mean": 0.003092517752458587,
+            "weighted_relative_frobenius": 0.0053606944760871186,
+            "weighted_mean_cosine": 0.9999913748526958,
+            "max_relative_norm_change": 0.0033418314673439907
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.727223,
+            "warm_p50_ms": 0.11447,
+            "warm_p95_ms": 0.11701515,
+            "warm_p99_ms": 0.14012006,
+            "samples_ms": [
+              0.120267,
+              0.116844,
+              0.116356,
+              0.116426,
+              0.115937,
+              0.115866,
+              0.113562,
+              0.114051,
+              0.113981,
+              0.11454,
+              0.114121,
+              0.11447,
+              0.114959,
+              0.11447,
+              0.113911,
+              0.114959,
+              0.113632,
+              0.114959,
+              0.115448,
+              0.11447,
+              0.114051,
+              0.11454,
+              0.11447,
+              0.114959,
+              0.114051,
+              0.152813,
+              0.113003,
+              0.114051,
+              0.113074,
+              0.114051,
+              0.113632,
+              0.114958,
+              0.11447,
+              0.113073,
+              0.115378,
+              0.114051,
+              0.113981,
+              0.113562,
+              0.115028,
+              0.113562
+            ],
+            "warm_rows_per_second": 4472787.629946711
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594522439986367,
+            "character_perplexity": 6.420219094563666,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.1295248559438053e-05,
+            "mean_prediction_kl_nats": 3.648268143178588e-06,
+            "prediction_kl_p99_nats": 2.577223089372882e-05,
+            "maximum_prediction_kl_nats": 0.00010449443355391112,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.031384944915771484,
+            "maximum_per_target_cross_entropy_increase": 0.028478145599365234
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802301,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 131,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "7a21ec1590d5c8c461d39c7936eefcd8c2a50245cde875af4712b68897f74de2",
+            "table_sha256": "fe1f98da27c853a902917702ab5d04fb502ae7236f0ac69e95da5273a0e4a755",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3854801938869059,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803553,
+          "backend_with_key_registry_bytes": 3401074,
+          "backend_with_datrie_key_index_bytes": 3098513,
+          "full_model_serving_artifact_bytes": 4101072,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999235421852686,
+            "mean_cosine": 0.9999882155834846,
+            "p05_cosine": 0.9999769308878261,
+            "relative_l2_mean": 0.004745605336158613,
+            "relative_l2_p95": 0.006838408959516379,
+            "relative_l2_max": 0.012370012480415811,
+            "weighted_relative_l2_mean": 0.003092517752458587,
+            "weighted_relative_frobenius": 0.0053606944760871186,
+            "weighted_mean_cosine": 0.9999913748526958,
+            "max_relative_norm_change": 0.0033418314673439907
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.744265,
+            "warm_p50_ms": 0.114539,
+            "warm_p95_ms": 0.11700479999999999,
+            "warm_p99_ms": 0.12482267999999999,
+            "samples_ms": [
+              0.11873,
+              0.115448,
+              0.115448,
+              0.115448,
+              0.113493,
+              0.115029,
+              0.115867,
+              0.116914,
+              0.115448,
+              0.116426,
+              0.11454,
+              0.115029,
+              0.128718,
+              0.115936,
+              0.114051,
+              0.114539,
+              0.113422,
+              0.112584,
+              0.113074,
+              0.112584,
+              0.113073,
+              0.113981,
+              0.114051,
+              0.11454,
+              0.11447,
+              0.113981,
+              0.114051,
+              0.113981,
+              0.113492,
+              0.114051,
+              0.114959,
+              0.11454,
+              0.11454,
+              0.1144,
+              0.114959,
+              0.11454,
+              0.11447,
+              0.114539,
+              0.113981,
+              0.113911
+            ],
+            "warm_rows_per_second": 4470093.15604292
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594522439986367,
+            "character_perplexity": 6.420219094563666,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.1295248559438053e-05,
+            "mean_prediction_kl_nats": 3.648268143178588e-06,
+            "prediction_kl_p99_nats": 2.577223089372882e-05,
+            "maximum_prediction_kl_nats": 0.00010449443355391112,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.031384944915771484,
+            "maximum_per_target_cross_entropy_increase": 0.028478145599365234
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802301,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 131,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "7a21ec1590d5c8c461d39c7936eefcd8c2a50245cde875af4712b68897f74de2",
+            "table_sha256": "fe1f98da27c853a902917702ab5d04fb502ae7236f0ac69e95da5273a0e4a755",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.251635808032006,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803553,
+          "backend_with_key_registry_bytes": 3401074,
+          "backend_with_datrie_key_index_bytes": 3098513,
+          "full_model_serving_artifact_bytes": 4101072,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999235421852686,
+            "mean_cosine": 0.9999882155834846,
+            "p05_cosine": 0.9999769308878261,
+            "relative_l2_mean": 0.004745605336158613,
+            "relative_l2_p95": 0.006838408959516379,
+            "relative_l2_max": 0.012370012480415811,
+            "weighted_relative_l2_mean": 0.003092517752458587,
+            "weighted_relative_frobenius": 0.0053606944760871186,
+            "weighted_mean_cosine": 0.9999913748526958,
+            "max_relative_norm_change": 0.0033418314673439907
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.734767,
+            "warm_p50_ms": 0.11450450000000001,
+            "warm_p95_ms": 0.1220409,
+            "warm_p99_ms": 0.13058091,
+            "samples_ms": [
+              0.122013,
+              0.117753,
+              0.114959,
+              0.115447,
+              0.116426,
+              0.116356,
+              0.116845,
+              0.135702,
+              0.122571,
+              0.114889,
+              0.121105,
+              0.115028,
+              0.113562,
+              0.115937,
+              0.114959,
+              0.114959,
+              0.112165,
+              0.113632,
+              0.113562,
+              0.115029,
+              0.114051,
+              0.113911,
+              0.112585,
+              0.113073,
+              0.112514,
+              0.112584,
+              0.112585,
+              0.11447,
+              0.114051,
+              0.114539,
+              0.112654,
+              0.114051,
+              0.113562,
+              0.113981,
+              0.114051,
+              0.113981,
+              0.114958,
+              0.114959,
+              0.114889,
+              0.11447
+            ],
+            "warm_rows_per_second": 4471439.987074743
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594522439986367,
+            "character_perplexity": 6.420219094563666,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.1295248559438053e-05,
+            "mean_prediction_kl_nats": 3.648268143178588e-06,
+            "prediction_kl_p99_nats": 2.577223089372882e-05,
+            "maximum_prediction_kl_nats": 0.00010449443355391112,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.031384944915771484,
+            "maximum_per_target_cross_entropy_increase": 0.028478145599365234
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2161923,
+              "unique_rows": 27408,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 60,
+              "compressed_blocks": 169,
+              "zlib_blocks": 169,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27408
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "f01aaa4197a58748b13a903bda6add998e61bb3afcaf191d51ed3a2f9980f3ed",
+            "table_sha256": "e3d8d172bc0e5ffb7b700333a1324985f365aaee68130d8ca92920cc84bc3427",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2589109721593559,
+          "representatives_sha256": "c404d7a33bd005c51ff59902036cf11911785c3a3c86e4f2a72f3e382b6de83f",
+          "structurally_merged_rows": 9370,
+          "backend_artifact_bytes": 2163173,
+          "backend_with_key_registry_bytes": 2760694,
+          "backend_with_datrie_key_index_bytes": 2458133,
+          "full_model_serving_artifact_bytes": 3460692,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9902830008809947,
+            "mean_cosine": 0.9997745580967632,
+            "p05_cosine": 0.9988623939400101,
+            "relative_l2_mean": 0.01360689390174835,
+            "relative_l2_p95": 0.04794353444322512,
+            "relative_l2_max": 0.13922942015502465,
+            "weighted_relative_l2_mean": 0.005234278781483011,
+            "weighted_relative_frobenius": 0.01266636913425628,
+            "weighted_mean_cosine": 0.9999437981882358,
+            "max_relative_norm_change": 0.011360291955908557
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9903389209589103,
+            "mean_cosine": 0.9997809738838896,
+            "p05_cosine": 0.9988492390424457,
+            "relative_l2_mean": 0.01007816341469381,
+            "relative_l2_p95": 0.04822341063628851,
+            "relative_l2_max": 0.1388218665797682,
+            "weighted_relative_l2_mean": 0.0025294326379207833,
+            "weighted_relative_frobenius": 0.011752570284712499,
+            "weighted_mean_cosine": 0.999950583796412,
+            "max_relative_norm_change": 0.01010074239305728
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.911255,
+            "warm_p50_ms": 0.111607,
+            "warm_p95_ms": 0.11677864999999998,
+            "warm_p99_ms": 0.12543893,
+            "samples_ms": [
+              0.114051,
+              0.113003,
+              0.126692,
+              0.113982,
+              0.112584,
+              0.116356,
+              0.111607,
+              0.111118,
+              0.111607,
+              0.112095,
+              0.111676,
+              0.111676,
+              0.111746,
+              0.113492,
+              0.114051,
+              0.110699,
+              0.111607,
+              0.111677,
+              0.111257,
+              0.10979,
+              0.111536,
+              0.111187,
+              0.111257,
+              0.111187,
+              0.111607,
+              0.111606,
+              0.111606,
+              0.109232,
+              0.111118,
+              0.110279,
+              0.10979,
+              0.116426,
+              0.108813,
+              0.112515,
+              0.110629,
+              0.112096,
+              0.109302,
+              0.123479,
+              0.112584,
+              0.112165
+            ],
+            "warm_rows_per_second": 4587525.872033116
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8594851865060764,
+            "character_perplexity": 6.42043059616263,
+            "next_character_accuracy": 0.49555282932065636,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 4.423867070959386e-05,
+            "mean_prediction_kl_nats": 1.40456145856038e-05,
+            "prediction_kl_p99_nats": 0.00016217386332785115,
+            "maximum_prediction_kl_nats": 0.002340309688407767,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": 0.000460052139242495,
+            "maximum_absolute_logit_change": 0.25087714195251465,
+            "maximum_per_target_cross_entropy_increase": 0.11739516258239746
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.294305005021718e-05,
+            "mean_prediction_kl_nats": 1.0321497770350946e-05,
+            "prediction_kl_p99_nats": 0.0001315307878000659,
+            "maximum_prediction_kl_nats": 0.0023158615785463044,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.2475517988204956,
+            "maximum_per_target_cross_entropy_increase": 0.11541223526000977
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2160397,
+              "unique_rows": 27387,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 62,
+              "compressed_blocks": 167,
+              "zlib_blocks": 167,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27387
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "ad282e29aaa0515112a327c85e8c943fe32bd5ff0a65f16b6b135aa9a4d708c7",
+            "table_sha256": "71db6e7b0acf5bfcc0df7266267c23968ab42c9c466f667f98cb5e4119911644",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22282429388724267,
+          "representatives_sha256": "d2de16a859b62db0947eb52fa6f461884bc24f9e8349b3b13475bf3d37fdab95",
+          "structurally_merged_rows": 9391,
+          "backend_artifact_bytes": 2161647,
+          "backend_with_key_registry_bytes": 2759168,
+          "backend_with_datrie_key_index_bytes": 2456607,
+          "full_model_serving_artifact_bytes": 3459166,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9816421009306339,
+            "mean_cosine": 0.9997652403899993,
+            "p05_cosine": 0.9988548508913819,
+            "relative_l2_mean": 0.013712651661030487,
+            "relative_l2_p95": 0.048130194023205695,
+            "relative_l2_max": 0.19229178536981864,
+            "weighted_relative_l2_mean": 0.005289604356728374,
+            "weighted_relative_frobenius": 0.013628023787982177,
+            "weighted_mean_cosine": 0.999938779029103,
+            "max_relative_norm_change": 0.011360291955908557
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.981848720195287,
+            "mean_cosine": 0.9997716323604746,
+            "p05_cosine": 0.9988420028161887,
+            "relative_l2_mean": 0.010186784702438669,
+            "relative_l2_p95": 0.04838511617363744,
+            "relative_l2_max": 0.19109288303028826,
+            "weighted_relative_l2_mean": 0.0025862251985459338,
+            "weighted_relative_frobenius": 0.012785517298615963,
+            "weighted_mean_cosine": 0.9999455515365314,
+            "max_relative_norm_change": 0.01010074239305728
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.999744,
+            "warm_p50_ms": 0.11220050000000001,
+            "warm_p95_ms": 0.11740729999999999,
+            "warm_p99_ms": 0.12165480000000001,
+            "samples_ms": [
+              0.115448,
+              0.111677,
+              0.113562,
+              0.112235,
+              0.113981,
+              0.113982,
+              0.113562,
+              0.112165,
+              0.112235,
+              0.1188,
+              0.113493,
+              0.113562,
+              0.114051,
+              0.112166,
+              0.112096,
+              0.112096,
+              0.112166,
+              0.112096,
+              0.117334,
+              0.111188,
+              0.113492,
+              0.113003,
+              0.112095,
+              0.112584,
+              0.12348,
+              0.113562,
+              0.112096,
+              0.117334,
+              0.111677,
+              0.111677,
+              0.112096,
+              0.112095,
+              0.113003,
+              0.112095,
+              0.112095,
+              0.116844,
+              0.112165,
+              0.112095,
+              0.112095,
+              0.112165
+            ],
+            "warm_rows_per_second": 4563259.52201639
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.85954489198257,
+            "character_perplexity": 6.42081394247449,
+            "next_character_accuracy": 0.49539947860757555,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010394857098016971,
+            "mean_prediction_kl_nats": 4.382602376892404e-05,
+            "prediction_kl_p99_nats": 0.00016823848963472371,
+            "maximum_prediction_kl_nats": 0.08511632811208247,
+            "top1_changed_fraction": 0.0021469099831314216,
+            "accuracy_change": 0.00030670142616168183,
+            "maximum_absolute_logit_change": 0.4676833152770996,
+            "maximum_per_target_cross_entropy_increase": 0.4725503921508789
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.265227589024589e-05,
+            "mean_prediction_kl_nats": 4.034427924357419e-05,
+            "prediction_kl_p99_nats": 0.0001563639767156741,
+            "maximum_prediction_kl_nats": 0.08632221023776415,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -7.667535654037883e-05,
+            "maximum_absolute_logit_change": 0.46900463104248047,
+            "maximum_per_target_cross_entropy_increase": 0.4750744104385376
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2159741,
+              "unique_rows": 27378,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 61,
+              "compressed_blocks": 168,
+              "zlib_blocks": 168,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27378
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "69458614fd13cf52ebf575d8817b1c4d821a8c1c7e9d947652c124918186a5db",
+            "table_sha256": "97d860efd673013410d4637fb123871f0ecb46f3e99ea34c5c949d00936cf699",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22295161592774093,
+          "representatives_sha256": "e842e6993c70cf7eb2ccf091e48159221e64ec8e727d0a14df416cab65eaca09",
+          "structurally_merged_rows": 9400,
+          "backend_artifact_bytes": 2160991,
+          "backend_with_key_registry_bytes": 2758512,
+          "backend_with_datrie_key_index_bytes": 2455951,
+          "full_model_serving_artifact_bytes": 3458510,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9707975827186466,
+            "mean_cosine": 0.9997560166171646,
+            "p05_cosine": 0.9988474667289791,
+            "relative_l2_mean": 0.013791136960217677,
+            "relative_l2_p95": 0.048213008711153964,
+            "relative_l2_max": 0.24134291688908707,
+            "weighted_relative_l2_mean": 0.005307653165989682,
+            "weighted_relative_frobenius": 0.013898882213643262,
+            "weighted_mean_cosine": 0.9999365518952043,
+            "max_relative_norm_change": 0.011360291955908557
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9707887824572112,
+            "mean_cosine": 0.9997624007244594,
+            "p05_cosine": 0.9988381018375099,
+            "relative_l2_mean": 0.010266526746003363,
+            "relative_l2_p95": 0.04848659250948559,
+            "relative_l2_max": 0.2413508426857053,
+            "weighted_relative_l2_mean": 0.0026046390875125703,
+            "weighted_relative_frobenius": 0.013074109055989915,
+            "weighted_mean_cosine": 0.999943322863491,
+            "max_relative_norm_change": 0.01010074239305728
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.145434,
+            "warm_p50_ms": 0.11185149999999999,
+            "warm_p95_ms": 0.11409974999999999,
+            "warm_p99_ms": 0.13914864999999998,
+            "samples_ms": [
+              0.116356,
+              0.113143,
+              0.113004,
+              0.113981,
+              0.112584,
+              0.113003,
+              0.112095,
+              0.111606,
+              0.113073,
+              0.112165,
+              0.111187,
+              0.111677,
+              0.112096,
+              0.111188,
+              0.112026,
+              0.111118,
+              0.109791,
+              0.113562,
+              0.113143,
+              0.111188,
+              0.153721,
+              0.113562,
+              0.111187,
+              0.111676,
+              0.111536,
+              0.112095,
+              0.110279,
+              0.111187,
+              0.110698,
+              0.111118,
+              0.111677,
+              0.111676,
+              0.112584,
+              0.112165,
+              0.110768,
+              0.111606,
+              0.111188,
+              0.112515,
+              0.112584,
+              0.111606
+            ],
+            "warm_rows_per_second": 4577497.843122355
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595651472084707,
+            "character_perplexity": 6.420943998828518,
+            "next_character_accuracy": 0.49539947860757555,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001242061075425597,
+            "mean_prediction_kl_nats": 5.2638764337911946e-05,
+            "prediction_kl_p99_nats": 0.00018133778386500096,
+            "maximum_prediction_kl_nats": 0.08511632811208247,
+            "top1_changed_fraction": 0.0022235853396718294,
+            "accuracy_change": 0.00030670142616168183,
+            "maximum_absolute_logit_change": 0.5142704248428345,
+            "maximum_per_target_cross_entropy_increase": 0.4725503921508789
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00011290958364130969,
+            "mean_prediction_kl_nats": 4.9197622857850525e-05,
+            "prediction_kl_p99_nats": 0.00016645288080595016,
+            "maximum_prediction_kl_nats": 0.08632221023776415,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": -7.667535654037883e-05,
+            "maximum_absolute_logit_change": 0.5174161195755005,
+            "maximum_per_target_cross_entropy_increase": 0.4750744104385376
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2159196,
+              "unique_rows": 27369,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 58,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27369
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "046c7c0f394517bf27a820dfec412434ce72494adaf29e4930cd4f18a4015163",
+            "table_sha256": "be41f5beb6281bad05b67299662ee40ddec9ae1155bc3567ac86f20373e4a284",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22292598406784236,
+          "representatives_sha256": "d4ebb46412064fb5a48afc1145b3825651cd0041a3b99efba712dca65fe57243",
+          "structurally_merged_rows": 9409,
+          "backend_artifact_bytes": 2160446,
+          "backend_with_key_registry_bytes": 2757967,
+          "backend_with_datrie_key_index_bytes": 2455406,
+          "full_model_serving_artifact_bytes": 3457965,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9503393835533169,
+            "mean_cosine": 0.9997387406374143,
+            "p05_cosine": 0.9988440679432582,
+            "relative_l2_mean": 0.013906177449907827,
+            "relative_l2_p95": 0.048287317929070005,
+            "relative_l2_max": 0.3165663548628563,
+            "weighted_relative_l2_mean": 0.005416989166314837,
+            "weighted_relative_frobenius": 0.01555448737128707,
+            "weighted_mean_cosine": 0.9999198514354147,
+            "max_relative_norm_change": 0.011360291955908557
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9503933292350666,
+            "mean_cosine": 0.9997451200762226,
+            "p05_cosine": 0.9988322194559154,
+            "relative_l2_mean": 0.010382896028430847,
+            "relative_l2_p95": 0.048593494091304056,
+            "relative_l2_max": 0.3162155535296128,
+            "weighted_relative_l2_mean": 0.0027153392047157185,
+            "weighted_relative_frobenius": 0.014827773285010164,
+            "weighted_mean_cosine": 0.999926567519293,
+            "max_relative_norm_change": 0.01010074239305728
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.229313,
+            "warm_p50_ms": 0.11143149999999999,
+            "warm_p95_ms": 0.11547239999999999,
+            "warm_p99_ms": 0.12714108999999998,
+            "samples_ms": [
+              0.115448,
+              0.113492,
+              0.113073,
+              0.113003,
+              0.111607,
+              0.113073,
+              0.111187,
+              0.113073,
+              0.134305,
+              0.114051,
+              0.111187,
+              0.112235,
+              0.110209,
+              0.111117,
+              0.111187,
+              0.111257,
+              0.111257,
+              0.111676,
+              0.111606,
+              0.112095,
+              0.112095,
+              0.10986,
+              0.111606,
+              0.112095,
+              0.111117,
+              0.110698,
+              0.111257,
+              0.11021,
+              0.11447,
+              0.108743,
+              0.110769,
+              0.11028,
+              0.11014,
+              0.111187,
+              0.113073,
+              0.111677,
+              0.109791,
+              0.115936,
+              0.110279,
+              0.111118
+            ],
+            "warm_rows_per_second": 4594751.035389455
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8595402974727455,
+            "character_perplexity": 6.420784442049521,
+            "next_character_accuracy": 0.49562950467719674,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.935359411882117e-05,
+            "mean_prediction_kl_nats": 8.015656015131716e-05,
+            "prediction_kl_p99_nats": 0.00021484519682922647,
+            "maximum_prediction_kl_nats": 0.08511632811208247,
+            "top1_changed_fraction": 0.002453611409293053,
+            "accuracy_change": 0.0005367274957828738,
+            "maximum_absolute_logit_change": 0.9997484683990479,
+            "maximum_per_target_cross_entropy_increase": 0.5335344076156616
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 8.805735092971689e-05,
+            "mean_prediction_kl_nats": 7.68182050921748e-05,
+            "prediction_kl_p99_nats": 0.0002090726426707212,
+            "maximum_prediction_kl_nats": 0.08632221023776415,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 1.0042335987091064,
+            "maximum_per_target_cross_entropy_increase": 0.5382595062255859
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2157353,
+              "unique_rows": 27342,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 56,
+              "compressed_blocks": 172,
+              "zlib_blocks": 172,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27342
+            },
+            "source_float32_sha256": "0e8b9cb031160e8df3fa6ebc3f76ab5e718940d0564b573772b46a06d6812b63",
+            "decoded_float32_sha256": "383b1e1b5a7b13f93bfa7966f558e8d70b522e53a597c2151a8e7c2a638c1e8d",
+            "table_sha256": "9d711388510a55735272b6ab8f3c6caf339089ec1272fc9069d360ac7a08974c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2181943708565086,
+          "representatives_sha256": "b8af1ff6069e469f3da9b4564d33d1ddef34b63c7a7cb9e594537cae38d574ee",
+          "structurally_merged_rows": 9436,
+          "backend_artifact_bytes": 2158603,
+          "backend_with_key_registry_bytes": 2756124,
+          "backend_with_datrie_key_index_bytes": 2453563,
+          "full_model_serving_artifact_bytes": 3456122,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9003178663665001,
+            "mean_cosine": 0.9996587291999485,
+            "p05_cosine": 0.9988343072054923,
+            "relative_l2_mean": 0.014300957383312534,
+            "relative_l2_p95": 0.04852503555078502,
+            "relative_l2_max": 0.4473976520047374,
+            "weighted_relative_l2_mean": 0.00555003852404553,
+            "weighted_relative_frobenius": 0.018010361448504417,
+            "weighted_mean_cosine": 0.9998933863856327,
+            "max_relative_norm_change": 0.011360291955908557
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9001092385885267,
+            "mean_cosine": 0.9996650778254199,
+            "p05_cosine": 0.9988186190338227,
+            "relative_l2_mean": 0.010781167898732758,
+            "relative_l2_p95": 0.04883380186376116,
+            "relative_l2_max": 0.44752145877237726,
+            "weighted_relative_l2_mean": 0.0028503829810415608,
+            "weighted_relative_frobenius": 0.017390962375218838,
+            "weighted_mean_cosine": 0.9999000452268496,
+            "max_relative_norm_change": 0.01010074239305728
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.429827,
+            "warm_p50_ms": 0.1088475,
+            "warm_p95_ms": 0.1150601,
+            "warm_p99_ms": 0.12666128999999998,
+            "samples_ms": [
+              0.118311,
+              0.110768,
+              0.110209,
+              0.109302,
+              0.109232,
+              0.110768,
+              0.110209,
+              0.10979,
+              0.107905,
+              0.109232,
+              0.106508,
+              0.108394,
+              0.109232,
+              0.108813,
+              0.108813,
+              0.132,
+              0.108743,
+              0.108882,
+              0.109721,
+              0.109791,
+              0.108813,
+              0.108394,
+              0.108813,
+              0.108394,
+              0.108813,
+              0.109371,
+              0.108324,
+              0.114889,
+              0.109302,
+              0.108812,
+              0.108813,
+              0.108813,
+              0.106997,
+              0.107835,
+              0.108394,
+              0.109791,
+              0.108393,
+              0.109372,
+              0.109721,
+              0.107346
+            ],
+            "warm_rows_per_second": 4703828.751234525
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.859759182445135,
+            "character_perplexity": 6.422190009097978,
+            "next_character_accuracy": 0.49555282932065636,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.000318284272960733,
+            "mean_prediction_kl_nats": 0.00018617670185500242,
+            "prediction_kl_p99_nats": 0.00033826775677929126,
+            "maximum_prediction_kl_nats": 0.36318883394217805,
+            "top1_changed_fraction": 0.002760312835454685,
+            "accuracy_change": 0.000460052139242495,
+            "maximum_absolute_logit_change": 1.1912569999694824,
+            "maximum_per_target_cross_entropy_increase": 0.9961937069892883
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00030698555692312536,
+            "mean_prediction_kl_nats": 0.00018294799506168375,
+            "prediction_kl_p99_nats": 0.0003370419292004499,
+            "maximum_prediction_kl_nats": 0.36399144749440143,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.1943440437316895,
+            "maximum_per_target_cross_entropy_increase": 0.995843231678009
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.8594409488138681,
+          "character_perplexity": 6.420146577412286,
+          "next_character_accuracy": 0.49509277718141387,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.732981677202601,
+          "character_perplexity": 5.657497616365887,
+          "next_character_accuracy": 0.5241125507935291,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.95",
+          "backend_with_key_registry_bytes": 7430160,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.733085906821203,
+            "character_perplexity": 5.658087325916751,
+            "next_character_accuracy": 0.5241892202714099,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00010423505069745625,
+            "mean_prediction_kl_nats": 0.00013875969726630407,
+            "prediction_kl_p99_nats": 0.00038196038107028794,
+            "maximum_prediction_kl_nats": 0.09296217712975313,
+            "top1_changed_fraction": 0.0010733726903319788,
+            "accuracy_change": 7.666947788076417e-05,
+            "maximum_absolute_logit_change": 1.504372239112854,
+            "maximum_per_target_cross_entropy_increase": 0.5252523422241211
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00022564232065017386,
+              0.0003975916668243442
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.95",
+          "backend_with_key_registry_bytes": 4136212,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.733086864041349,
+            "character_perplexity": 5.658092741954519,
+            "next_character_accuracy": 0.5241892202714099,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00010519237107762973,
+            "mean_prediction_kl_nats": 0.0001388013511152666,
+            "prediction_kl_p99_nats": 0.0003827823135934586,
+            "maximum_prediction_kl_nats": 0.09302745751300914,
+            "top1_changed_fraction": 0.0010733726903319788,
+            "accuracy_change": 7.666947788076417e-05,
+            "maximum_absolute_logit_change": 1.5042415857315063,
+            "maximum_per_target_cross_entropy_increase": 0.5253055095672607
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00022603695046941323,
+              0.00039856463735664214
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.95",
+          "backend_with_key_registry_bytes": 2757967,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7330446700904785,
+            "character_perplexity": 5.657854009703907,
+            "next_character_accuracy": 0.5242658897492908,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 6.299487197111428e-05,
+            "mean_prediction_kl_nats": 0.00013896683904643248,
+            "prediction_kl_p99_nats": 0.00035191132917633707,
+            "maximum_prediction_kl_nats": 0.09188349093556392,
+            "top1_changed_fraction": 0.0017633979912596795,
+            "accuracy_change": 0.00015333895576163936,
+            "maximum_absolute_logit_change": 1.4925585985183716,
+            "maximum_per_target_cross_entropy_increase": 0.5185873508453369
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0002516761914661864,
+              0.00035003994847103626
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7329812414730335,
+            "character_perplexity": 5.657495151227435,
+            "next_character_accuracy": 0.5241125507935291,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -4.3572947252552845e-07,
+            "mean_prediction_kl_nats": 3.895838651310438e-09,
+            "prediction_kl_p99_nats": 2.7689389975956324e-08,
+            "maximum_prediction_kl_nats": 1.3003728296797735e-07,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011608600616455078,
+            "maximum_per_target_cross_entropy_increase": 0.0008046627044677734
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.732985057497423,
+            "character_perplexity": 5.657516740408108,
+            "next_character_accuracy": 0.5241125507935291,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 3.380300535330562e-06,
+            "mean_prediction_kl_nats": 3.53532370279057e-06,
+            "prediction_kl_p99_nats": 2.8211052007782173e-05,
+            "maximum_prediction_kl_nats": 0.0001297718267378109,
+            "top1_changed_fraction": 0.0009200337345702676,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.029512405395507812,
+            "maximum_per_target_cross_entropy_increase": 0.020233631134033203
+          }
+        }
+      },
+      "checkpoint_sha256": "0e8078af3c09f2b3fc9f9326eeadf80476c38c986ac134e9d92181c35b724578",
+      "registry_sha256": "e22a7692100a89679e3088226c3399678ae46a06d73d93bef7d898aa00f6fb7c"
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "rows": 36778,
+      "dim": 64,
+      "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+      "source_float32_bytes": 9415168,
+      "key_registry_bytes": 597521,
+      "unchanged_backbone_artifact_bytes": 699998,
+      "alternative_datrie_key_index_bytes": 294960,
+      "query_rows": 512,
+      "query_ids_sha256": "c0a9c7f836d519eda638b9a28093508b2d62873b170686d55b9ec727411573db",
+      "frequency_trace_sha256": "efa6b79677263433708f5d18746f076a51a377d034e599be829419ac6115bd49",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 9415168,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "table_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.052108424017205834,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9415972,
+          "backend_with_key_registry_bytes": 10013493,
+          "backend_with_datrie_key_index_bytes": 9710932,
+          "full_model_serving_artifact_bytes": 10713491,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.288095,
+            "warm_p50_ms": 0.0482605,
+            "warm_p95_ms": 0.0487744,
+            "warm_p99_ms": 0.049238609999999995,
+            "samples_ms": [
+              0.049238,
+              0.049239,
+              0.04875,
+              0.04875,
+              0.048261,
+              0.048331,
+              0.048261,
+              0.048749,
+              0.048749,
+              0.046864,
+              0.048261,
+              0.04868,
+              0.046375,
+              0.046374,
+              0.046863,
+              0.047353,
+              0.047842,
+              0.04875,
+              0.048261,
+              0.048191,
+              0.048749,
+              0.047841,
+              0.048749,
+              0.046794,
+              0.048261,
+              0.04875,
+              0.048261,
+              0.047772,
+              0.047842,
+              0.046375,
+              0.046863,
+              0.047771,
+              0.046375,
+              0.047772,
+              0.047772,
+              0.046374,
+              0.04833,
+              0.048749,
+              0.04826,
+              0.047771
+            ],
+            "warm_rows_per_second": 10609090.249790201
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525171642296288,
+            "character_perplexity": 6.375848398003521,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082639,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "table_sha256": "30b4d7b29aac1d211e9639854476d82b2936e9a52bada58e85b31d536ede5398",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.7903805440291762,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083849,
+          "backend_with_key_registry_bytes": 9681370,
+          "backend_with_datrie_key_index_bytes": 9378809,
+          "full_model_serving_artifact_bytes": 10381368,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.489635,
+            "warm_p50_ms": 0.056327,
+            "warm_p95_ms": 0.05920835,
+            "warm_p99_ms": 0.06821229999999999,
+            "samples_ms": [
+              0.060203,
+              0.073333,
+              0.059156,
+              0.056222,
+              0.056292,
+              0.057758,
+              0.05727,
+              0.056781,
+              0.056292,
+              0.05727,
+              0.056362,
+              0.056362,
+              0.056292,
+              0.056292,
+              0.056781,
+              0.056222,
+              0.056292,
+              0.05685,
+              0.056781,
+              0.05727,
+              0.055734,
+              0.056222,
+              0.056362,
+              0.056361,
+              0.055873,
+              0.055873,
+              0.056292,
+              0.055803,
+              0.056781,
+              0.0572,
+              0.05727,
+              0.055873,
+              0.054476,
+              0.056362,
+              0.054965,
+              0.056293,
+              0.056781,
+              0.056292,
+              0.055734,
+              0.056223
+            ],
+            "warm_rows_per_second": 9089779.324302731
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525171642296288,
+            "character_perplexity": 6.375848398003521,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082639,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "table_sha256": "30b4d7b29aac1d211e9639854476d82b2936e9a52bada58e85b31d536ede5398",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9153684892226011,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083848,
+          "backend_with_key_registry_bytes": 9681369,
+          "backend_with_datrie_key_index_bytes": 9378808,
+          "full_model_serving_artifact_bytes": 10381367,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.460791,
+            "warm_p50_ms": 0.055559,
+            "warm_p95_ms": 0.0596929,
+            "warm_p99_ms": 0.07587382999999999,
+            "samples_ms": [
+              0.059644,
+              0.060622,
+              0.057688,
+              0.055873,
+              0.057689,
+              0.056781,
+              0.055314,
+              0.056222,
+              0.053917,
+              0.056362,
+              0.05727,
+              0.0572,
+              0.055384,
+              0.055873,
+              0.054476,
+              0.054895,
+              0.055874,
+              0.055873,
+              0.054895,
+              0.054965,
+              0.055873,
+              0.085625,
+              0.057689,
+              0.055385,
+              0.055873,
+              0.055384,
+              0.054895,
+              0.055314,
+              0.054895,
+              0.055384,
+              0.054895,
+              0.055314,
+              0.054895,
+              0.055803,
+              0.056223,
+              0.055315,
+              0.055314,
+              0.055733,
+              0.054825,
+              0.054406
+            ],
+            "warm_rows_per_second": 9215428.643424109
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525171642296288,
+            "character_perplexity": 6.375848398003521,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9082639,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "table_sha256": "30b4d7b29aac1d211e9639854476d82b2936e9a52bada58e85b31d536ede5398",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.8107393679674715,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083848,
+          "backend_with_key_registry_bytes": 9681369,
+          "backend_with_datrie_key_index_bytes": 9378808,
+          "full_model_serving_artifact_bytes": 10381367,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.510029,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.05867045,
+            "warm_p99_ms": 0.05988646,
+            "samples_ms": [
+              0.060622,
+              0.058667,
+              0.057689,
+              0.056292,
+              0.056362,
+              0.055873,
+              0.057689,
+              0.055804,
+              0.056781,
+              0.056292,
+              0.055734,
+              0.0572,
+              0.055454,
+              0.055384,
+              0.055873,
+              0.055873,
+              0.055873,
+              0.055384,
+              0.055873,
+              0.058178,
+              0.057689,
+              0.055384,
+              0.057758,
+              0.0572,
+              0.058736,
+              0.057759,
+              0.05727,
+              0.055873,
+              0.056292,
+              0.055803,
+              0.055384,
+              0.056293,
+              0.058667,
+              0.058178,
+              0.055803,
+              0.056292,
+              0.055384,
+              0.056292,
+              0.058178,
+              0.056361
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525171642296288,
+            "character_perplexity": 6.375848398003521,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6834157,
+              "unique_rows": 27356,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27356
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "f28974969a3a043c3a80922400a7d15e6c9bbcc97a8358eae5e42f49be64e9c6",
+            "table_sha256": "25bac41ea095284e22567e966e065bee4654e87ba02a7b8e518a043bb76b742f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6719967280514538,
+          "representatives_sha256": "7a281a43d6ba2ebdaab9799fb9ded5634de78634979b5a471bd864fdfb7ff118",
+          "structurally_merged_rows": 9422,
+          "backend_artifact_bytes": 6835363,
+          "backend_with_key_registry_bytes": 7432884,
+          "backend_with_datrie_key_index_bytes": 7130323,
+          "full_model_serving_artifact_bytes": 8132882,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901735396747365,
+            "mean_cosine": 0.9997820335582835,
+            "p05_cosine": 0.9988600506997894,
+            "relative_l2_mean": 0.010062147313454804,
+            "relative_l2_p95": 0.04801019397134542,
+            "relative_l2_max": 0.1398521329039012,
+            "weighted_relative_l2_mean": 0.002481341189480067,
+            "weighted_relative_frobenius": 0.011233518943283134,
+            "weighted_mean_cosine": 0.9999522274010958,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901735396747365,
+            "mean_cosine": 0.9997820335582835,
+            "p05_cosine": 0.9988600506997894,
+            "relative_l2_mean": 0.010062147313454804,
+            "relative_l2_p95": 0.04801019397134542,
+            "relative_l2_max": 0.1398521329039012,
+            "weighted_relative_l2_mean": 0.002481341189480067,
+            "weighted_relative_frobenius": 0.011233518943283134,
+            "weighted_mean_cosine": 0.9999522274010958,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.079946,
+            "warm_p50_ms": 0.0558385,
+            "warm_p95_ms": 0.0583632,
+            "warm_p99_ms": 0.06055261,
+            "samples_ms": [
+              0.060552,
+              0.058177,
+              0.0572,
+              0.060553,
+              0.058178,
+              0.058109,
+              0.05727,
+              0.058248,
+              0.056781,
+              0.05727,
+              0.055314,
+              0.055314,
+              0.055804,
+              0.055384,
+              0.0572,
+              0.056362,
+              0.056292,
+              0.057759,
+              0.056293,
+              0.057759,
+              0.055454,
+              0.055873,
+              0.054965,
+              0.055803,
+              0.055384,
+              0.054965,
+              0.055314,
+              0.055873,
+              0.055874,
+              0.055384,
+              0.055384,
+              0.055803,
+              0.053428,
+              0.055873,
+              0.054476,
+              0.053987,
+              0.054895,
+              0.054895,
+              0.054895,
+              0.054825
+            ],
+            "warm_rows_per_second": 9169300.751273762
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852589936519802,
+            "character_perplexity": 6.376312399976279,
+            "next_character_accuracy": 0.5013801564177274,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.277493814049522e-05,
+            "mean_prediction_kl_nats": 5.884713828666284e-06,
+            "prediction_kl_p99_nats": 0.00010471392741432696,
+            "maximum_prediction_kl_nats": 0.0006206674105765104,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": -0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.23345136642456055,
+            "maximum_per_target_cross_entropy_increase": 0.0630180835723877
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 7.277493814049522e-05,
+            "mean_prediction_kl_nats": 5.884713828666284e-06,
+            "prediction_kl_p99_nats": 0.00010471392741432696,
+            "maximum_prediction_kl_nats": 0.0006206674105765104,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": -0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.23345136642456055,
+            "maximum_per_target_cross_entropy_increase": 0.0630180835723877
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6829367,
+              "unique_rows": 27337,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27337
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "97f4cadb60613c7e71e4479292720b7b36028f674ba9b1e0e79e6e354ef56bf9",
+            "table_sha256": "27ad7aa908dcfdd5e6173437e75c7bfed5ac1ea58c61ef59b44d436e820434b5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6307932629715651,
+          "representatives_sha256": "5eff92e33cd485bb98a3eac5abcec46c200631815f44387ae3f54f1c15f6dd8b",
+          "structurally_merged_rows": 9441,
+          "backend_artifact_bytes": 6830573,
+          "backend_with_key_registry_bytes": 7428094,
+          "backend_with_datrie_key_index_bytes": 7125533,
+          "full_model_serving_artifact_bytes": 8128092,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9806045429468069,
+            "mean_cosine": 0.9997744007293583,
+            "p05_cosine": 0.9988530409975274,
+            "relative_l2_mean": 0.010152244071902218,
+            "relative_l2_p95": 0.04814969321960311,
+            "relative_l2_max": 0.19798703115127078,
+            "weighted_relative_l2_mean": 0.002568375099506692,
+            "weighted_relative_frobenius": 0.01331560186565728,
+            "weighted_mean_cosine": 0.9999448020457253,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9806045429468069,
+            "mean_cosine": 0.9997744007293583,
+            "p05_cosine": 0.9988530409975274,
+            "relative_l2_mean": 0.010152244071902218,
+            "relative_l2_p95": 0.04814969321960311,
+            "relative_l2_max": 0.19798703115127078,
+            "weighted_relative_l2_mean": 0.002568375099506692,
+            "weighted_relative_frobenius": 0.01331560186565728,
+            "weighted_mean_cosine": 0.9999448020457253,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.774321,
+            "warm_p50_ms": 0.055733,
+            "warm_p95_ms": 0.05873585,
+            "warm_p99_ms": 0.06905257,
+            "samples_ms": [
+              0.060063,
+              0.058666,
+              0.05727,
+              0.05685,
+              0.055384,
+              0.05727,
+              0.054825,
+              0.055315,
+              0.055315,
+              0.056292,
+              0.055733,
+              0.055733,
+              0.055803,
+              0.055734,
+              0.054826,
+              0.053918,
+              0.056223,
+              0.054337,
+              0.058248,
+              0.058108,
+              0.055873,
+              0.056851,
+              0.053987,
+              0.054406,
+              0.054965,
+              0.055873,
+              0.0748,
+              0.0572,
+              0.055733,
+              0.054825,
+              0.054336,
+              0.055384,
+              0.053498,
+              0.054895,
+              0.053917,
+              0.055873,
+              0.055454,
+              0.054476,
+              0.055873,
+              0.056362
+            ],
+            "warm_rows_per_second": 9186657.814939085
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525007685305952,
+            "character_perplexity": 6.375743862369073,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.6395564624773986e-05,
+            "mean_prediction_kl_nats": 2.1939708812914536e-05,
+            "prediction_kl_p99_nats": 0.00011821235869118451,
+            "maximum_prediction_kl_nats": 0.03485956466685582,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.3628110885620117,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -1.6395564624773986e-05,
+            "mean_prediction_kl_nats": 2.1939708812914536e-05,
+            "prediction_kl_p99_nats": 0.00011821235869118451,
+            "maximum_prediction_kl_nats": 0.03485956466685582,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.3628110885620117,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6827086,
+              "unique_rows": 27327,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 854,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 854,
+              "zlib_blocks": 854,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27327
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "24b9eb6ce21379fa95579811cd63fe48c92a4b0071cfc389b3b94d36c58d684f",
+            "table_sha256": "31efef37403c38fb200012740cb063ef06eb0f2a419b0e17967e33fc5a4c0d1d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6226584929972887,
+          "representatives_sha256": "1ea48882d40270fe86550574bf480b401cc53b5667517caf97945698b9e913aa",
+          "structurally_merged_rows": 9451,
+          "backend_artifact_bytes": 6828292,
+          "backend_with_key_registry_bytes": 7425813,
+          "backend_with_datrie_key_index_bytes": 7123252,
+          "full_model_serving_artifact_bytes": 8125811,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9709786172758579,
+            "mean_cosine": 0.9997646300753811,
+            "p05_cosine": 0.9988468769184199,
+            "relative_l2_mean": 0.010237178448012207,
+            "relative_l2_p95": 0.048278424585558345,
+            "relative_l2_max": 0.2415125233327801,
+            "weighted_relative_l2_mean": 0.002605521992310969,
+            "weighted_relative_frobenius": 0.014693300249397735,
+            "weighted_mean_cosine": 0.9999405173643419,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9709786172758579,
+            "mean_cosine": 0.9997646300753811,
+            "p05_cosine": 0.9988468769184199,
+            "relative_l2_mean": 0.010237178448012207,
+            "relative_l2_p95": 0.048278424585558345,
+            "relative_l2_max": 0.2415125233327801,
+            "weighted_relative_l2_mean": 0.002605521992310969,
+            "weighted_relative_frobenius": 0.014693300249397735,
+            "weighted_mean_cosine": 0.9999405173643419,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.766288,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.0596694,
+            "warm_p99_ms": 0.07368109999999999,
+            "samples_ms": [
+              0.059085,
+              0.060133,
+              0.059645,
+              0.056781,
+              0.059085,
+              0.082343,
+              0.057689,
+              0.056851,
+              0.057689,
+              0.058178,
+              0.05727,
+              0.055315,
+              0.055803,
+              0.055873,
+              0.055454,
+              0.055873,
+              0.056362,
+              0.055873,
+              0.055803,
+              0.057689,
+              0.056223,
+              0.055803,
+              0.055803,
+              0.055733,
+              0.055314,
+              0.055315,
+              0.055734,
+              0.055315,
+              0.056362,
+              0.056292,
+              0.055873,
+              0.055873,
+              0.055873,
+              0.055384,
+              0.055803,
+              0.056292,
+              0.055873,
+              0.055384,
+              0.056711,
+              0.055733
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852489701405089,
+            "character_perplexity": 6.375673301602006,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.74624474398571e-05,
+            "mean_prediction_kl_nats": 2.696258723223034e-05,
+            "prediction_kl_p99_nats": 0.00012362042407023673,
+            "maximum_prediction_kl_nats": 0.049842036475113476,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.743290901184082,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -2.74624474398571e-05,
+            "mean_prediction_kl_nats": 2.696258723223034e-05,
+            "prediction_kl_p99_nats": 0.00012362042407023673,
+            "maximum_prediction_kl_nats": 0.049842036475113476,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.743290901184082,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6824580,
+              "unique_rows": 27316,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 854,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 854,
+              "zlib_blocks": 854,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27316
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "01a343e3ceb0c65c4480ff127064c7876c3e6b42561e1a57db961044e89c4275",
+            "table_sha256": "81cfd761163b880ee94e57808ea7582077121d49861ec2c415cf2e051feb5eeb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6392606198787689,
+          "representatives_sha256": "0d6ba1d3a2d0cdae0fe754e6813613693a7a16717c6d3309e723887c0e943da5",
+          "structurally_merged_rows": 9462,
+          "backend_artifact_bytes": 6825786,
+          "backend_with_key_registry_bytes": 7423307,
+          "backend_with_datrie_key_index_bytes": 7120746,
+          "full_model_serving_artifact_bytes": 8123305,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9513234441624956,
+            "mean_cosine": 0.9997470418346616,
+            "p05_cosine": 0.9988408482469365,
+            "relative_l2_mean": 0.010360222319673776,
+            "relative_l2_p95": 0.048376897574973085,
+            "relative_l2_max": 0.31129419888155907,
+            "weighted_relative_l2_mean": 0.0027232213547155218,
+            "weighted_relative_frobenius": 0.01834001658780078,
+            "weighted_mean_cosine": 0.9999244913850499,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9513234441624956,
+            "mean_cosine": 0.9997470418346616,
+            "p05_cosine": 0.9988408482469365,
+            "relative_l2_mean": 0.010360222319673776,
+            "relative_l2_p95": 0.048376897574973085,
+            "relative_l2_max": 0.31129419888155907,
+            "weighted_relative_l2_mean": 0.0027232213547155218,
+            "weighted_relative_frobenius": 0.01834001658780078,
+            "weighted_mean_cosine": 0.9999244913850499,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.87126,
+            "warm_p50_ms": 0.055804,
+            "warm_p95_ms": 0.05917595,
+            "warm_p99_ms": 0.0676687,
+            "samples_ms": [
+              0.059574,
+              0.058178,
+              0.056781,
+              0.054476,
+              0.056292,
+              0.056781,
+              0.057759,
+              0.059155,
+              0.055873,
+              0.054476,
+              0.055384,
+              0.056781,
+              0.055874,
+              0.054896,
+              0.055384,
+              0.055873,
+              0.055873,
+              0.055385,
+              0.056292,
+              0.055244,
+              0.055803,
+              0.055314,
+              0.055314,
+              0.054895,
+              0.053987,
+              0.056781,
+              0.055804,
+              0.056293,
+              0.055803,
+              0.05727,
+              0.055314,
+              0.072844,
+              0.055803,
+              0.054826,
+              0.054826,
+              0.055804,
+              0.055314,
+              0.056292,
+              0.054825,
+              0.056292
+            ],
+            "warm_rows_per_second": 9174969.536233962
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8521260846628,
+            "character_perplexity": 6.373355421481727,
+            "next_character_accuracy": 0.5019168839135102,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003910031051826457,
+            "mean_prediction_kl_nats": 0.00012668706532695237,
+            "prediction_kl_p99_nats": 0.0001307250665160562,
+            "maximum_prediction_kl_nats": 0.12414267612917526,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.8881440162658691,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003910031051826457,
+            "mean_prediction_kl_nats": 0.00012668706532695237,
+            "prediction_kl_p99_nats": 0.0001307250665160562,
+            "maximum_prediction_kl_nats": 0.12414267612917526,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.8881440162658691,
+            "maximum_per_target_cross_entropy_increase": 0.2883567810058594
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6818694,
+              "unique_rows": 27292,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 853,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 853,
+              "zlib_blocks": 853,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27292
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "1b9166492d0bc6751440d4327dfd61cd7ac83033da680e93ac8222b01362268f",
+            "table_sha256": "55bf023fb3fc3f81cc2585f60d3a700947480aa2b8ba42109becac4929c08f16",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6190395930316299,
+          "representatives_sha256": "ed134a131973f62254def80cb9064931fc73fe7eef505181819eafb931307193",
+          "structurally_merged_rows": 9486,
+          "backend_artifact_bytes": 6819900,
+          "backend_with_key_registry_bytes": 7417421,
+          "backend_with_datrie_key_index_bytes": 7114860,
+          "full_model_serving_artifact_bytes": 8117419,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9000058268534885,
+            "mean_cosine": 0.9996821959897936,
+            "p05_cosine": 0.9988298505418146,
+            "relative_l2_mean": 0.010683446807069317,
+            "relative_l2_p95": 0.04867132648328578,
+            "relative_l2_max": 0.4457487621960916,
+            "weighted_relative_l2_mean": 0.003096513084103833,
+            "weighted_relative_frobenius": 0.02401041382452133,
+            "weighted_mean_cosine": 0.9998493620848846,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9000058268534885,
+            "mean_cosine": 0.9996821959897936,
+            "p05_cosine": 0.9988298505418146,
+            "relative_l2_mean": 0.010683446807069317,
+            "relative_l2_p95": 0.04867132648328578,
+            "relative_l2_max": 0.4457487621960916,
+            "weighted_relative_l2_mean": 0.003096513084103833,
+            "weighted_relative_frobenius": 0.02401041382452133,
+            "weighted_mean_cosine": 0.9998493620848846,
+            "max_relative_norm_change": 0.010064555420672167
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.088816,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.060132849999999995,
+            "warm_p99_ms": 0.07649893999999999,
+            "samples_ms": [
+              0.06146,
+              0.058736,
+              0.058178,
+              0.058178,
+              0.055384,
+              0.055733,
+              0.056223,
+              0.056851,
+              0.055873,
+              0.055873,
+              0.060063,
+              0.057689,
+              0.056362,
+              0.058248,
+              0.057689,
+              0.058247,
+              0.056292,
+              0.056292,
+              0.055803,
+              0.056223,
+              0.058667,
+              0.058667,
+              0.0572,
+              0.056222,
+              0.055873,
+              0.055384,
+              0.055384,
+              0.055384,
+              0.059575,
+              0.056292,
+              0.055385,
+              0.056292,
+              0.055803,
+              0.086114,
+              0.058667,
+              0.056292,
+              0.055873,
+              0.054476,
+              0.053918,
+              0.054825
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8521563373934884,
+            "character_perplexity": 6.373548235803439,
+            "next_character_accuracy": 0.5019168839135102,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003607617459665677,
+            "mean_prediction_kl_nats": 0.00022579112662206196,
+            "prediction_kl_p99_nats": 0.0003546683857314661,
+            "maximum_prediction_kl_nats": 0.12414267612917526,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.0743937492370605,
+            "maximum_per_target_cross_entropy_increase": 0.6843762397766113
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003607617459665677,
+            "mean_prediction_kl_nats": 0.00022579112662206196,
+            "prediction_kl_p99_nats": 0.0003546683857314661,
+            "maximum_prediction_kl_nats": 0.12414267612917526,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.0743937492370605,
+            "maximum_per_target_cross_entropy_increase": 0.6843762397766113
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 4707584,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "5e1e9eb12dad3c914b817161ca8ba461f69a9a80c798a2f75f2a1c88f00a27a2",
+            "table_sha256": "b9d730c7176cf58fede8bab1219fb42cb9ca785bdab964772b80efc4d4c0dcab",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05573004693724215,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4708389,
+          "backend_with_key_registry_bytes": 5305910,
+          "backend_with_datrie_key_index_bytes": 5003349,
+          "full_model_serving_artifact_bytes": 6005908,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999588217124,
+            "mean_cosine": 0.999999979190866,
+            "p05_cosine": 0.9999999715194372,
+            "relative_l2_mean": 0.0002065236265028307,
+            "relative_l2_p95": 0.00024247128939954417,
+            "relative_l2_max": 0.00030652577504051233,
+            "weighted_relative_l2_mean": 0.00011753808371651295,
+            "weighted_relative_frobenius": 0.00020704368102547602,
+            "weighted_mean_cosine": 0.9999999882675509,
+            "max_relative_norm_change": 0.00018710984770758387
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.348718,
+            "warm_p50_ms": 0.138565,
+            "warm_p95_ms": 0.14061415,
+            "warm_p99_ms": 0.14722647,
+            "samples_ms": [
+              0.139962,
+              0.138216,
+              0.139543,
+              0.137657,
+              0.138146,
+              0.138635,
+              0.137658,
+              0.139543,
+              0.143733,
+              0.140032,
+              0.137658,
+              0.139054,
+              0.137098,
+              0.138565,
+              0.14045,
+              0.137727,
+              0.137727,
+              0.14946,
+              0.139543,
+              0.138636,
+              0.139054,
+              0.137098,
+              0.138565,
+              0.137169,
+              0.13668,
+              0.138566,
+              0.138565,
+              0.137587,
+              0.138565,
+              0.138635,
+              0.137239,
+              0.138635,
+              0.137727,
+              0.138635,
+              0.136819,
+              0.137727,
+              0.138146,
+              0.138635,
+              0.138146,
+              0.137238
+            ],
+            "warm_rows_per_second": 3695016.7791289287
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525145874085385,
+            "character_perplexity": 6.375831968604068,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.5768177702404637e-06,
+            "mean_prediction_kl_nats": 4.324500096867378e-09,
+            "prediction_kl_p99_nats": 3.221988317093933e-08,
+            "maximum_prediction_kl_nats": 9.34618077573458e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010292530059814453,
+            "maximum_per_target_cross_entropy_increase": 0.0007352828979492188
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650449,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "5e1e9eb12dad3c914b817161ca8ba461f69a9a80c798a2f75f2a1c88f00a27a2",
+            "table_sha256": "be57013cde218e1ae57134f57ab3cfa76271302604acccd66f3fcb396f2839ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.43717795005068183,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651657,
+          "backend_with_key_registry_bytes": 5249178,
+          "backend_with_datrie_key_index_bytes": 4946617,
+          "full_model_serving_artifact_bytes": 5949176,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999588217124,
+            "mean_cosine": 0.999999979190866,
+            "p05_cosine": 0.9999999715194372,
+            "relative_l2_mean": 0.0002065236265028307,
+            "relative_l2_p95": 0.00024247128939954417,
+            "relative_l2_max": 0.00030652577504051233,
+            "weighted_relative_l2_mean": 0.00011753808371651295,
+            "weighted_relative_frobenius": 0.00020704368102547602,
+            "weighted_mean_cosine": 0.9999999882675509,
+            "max_relative_norm_change": 0.00018710984770758387
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.80505,
+            "warm_p50_ms": 0.146178,
+            "warm_p95_ms": 0.15052895,
+            "warm_p99_ms": 0.16651981999999999,
+            "samples_ms": [
+              0.149601,
+              0.148064,
+              0.148552,
+              0.147016,
+              0.147086,
+              0.148134,
+              0.146666,
+              0.146178,
+              0.148063,
+              0.149041,
+              0.147645,
+              0.148553,
+              0.147645,
+              0.146178,
+              0.1452,
+              0.144362,
+              0.14527,
+              0.145339,
+              0.150927,
+              0.145689,
+              0.176489,
+              0.14995,
+              0.146108,
+              0.1452,
+              0.14562,
+              0.150508,
+              0.146737,
+              0.145759,
+              0.14534,
+              0.145759,
+              0.145759,
+              0.146248,
+              0.145689,
+              0.146178,
+              0.145759,
+              0.145759,
+              0.144781,
+              0.145619,
+              0.150438,
+              0.145759
+            ],
+            "warm_rows_per_second": 3502579.0474626822
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525145874085385,
+            "character_perplexity": 6.375831968604068,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.5768177702404637e-06,
+            "mean_prediction_kl_nats": 4.324500096867378e-09,
+            "prediction_kl_p99_nats": 3.221988317093933e-08,
+            "maximum_prediction_kl_nats": 9.34618077573458e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010292530059814453,
+            "maximum_per_target_cross_entropy_increase": 0.0007352828979492188
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650449,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "5e1e9eb12dad3c914b817161ca8ba461f69a9a80c798a2f75f2a1c88f00a27a2",
+            "table_sha256": "be57013cde218e1ae57134f57ab3cfa76271302604acccd66f3fcb396f2839ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5636359148193151,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651656,
+          "backend_with_key_registry_bytes": 5249177,
+          "backend_with_datrie_key_index_bytes": 4946616,
+          "full_model_serving_artifact_bytes": 5949175,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999588217124,
+            "mean_cosine": 0.999999979190866,
+            "p05_cosine": 0.9999999715194372,
+            "relative_l2_mean": 0.0002065236265028307,
+            "relative_l2_p95": 0.00024247128939954417,
+            "relative_l2_max": 0.00030652577504051233,
+            "weighted_relative_l2_mean": 0.00011753808371651295,
+            "weighted_relative_frobenius": 0.00020704368102547602,
+            "weighted_mean_cosine": 0.9999999882675509,
+            "max_relative_norm_change": 0.00018710984770758387
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.784168,
+            "warm_p50_ms": 0.14733000000000002,
+            "warm_p95_ms": 0.17061604999999994,
+            "warm_p99_ms": 0.19245598,
+            "samples_ms": [
+              0.14946,
+              0.148622,
+              0.146597,
+              0.146737,
+              0.148483,
+              0.147575,
+              0.186406,
+              0.1452,
+              0.14527,
+              0.147155,
+              0.148552,
+              0.1452,
+              0.14562,
+              0.145689,
+              0.145689,
+              0.147575,
+              0.1452,
+              0.147644,
+              0.150438,
+              0.149041,
+              0.147645,
+              0.14527,
+              0.14527,
+              0.145689,
+              0.146667,
+              0.145689,
+              0.147155,
+              0.146667,
+              0.145689,
+              0.149041,
+              0.148622,
+              0.14527,
+              0.157073,
+              0.147505,
+              0.146666,
+              0.196324,
+              0.151346,
+              0.169785,
+              0.168947,
+              0.168877
+            ],
+            "warm_rows_per_second": 3475191.746419602
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525145874085385,
+            "character_perplexity": 6.375831968604068,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.5768177702404637e-06,
+            "mean_prediction_kl_nats": 4.324500096867378e-09,
+            "prediction_kl_p99_nats": 3.221988317093933e-08,
+            "maximum_prediction_kl_nats": 9.34618077573458e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010292530059814453,
+            "maximum_per_target_cross_entropy_increase": 0.0007352828979492188
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650449,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "5e1e9eb12dad3c914b817161ca8ba461f69a9a80c798a2f75f2a1c88f00a27a2",
+            "table_sha256": "be57013cde218e1ae57134f57ab3cfa76271302604acccd66f3fcb396f2839ef",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.45110794715583324,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651656,
+          "backend_with_key_registry_bytes": 5249177,
+          "backend_with_datrie_key_index_bytes": 4946616,
+          "full_model_serving_artifact_bytes": 5949175,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999588217124,
+            "mean_cosine": 0.999999979190866,
+            "p05_cosine": 0.9999999715194372,
+            "relative_l2_mean": 0.0002065236265028307,
+            "relative_l2_p95": 0.00024247128939954417,
+            "relative_l2_max": 0.00030652577504051233,
+            "weighted_relative_l2_mean": 0.00011753808371651295,
+            "weighted_relative_frobenius": 0.00020704368102547602,
+            "weighted_mean_cosine": 0.9999999882675509,
+            "max_relative_norm_change": 0.00018710984770758387
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.764333,
+            "warm_p50_ms": 0.147121,
+            "warm_p95_ms": 0.1518454,
+            "warm_p99_ms": 0.17373103,
+            "samples_ms": [
+              0.150857,
+              0.149041,
+              0.148553,
+              0.147645,
+              0.147574,
+              0.148064,
+              0.147086,
+              0.146736,
+              0.181657,
+              0.148553,
+              0.148064,
+              0.145619,
+              0.145689,
+              0.146109,
+              0.147575,
+              0.147156,
+              0.147156,
+              0.146248,
+              0.147086,
+              0.150927,
+              0.145689,
+              0.146597,
+              0.147156,
+              0.146248,
+              0.147156,
+              0.145759,
+              0.147156,
+              0.146737,
+              0.14534,
+              0.147575,
+              0.146248,
+              0.14527,
+              0.146178,
+              0.146666,
+              0.161334,
+              0.148064,
+              0.14527,
+              0.147086,
+              0.146597,
+              0.151346
+            ],
+            "warm_rows_per_second": 3480128.601627232
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525145874085385,
+            "character_perplexity": 6.375831968604068,
+            "next_character_accuracy": 0.5017635332004294,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.5768177702404637e-06,
+            "mean_prediction_kl_nats": 4.324500096867378e-09,
+            "prediction_kl_p99_nats": 3.221988317093933e-08,
+            "maximum_prediction_kl_nats": 9.34618077573458e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0010292530059814453,
+            "maximum_per_target_cross_entropy_increase": 0.0007352828979492188
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3538979,
+              "unique_rows": 27356,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27356
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "d12039e13a084e6288da830c7f215584bd264df7430402ac4a44a5536e21a4fd",
+            "table_sha256": "f17fe763c9a1f5d876554c3d10a78248e046947a9549e4c446c2856ebbf013f8",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3687351008411497,
+          "representatives_sha256": "4c62dcd1ad5b215aa55f4e8e28f4ac90fcf41ceb90a25e17d213683799437f9b",
+          "structurally_merged_rows": 9422,
+          "backend_artifact_bytes": 3540185,
+          "backend_with_key_registry_bytes": 4137706,
+          "backend_with_datrie_key_index_bytes": 3835145,
+          "full_model_serving_artifact_bytes": 4837704,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901762297460064,
+            "mean_cosine": 0.9997820555543439,
+            "p05_cosine": 0.9988603489157089,
+            "relative_l2_mean": 0.010214953275116508,
+            "relative_l2_p95": 0.04802668373932069,
+            "relative_l2_max": 0.139832944885907,
+            "weighted_relative_l2_mean": 0.0025829471377984657,
+            "weighted_relative_frobenius": 0.011234116695951897,
+            "weighted_mean_cosine": 0.9999522363805332,
+            "max_relative_norm_change": 0.01010576944316186
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901807346928359,
+            "mean_cosine": 0.9997820653830614,
+            "p05_cosine": 0.9988596000008526,
+            "relative_l2_mean": 0.010061514977180067,
+            "relative_l2_p95": 0.04801683914824954,
+            "relative_l2_max": 0.13980063605374016,
+            "weighted_relative_l2_mean": 0.002480531716172749,
+            "weighted_relative_frobenius": 0.011232898757745064,
+            "weighted_mean_cosine": 0.9999522432203907,
+            "max_relative_norm_change": 0.010098569885149627
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.905633,
+            "warm_p50_ms": 0.146422,
+            "warm_p95_ms": 0.1685689,
+            "warm_p99_ms": 0.17256018,
+            "samples_ms": [
+              0.14946,
+              0.147644,
+              0.168387,
+              0.168527,
+              0.169365,
+              0.145759,
+              0.144712,
+              0.145689,
+              0.146108,
+              0.14995,
+              0.145759,
+              0.145759,
+              0.146737,
+              0.144851,
+              0.146667,
+              0.146737,
+              0.151905,
+              0.145689,
+              0.146736,
+              0.146667,
+              0.146666,
+              0.145759,
+              0.167479,
+              0.167968,
+              0.174603,
+              0.146178,
+              0.1452,
+              0.145619,
+              0.146178,
+              0.167899,
+              0.168039,
+              0.146177,
+              0.14527,
+              0.146178,
+              0.146178,
+              0.145759,
+              0.144712,
+              0.145689,
+              0.167898,
+              0.167968
+            ],
+            "warm_rows_per_second": 3496742.2928248486
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525869792546004,
+            "character_perplexity": 6.376293543557386,
+            "next_character_accuracy": 0.5013801564177274,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.981746209715848e-05,
+            "mean_prediction_kl_nats": 5.893158849198016e-06,
+            "prediction_kl_p99_nats": 0.00010359299454403867,
+            "maximum_prediction_kl_nats": 0.0006213262813282408,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": -0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.2334275245666504,
+            "maximum_per_target_cross_entropy_increase": 0.0630805492401123
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 7.239446641474648e-05,
+            "mean_prediction_kl_nats": 5.884694380958763e-06,
+            "prediction_kl_p99_nats": 0.00010475046088103621,
+            "maximum_prediction_kl_nats": 0.0006223747706168132,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": -0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.23338603973388672,
+            "maximum_per_target_cross_entropy_increase": 0.06292223930358887
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3536848,
+              "unique_rows": 27338,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27338
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "937d1df77474fb2cf4272c65e4fcc0860b5097c45fdd8f80a70eba56cbfe9619",
+            "table_sha256": "dc24bbc961478837897ffaecc48bdcba295e4b1f3e1c1f223644c86431169cb0",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36003342689946294,
+          "representatives_sha256": "df8348472b426cae6fd7a92bad1815eaf4cb6bbd4a1432defac943607997210a",
+          "structurally_merged_rows": 9440,
+          "backend_artifact_bytes": 3538054,
+          "backend_with_key_registry_bytes": 4135575,
+          "backend_with_datrie_key_index_bytes": 3833014,
+          "full_model_serving_artifact_bytes": 4835573,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9806124557008215,
+            "mean_cosine": 0.999774823139785,
+            "p05_cosine": 0.9988537376886683,
+            "relative_l2_mean": 0.010300252832578329,
+            "relative_l2_p95": 0.04812333611612598,
+            "relative_l2_max": 0.1979532702102594,
+            "weighted_relative_l2_mean": 0.0026642370846242046,
+            "weighted_relative_frobenius": 0.01323357293932989,
+            "weighted_mean_cosine": 0.9999452922090167,
+            "max_relative_norm_change": 0.01010576944316186
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9806137170452336,
+            "mean_cosine": 0.9997748339692338,
+            "p05_cosine": 0.9988534109705031,
+            "relative_l2_mean": 0.010146909778610541,
+            "relative_l2_p95": 0.04811074740344134,
+            "relative_l2_max": 0.19794634814101575,
+            "weighted_relative_l2_mean": 0.002561917971575951,
+            "weighted_relative_frobenius": 0.013232561349049259,
+            "weighted_mean_cosine": 0.9999452995059956,
+            "max_relative_norm_change": 0.010098569885149627
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.058028,
+            "warm_p50_ms": 0.1460035,
+            "warm_p95_ms": 0.16206725,
+            "warm_p99_ms": 0.16884807999999998,
+            "samples_ms": [
+              0.147086,
+              0.147156,
+              0.146178,
+              0.150439,
+              0.1452,
+              0.145759,
+              0.146736,
+              0.146667,
+              0.14527,
+              0.146667,
+              0.150997,
+              0.14527,
+              0.161753,
+              0.146667,
+              0.143803,
+              0.1452,
+              0.146248,
+              0.143873,
+              0.144851,
+              0.146248,
+              0.14527,
+              0.146736,
+              0.144781,
+              0.144781,
+              0.143803,
+              0.144781,
+              0.14527,
+              0.145829,
+              0.144292,
+              0.145759,
+              0.151346,
+              0.145689,
+              0.169366,
+              0.168038,
+              0.146248,
+              0.14534,
+              0.151905,
+              0.144781,
+              0.158959,
+              0.146667
+            ],
+            "warm_rows_per_second": 3506765.2487782827
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852498542202316,
+            "character_perplexity": 6.375729667886012,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.8621853923990522e-05,
+            "mean_prediction_kl_nats": 2.1932618984387973e-05,
+            "prediction_kl_p99_nats": 0.00011857932071118246,
+            "maximum_prediction_kl_nats": 0.03487250158408524,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.3628807067871094,
+            "maximum_per_target_cross_entropy_increase": 0.28847646713256836
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -1.604507749899088e-05,
+            "mean_prediction_kl_nats": 2.1927497150990994e-05,
+            "prediction_kl_p99_nats": 0.00011877888677840257,
+            "maximum_prediction_kl_nats": 0.034874330753904434,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.3629586696624756,
+            "maximum_per_target_cross_entropy_increase": 0.28856325149536133
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3535500,
+              "unique_rows": 27328,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 427,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 427,
+              "zlib_blocks": 427,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27328
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "d6037ca8e04418feae7eaa8e60f1af3a9834ffafb67ef4912ab3476ec9410a91",
+            "table_sha256": "7e1e0bcd89720660613d6f86f4284b263e2ab07238e0d2b010eb1abeee2fc603",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3660884629935026,
+          "representatives_sha256": "f87cf6f37333a9c633b7ebdec21578fef04fd104c1f2a6a8878fbf5c2368da98",
+          "structurally_merged_rows": 9450,
+          "backend_artifact_bytes": 3536706,
+          "backend_with_key_registry_bytes": 4134227,
+          "backend_with_datrie_key_index_bytes": 3831666,
+          "full_model_serving_artifact_bytes": 4834225,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9709827022114997,
+            "mean_cosine": 0.9997650521906866,
+            "p05_cosine": 0.9988471832102334,
+            "relative_l2_mean": 0.010385134048582139,
+            "relative_l2_p95": 0.048265962543471375,
+            "relative_l2_max": 0.24149555041857607,
+            "weighted_relative_l2_mean": 0.002701355191716331,
+            "weighted_relative_frobenius": 0.014619358124001142,
+            "weighted_mean_cosine": 0.9999410069544857,
+            "max_relative_norm_change": 0.01010576944316186
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.970984984297336,
+            "mean_cosine": 0.9997650624190308,
+            "p05_cosine": 0.9988474333802698,
+            "relative_l2_mean": 0.010231848281874937,
+            "relative_l2_p95": 0.04824688144478295,
+            "relative_l2_max": 0.24149217024845834,
+            "weighted_relative_l2_mean": 0.0025990682858739013,
+            "weighted_relative_frobenius": 0.014618411167244827,
+            "weighted_mean_cosine": 0.9999410141982245,
+            "max_relative_norm_change": 0.010098569885149627
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.073602,
+            "warm_p50_ms": 0.146178,
+            "warm_p95_ms": 0.15004345000000002,
+            "warm_p99_ms": 0.15826231999999998,
+            "samples_ms": [
+              0.149949,
+              0.147156,
+              0.146667,
+              0.14527,
+              0.14527,
+              0.14527,
+              0.144781,
+              0.148134,
+              0.147155,
+              0.146667,
+              0.145689,
+              0.146178,
+              0.150508,
+              0.16322,
+              0.148553,
+              0.147155,
+              0.146178,
+              0.146667,
+              0.146178,
+              0.146178,
+              0.144781,
+              0.144781,
+              0.147645,
+              0.146178,
+              0.146178,
+              0.146597,
+              0.144781,
+              0.145689,
+              0.145689,
+              0.14527,
+              0.145759,
+              0.14527,
+              0.14534,
+              0.144781,
+              0.145689,
+              0.146178,
+              0.14569,
+              0.144781,
+              0.150019,
+              0.146248
+            ],
+            "warm_rows_per_second": 3502579.0474626822
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8524874754607605,
+            "character_perplexity": 6.375659109723975,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.9688328161007978e-05,
+            "mean_prediction_kl_nats": 2.6959347392600337e-05,
+            "prediction_kl_p99_nats": 0.0001232882379827201,
+            "maximum_prediction_kl_nats": 0.04987204538153633,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.7435135841369629,
+            "maximum_per_target_cross_entropy_increase": 0.28847646713256836
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -2.7111580252369287e-05,
+            "mean_prediction_kl_nats": 2.6952233424099144e-05,
+            "prediction_kl_p99_nats": 0.00012372796579465564,
+            "maximum_prediction_kl_nats": 0.049850215883357044,
+            "top1_changed_fraction": 0.0013801564177273425,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.7435731887817383,
+            "maximum_per_target_cross_entropy_increase": 0.28856325149536133
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3534205,
+              "unique_rows": 27317,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 427,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 427,
+              "zlib_blocks": 427,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27317
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "7d4c96dab65308fcac02e0971eb24acda40c83bdf0f213aabb1f7f634d5ba5b4",
+            "table_sha256": "25d43cb46dc00061786907d19646096d7d17cbac7a69e70d20ccd23a33fb66e9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3691822250839323,
+          "representatives_sha256": "5b4650fa10885d37c0ca166e016822c9a5e5da800134c1f27d7ecca2ffcd8cdc",
+          "structurally_merged_rows": 9461,
+          "backend_artifact_bytes": 3535411,
+          "backend_with_key_registry_bytes": 4132932,
+          "backend_with_datrie_key_index_bytes": 3830371,
+          "full_model_serving_artifact_bytes": 4832930,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9513163194091709,
+            "mean_cosine": 0.999747462156296,
+            "p05_cosine": 0.9988418588909616,
+            "relative_l2_mean": 0.01050812330519457,
+            "relative_l2_p95": 0.04836003612999388,
+            "relative_l2_max": 0.311314808110222,
+            "weighted_relative_l2_mean": 0.002819016285307103,
+            "weighted_relative_frobenius": 0.01828155946369207,
+            "weighted_mean_cosine": 0.9999249770262345,
+            "max_relative_norm_change": 0.01010576944316186
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9513112397926677,
+            "mean_cosine": 0.999747472245378,
+            "p05_cosine": 0.9988421820784226,
+            "relative_l2_mean": 0.010354899471465413,
+            "relative_l2_p95": 0.048361269465342645,
+            "relative_l2_max": 0.31133352707774775,
+            "weighted_relative_l2_mean": 0.002716787097585304,
+            "weighted_relative_frobenius": 0.018280694607926192,
+            "weighted_mean_cosine": 0.999924984237895,
+            "max_relative_norm_change": 0.010098569885149627
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.426999,
+            "warm_p50_ms": 0.146143,
+            "warm_p95_ms": 0.1505288,
+            "warm_p99_ms": 0.17334230999999997,
+            "samples_ms": [
+              0.150438,
+              0.148133,
+              0.148553,
+              0.147156,
+              0.14527,
+              0.147156,
+              0.149531,
+              0.148064,
+              0.148063,
+              0.147575,
+              0.147086,
+              0.146736,
+              0.145689,
+              0.14527,
+              0.145689,
+              0.146597,
+              0.146178,
+              0.186825,
+              0.152254,
+              0.147086,
+              0.147086,
+              0.145201,
+              0.146178,
+              0.145689,
+              0.14527,
+              0.145689,
+              0.14527,
+              0.146248,
+              0.145759,
+              0.14527,
+              0.14534,
+              0.144781,
+              0.1452,
+              0.145689,
+              0.146108,
+              0.1452,
+              0.145689,
+              0.144781,
+              0.146667,
+              0.14527
+            ],
+            "warm_rows_per_second": 3503417.8852220085
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852123829611428,
+            "character_perplexity": 6.373341049254044,
+            "next_character_accuracy": 0.5019168839135102,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00039325727228118256,
+            "mean_prediction_kl_nats": 0.00012677548255543656,
+            "prediction_kl_p99_nats": 0.00013120910889351578,
+            "maximum_prediction_kl_nats": 0.12425860140083476,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.8884759545326233,
+            "maximum_per_target_cross_entropy_increase": 0.28847646713256836
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00039068146122587394,
+            "mean_prediction_kl_nats": 0.00012671646408585208,
+            "prediction_kl_p99_nats": 0.00013086450566998734,
+            "maximum_prediction_kl_nats": 0.12420780785095903,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.8883553147315979,
+            "maximum_per_target_cross_entropy_increase": 0.28856325149536133
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3531723,
+              "unique_rows": 27293,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 427,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 427,
+              "zlib_blocks": 427,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27293
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "1e479118a5075d1ef1b4218623a12cf99944f1bb3c6b655c7b32b9c58f19194e",
+            "table_sha256": "7c7a26b4b5b735fa1b933861cb29cc40cccc070092717cffc74dc36b0112039e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.36045743408612907,
+          "representatives_sha256": "e4ad195c6a7a47cd0145ade2e137180ae92aedf3b273b0e3f77e2acfd45d7c24",
+          "structurally_merged_rows": 9485,
+          "backend_artifact_bytes": 3532929,
+          "backend_with_key_registry_bytes": 4130450,
+          "backend_with_datrie_key_index_bytes": 3827889,
+          "full_model_serving_artifact_bytes": 4830448,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9000114158323158,
+            "mean_cosine": 0.9996845787112755,
+            "p05_cosine": 0.9988313432754199,
+            "relative_l2_mean": 0.010822072466038597,
+            "relative_l2_p95": 0.04865110429368451,
+            "relative_l2_max": 0.4457365469788921,
+            "weighted_relative_l2_mean": 0.0031921173076031014,
+            "weighted_relative_frobenius": 0.02396636485356996,
+            "weighted_mean_cosine": 0.9998498425719602,
+            "max_relative_norm_change": 0.01010576944316186
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9000173825782672,
+            "mean_cosine": 0.9996845898874618,
+            "p05_cosine": 0.998831055200147,
+            "relative_l2_mean": 0.010668983896081393,
+            "relative_l2_p95": 0.048643796092008695,
+            "relative_l2_max": 0.44572907924552096,
+            "weighted_relative_l2_mean": 0.003090102065101061,
+            "weighted_relative_frobenius": 0.023965896259199232,
+            "weighted_mean_cosine": 0.9998498482765686,
+            "max_relative_norm_change": 0.010098569885149627
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.418967,
+            "warm_p50_ms": 0.1464575,
+            "warm_p95_ms": 0.15809009999999996,
+            "warm_p99_ms": 0.19397468999999998,
+            "samples_ms": [
+              0.150927,
+              0.148971,
+              0.148552,
+              0.146667,
+              0.147155,
+              0.146178,
+              0.157493,
+              0.209664,
+              0.152953,
+              0.147644,
+              0.146667,
+              0.146667,
+              0.146667,
+              0.146178,
+              0.145689,
+              0.146667,
+              0.144711,
+              0.147155,
+              0.146667,
+              0.146178,
+              0.145759,
+              0.144781,
+              0.146248,
+              0.145759,
+              0.146247,
+              0.14527,
+              0.146737,
+              0.146248,
+              0.145759,
+              0.14527,
+              0.14527,
+              0.144781,
+              0.146248,
+              0.148552,
+              0.169435,
+              0.150438,
+              0.146667,
+              0.145689,
+              0.146248,
+              0.145201
+            ],
+            "warm_rows_per_second": 3495894.713483434
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8521540448173928,
+            "character_perplexity": 6.373533623975859,
+            "next_character_accuracy": 0.5019168839135102,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003630534923612783,
+            "mean_prediction_kl_nats": 0.00022589165931384048,
+            "prediction_kl_p99_nats": 0.0003547592823600955,
+            "maximum_prediction_kl_nats": 0.12425860140083476,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.0748991966247559,
+            "maximum_per_target_cross_entropy_increase": 0.6844158172607422
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003604776034761322,
+            "mean_prediction_kl_nats": 0.00022582647437277177,
+            "prediction_kl_p99_nats": 0.0003549476837928677,
+            "maximum_prediction_kl_nats": 0.12420780785095903,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.074732780456543,
+            "maximum_per_target_cross_entropy_increase": 0.6844334602355957
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2500904,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "825e9083d4fb773e7477d19b942e81d71aa7941df0d31375fb16b12950b6837f",
+            "table_sha256": "7971ce6013cd10940ea0859b9f441072b9e4740e2e29e5921eacca0a1b7e229b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05032146302983165,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2501752,
+          "backend_with_key_registry_bytes": 3099273,
+          "backend_with_datrie_key_index_bytes": 2796712,
+          "full_model_serving_artifact_bytes": 3799271,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999423853983437,
+            "mean_cosine": 0.9999882608898237,
+            "p05_cosine": 0.9999771263451054,
+            "relative_l2_mean": 0.0047384062543476555,
+            "relative_l2_p95": 0.006803712913917385,
+            "relative_l2_max": 0.010788400016504664,
+            "weighted_relative_l2_mean": 0.0030901968715466564,
+            "weighted_relative_frobenius": 0.005367400629039276,
+            "weighted_mean_cosine": 0.9999913956326278,
+            "max_relative_norm_change": 0.0030120548461313864
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.321759,
+            "warm_p50_ms": 0.096032,
+            "warm_p95_ms": 0.09845489999999998,
+            "warm_p99_ms": 0.11029019,
+            "samples_ms": [
+              0.098406,
+              0.097428,
+              0.096521,
+              0.095473,
+              0.095962,
+              0.09701,
+              0.097428,
+              0.096451,
+              0.095054,
+              0.096032,
+              0.094635,
+              0.095124,
+              0.096102,
+              0.094635,
+              0.096032,
+              0.099384,
+              0.097498,
+              0.095054,
+              0.096102,
+              0.095193,
+              0.095124,
+              0.095613,
+              0.094565,
+              0.095543,
+              0.095473,
+              0.096032,
+              0.098337,
+              0.096032,
+              0.117263,
+              0.095612,
+              0.094705,
+              0.097009,
+              0.096032,
+              0.096102,
+              0.096101,
+              0.096521,
+              0.096521,
+              0.095124,
+              0.096032,
+              0.095054
+            ],
+            "warm_rows_per_second": 5331556.147950683
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525349765882355,
+            "character_perplexity": 6.37596196791308,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.7812517247741032e-05,
+            "mean_prediction_kl_nats": 3.922783085973939e-06,
+            "prediction_kl_p99_nats": 3.02223781367696e-05,
+            "maximum_prediction_kl_nats": 7.174838273647961e-05,
+            "top1_changed_fraction": 0.0012268057046465265,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.03138601779937744,
+            "maximum_per_target_cross_entropy_increase": 0.03577136993408203
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802430,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 130,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "825e9083d4fb773e7477d19b942e81d71aa7941df0d31375fb16b12950b6837f",
+            "table_sha256": "c455ed4ebdc5a63b131ba6c6f986de04703fa0b5e64a378a46a5675bbbb32ab2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24732666602358222,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803683,
+          "backend_with_key_registry_bytes": 3401204,
+          "backend_with_datrie_key_index_bytes": 3098643,
+          "full_model_serving_artifact_bytes": 4101202,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999423853983437,
+            "mean_cosine": 0.9999882608898237,
+            "p05_cosine": 0.9999771263451054,
+            "relative_l2_mean": 0.0047384062543476555,
+            "relative_l2_p95": 0.006803712913917385,
+            "relative_l2_max": 0.010788400016504664,
+            "weighted_relative_l2_mean": 0.0030901968715466564,
+            "weighted_relative_frobenius": 0.005367400629039276,
+            "weighted_mean_cosine": 0.9999913956326278,
+            "max_relative_norm_change": 0.0030120548461313864
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.801046,
+            "warm_p50_ms": 0.114051,
+            "warm_p95_ms": 0.11917695,
+            "warm_p99_ms": 0.12750440999999998,
+            "samples_ms": [
+              0.119149,
+              0.116914,
+              0.114121,
+              0.113562,
+              0.115448,
+              0.116775,
+              0.113562,
+              0.115029,
+              0.115028,
+              0.113492,
+              0.114539,
+              0.114051,
+              0.114051,
+              0.113981,
+              0.11447,
+              0.113493,
+              0.11454,
+              0.113003,
+              0.113981,
+              0.113562,
+              0.112025,
+              0.114051,
+              0.117823,
+              0.113981,
+              0.113981,
+              0.112654,
+              0.113562,
+              0.113562,
+              0.113562,
+              0.112584,
+              0.119708,
+              0.114051,
+              0.132489,
+              0.11447,
+              0.113981,
+              0.113632,
+              0.11447,
+              0.114051,
+              0.115378,
+              0.112584
+            ],
+            "warm_rows_per_second": 4489219.73503082
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525349765882355,
+            "character_perplexity": 6.37596196791308,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.7812517247741032e-05,
+            "mean_prediction_kl_nats": 3.922783085973939e-06,
+            "prediction_kl_p99_nats": 3.02223781367696e-05,
+            "maximum_prediction_kl_nats": 7.174838273647961e-05,
+            "top1_changed_fraction": 0.0012268057046465265,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.03138601779937744,
+            "maximum_per_target_cross_entropy_increase": 0.03577136993408203
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802430,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 130,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "825e9083d4fb773e7477d19b942e81d71aa7941df0d31375fb16b12950b6837f",
+            "table_sha256": "c455ed4ebdc5a63b131ba6c6f986de04703fa0b5e64a378a46a5675bbbb32ab2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38247065991163254,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803682,
+          "backend_with_key_registry_bytes": 3401203,
+          "backend_with_datrie_key_index_bytes": 3098642,
+          "full_model_serving_artifact_bytes": 4101201,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999423853983437,
+            "mean_cosine": 0.9999882608898237,
+            "p05_cosine": 0.9999771263451054,
+            "relative_l2_mean": 0.0047384062543476555,
+            "relative_l2_p95": 0.006803712913917385,
+            "relative_l2_max": 0.010788400016504664,
+            "weighted_relative_l2_mean": 0.0030901968715466564,
+            "weighted_relative_frobenius": 0.005367400629039276,
+            "weighted_mean_cosine": 0.9999913956326278,
+            "max_relative_norm_change": 0.0030120548461313864
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.826677,
+            "warm_p50_ms": 0.11443500000000001,
+            "warm_p95_ms": 0.12597964999999997,
+            "warm_p99_ms": 0.14579478999999998,
+            "samples_ms": [
+              0.137658,
+              0.116355,
+              0.116426,
+              0.113562,
+              0.113562,
+              0.115867,
+              0.114959,
+              0.114959,
+              0.115937,
+              0.11447,
+              0.116356,
+              0.115029,
+              0.11454,
+              0.113562,
+              0.113562,
+              0.113073,
+              0.113562,
+              0.113562,
+              0.1144,
+              0.113003,
+              0.112514,
+              0.113492,
+              0.113563,
+              0.113981,
+              0.114051,
+              0.112235,
+              0.114959,
+              0.113143,
+              0.125365,
+              0.116356,
+              0.113562,
+              0.113981,
+              0.119708,
+              0.11447,
+              0.150997,
+              0.11447,
+              0.114959,
+              0.113562,
+              0.115378,
+              0.113982
+            ],
+            "warm_rows_per_second": 4474155.634202822
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525349765882355,
+            "character_perplexity": 6.37596196791308,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.7812517247741032e-05,
+            "mean_prediction_kl_nats": 3.922783085973939e-06,
+            "prediction_kl_p99_nats": 3.02223781367696e-05,
+            "maximum_prediction_kl_nats": 7.174838273647961e-05,
+            "top1_changed_fraction": 0.0012268057046465265,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.03138601779937744,
+            "maximum_per_target_cross_entropy_increase": 0.03577136993408203
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802430,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 130,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "825e9083d4fb773e7477d19b942e81d71aa7941df0d31375fb16b12950b6837f",
+            "table_sha256": "c455ed4ebdc5a63b131ba6c6f986de04703fa0b5e64a378a46a5675bbbb32ab2",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2969288320746273,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803682,
+          "backend_with_key_registry_bytes": 3401203,
+          "backend_with_datrie_key_index_bytes": 3098642,
+          "full_model_serving_artifact_bytes": 4101201,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999423853983437,
+            "mean_cosine": 0.9999882608898237,
+            "p05_cosine": 0.9999771263451054,
+            "relative_l2_mean": 0.0047384062543476555,
+            "relative_l2_p95": 0.006803712913917385,
+            "relative_l2_max": 0.010788400016504664,
+            "weighted_relative_l2_mean": 0.0030901968715466564,
+            "weighted_relative_frobenius": 0.005367400629039276,
+            "weighted_mean_cosine": 0.9999913956326278,
+            "max_relative_norm_change": 0.0030120548461313864
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.771224,
+            "warm_p50_ms": 0.114261,
+            "warm_p95_ms": 0.11787089999999999,
+            "warm_p99_ms": 0.13780088999999998,
+            "samples_ms": [
+              0.1188,
+              0.115937,
+              0.114959,
+              0.114401,
+              0.114959,
+              0.114958,
+              0.11447,
+              0.113562,
+              0.11447,
+              0.113911,
+              0.114051,
+              0.112724,
+              0.113073,
+              0.114121,
+              0.114959,
+              0.113493,
+              0.114051,
+              0.11447,
+              0.11447,
+              0.114539,
+              0.113073,
+              0.117822,
+              0.113632,
+              0.149949,
+              0.11447,
+              0.114051,
+              0.115867,
+              0.113562,
+              0.11447,
+              0.114401,
+              0.113073,
+              0.113143,
+              0.114051,
+              0.11454,
+              0.113562,
+              0.113492,
+              0.113004,
+              0.113003,
+              0.114959,
+              0.113563
+            ],
+            "warm_rows_per_second": 4480969.009548315
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525349765882355,
+            "character_perplexity": 6.37596196791308,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.7812517247741032e-05,
+            "mean_prediction_kl_nats": 3.922783085973939e-06,
+            "prediction_kl_p99_nats": 3.02223781367696e-05,
+            "maximum_prediction_kl_nats": 7.174838273647961e-05,
+            "top1_changed_fraction": 0.0012268057046465265,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.03138601779937744,
+            "maximum_per_target_cross_entropy_increase": 0.03577136993408203
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2159553,
+              "unique_rows": 27372,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 58,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27372
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "bd98a4599f4a90cead3e90ca3b7aabff1968d2f9f4a281441f297c467992bbef",
+            "table_sha256": "489b9f9de01d8abe5f50495510ba00a43233e4069b495e950ff93e3c268d70e5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21825729892589152,
+          "representatives_sha256": "ee823010b22da96364634aa24fdb0332bd7e63e2a18483df332a03c9f0e4e861",
+          "structurally_merged_rows": 9406,
+          "backend_artifact_bytes": 2160803,
+          "backend_with_key_registry_bytes": 2758324,
+          "backend_with_datrie_key_index_bytes": 2455763,
+          "full_model_serving_artifact_bytes": 3458322,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901936823909471,
+            "mean_cosine": 0.9997707398036456,
+            "p05_cosine": 0.9988471744883699,
+            "relative_l2_mean": 0.01370286698712146,
+            "relative_l2_p95": 0.04818096490309023,
+            "relative_l2_max": 0.13970731928662025,
+            "weighted_relative_l2_mean": 0.005253370717849569,
+            "weighted_relative_frobenius": 0.012475970273467448,
+            "weighted_mean_cosine": 0.9999434089752636,
+            "max_relative_norm_change": 0.01100592058332153
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900201496082667,
+            "mean_cosine": 0.999777006668141,
+            "p05_cosine": 0.9988339063736171,
+            "relative_l2_mean": 0.01018436070719559,
+            "relative_l2_p95": 0.04850662653422283,
+            "relative_l2_max": 0.14093234220233247,
+            "weighted_relative_l2_mean": 0.0025508588944308784,
+            "weighted_relative_frobenius": 0.011543854934588026,
+            "weighted_mean_cosine": 0.9999501476197958,
+            "max_relative_norm_change": 0.010088626688142067
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.299713,
+            "warm_p50_ms": 0.109057,
+            "warm_p95_ms": 0.11356884999999999,
+            "warm_p99_ms": 0.13028083,
+            "samples_ms": [
+              0.113492,
+              0.111676,
+              0.109651,
+              0.109791,
+              0.109232,
+              0.110699,
+              0.10979,
+              0.109232,
+              0.110769,
+              0.109302,
+              0.11021,
+              0.108882,
+              0.108324,
+              0.108394,
+              0.108813,
+              0.11028,
+              0.108323,
+              0.109791,
+              0.108813,
+              0.107835,
+              0.109721,
+              0.107835,
+              0.107836,
+              0.11021,
+              0.11028,
+              0.108813,
+              0.108324,
+              0.109791,
+              0.108813,
+              0.108324,
+              0.108324,
+              0.109791,
+              0.107416,
+              0.140032,
+              0.115029,
+              0.107416,
+              0.108324,
+              0.108254,
+              0.108394,
+              0.108743
+            ],
+            "warm_rows_per_second": 4694792.6313762525
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852623154194073,
+            "character_perplexity": 6.376524209762526,
+            "next_character_accuracy": 0.5016101824873486,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00010599558157896495,
+            "mean_prediction_kl_nats": 1.0218319596541971e-05,
+            "prediction_kl_p99_nats": 0.00012016061647095144,
+            "maximum_prediction_kl_nats": 0.000566337115838136,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.23667526245117188,
+            "maximum_per_target_cross_entropy_increase": 0.06543993949890137
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 8.818149359684829e-05,
+            "mean_prediction_kl_nats": 6.195150129714561e-06,
+            "prediction_kl_p99_nats": 0.0001115058126726823,
+            "maximum_prediction_kl_nats": 0.0005962701972969846,
+            "top1_changed_fraction": 0.0006134028523232633,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.23351335525512695,
+            "maximum_per_target_cross_entropy_increase": 0.06547760963439941
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2158281,
+              "unique_rows": 27354,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 54,
+              "compressed_blocks": 174,
+              "zlib_blocks": 174,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27354
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "121b91d816b17acd3e8c8ac010f3e4a7ebaa64edf50d3f714101c59e309c0e86",
+            "table_sha256": "88d3e18197a954cafaa5e43f8509d538120223f6adb2098aec19f4ff18320483",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22241418599151075,
+          "representatives_sha256": "c55543f234ecf51aa35da166c68b43c7be495da8eef77faab73ad37db8ca1643",
+          "structurally_merged_rows": 9424,
+          "backend_artifact_bytes": 2159531,
+          "backend_with_key_registry_bytes": 2757052,
+          "backend_with_datrie_key_index_bytes": 2454491,
+          "full_model_serving_artifact_bytes": 3457050,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9803841974692542,
+            "mean_cosine": 0.99976350324125,
+            "p05_cosine": 0.9988431736660357,
+            "relative_l2_mean": 0.01378569874972075,
+            "relative_l2_p95": 0.04830936413209999,
+            "relative_l2_max": 0.19914099783926265,
+            "weighted_relative_l2_mean": 0.005332148767566714,
+            "weighted_relative_frobenius": 0.014300160532346706,
+            "weighted_mean_cosine": 0.9999364576676586,
+            "max_relative_norm_change": 0.01100592058332153
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.980402063783619,
+            "mean_cosine": 0.9997697652136252,
+            "p05_cosine": 0.9988288715392164,
+            "relative_l2_mean": 0.010269748863580546,
+            "relative_l2_p95": 0.048580357032820674,
+            "relative_l2_max": 0.1991238828124796,
+            "weighted_relative_l2_mean": 0.002632430675154758,
+            "weighted_relative_frobenius": 0.013510576247234417,
+            "weighted_mean_cosine": 0.999943160807779,
+            "max_relative_norm_change": 0.010088626688142067
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.15165,
+            "warm_p50_ms": 0.11045450000000001,
+            "warm_p95_ms": 0.11361089999999999,
+            "warm_p99_ms": 0.12399804999999998,
+            "samples_ms": [
+              0.113562,
+              0.112236,
+              0.113562,
+              0.111746,
+              0.11014,
+              0.11021,
+              0.11028,
+              0.110629,
+              0.111117,
+              0.111187,
+              0.108813,
+              0.110629,
+              0.11028,
+              0.10979,
+              0.110698,
+              0.130045,
+              0.110768,
+              0.110279,
+              0.111746,
+              0.111187,
+              0.111118,
+              0.110769,
+              0.11454,
+              0.110279,
+              0.107905,
+              0.110768,
+              0.109302,
+              0.109232,
+              0.110769,
+              0.108813,
+              0.110209,
+              0.107835,
+              0.108882,
+              0.110699,
+              0.109721,
+              0.109791,
+              0.112165,
+              0.110209,
+              0.10979,
+              0.109791
+            ],
+            "warm_rows_per_second": 4635392.854071133
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525341141760467,
+            "character_perplexity": 6.375956469208134,
+            "next_character_accuracy": 0.5018402085569698,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.6950090069191802e-05,
+            "mean_prediction_kl_nats": 2.6299175439423748e-05,
+            "prediction_kl_p99_nats": 0.00013393714038067466,
+            "maximum_prediction_kl_nats": 0.03291117008090324,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.35282444953918457,
+            "maximum_per_target_cross_entropy_increase": 0.2796969413757324
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -8.624118168238675e-07,
+            "mean_prediction_kl_nats": 2.1991440496527458e-05,
+            "prediction_kl_p99_nats": 0.00011574609366350268,
+            "maximum_prediction_kl_nats": 0.0329851882669773,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.35393357276916504,
+            "maximum_per_target_cross_entropy_increase": 0.28632402420043945
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2157615,
+              "unique_rows": 27344,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 57,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27344
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "7c3e9a58c57a7130ed4bc6689968425ec271ab2704ee9b2a41e1f66c4e7717c5",
+            "table_sha256": "2feedd457e94ec3fb748a014d1832bf8ab40ce1343fe543ca6ba8db74bbbd404",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21872844803147018,
+          "representatives_sha256": "ed6c53830fcf065d41f20f69996586e097443ff3194041894a9d84046c3704e4",
+          "structurally_merged_rows": 9434,
+          "backend_artifact_bytes": 2158865,
+          "backend_with_key_registry_bytes": 2756386,
+          "backend_with_datrie_key_index_bytes": 2453825,
+          "full_model_serving_artifact_bytes": 3456384,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9709833361988419,
+            "mean_cosine": 0.9997537322133385,
+            "p05_cosine": 0.9988391669088803,
+            "relative_l2_mean": 0.013869420282903912,
+            "relative_l2_p95": 0.048450114957389066,
+            "relative_l2_max": 0.2415260799662704,
+            "weighted_relative_l2_mean": 0.005368595776662369,
+            "weighted_relative_frobenius": 0.015593640901344548,
+            "weighted_mean_cosine": 0.9999321681835488,
+            "max_relative_norm_change": 0.01100592058332153
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9709638081310338,
+            "mean_cosine": 0.999759985730253,
+            "p05_cosine": 0.9988257447836826,
+            "relative_l2_mean": 0.010354703942669713,
+            "relative_l2_p95": 0.04866831910058303,
+            "relative_l2_max": 0.24158341386608242,
+            "weighted_relative_l2_mean": 0.0026695630853409,
+            "weighted_relative_frobenius": 0.014868980379677798,
+            "weighted_mean_cosine": 0.9999388807722678,
+            "max_relative_norm_change": 0.010088626688142067
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.157237,
+            "warm_p50_ms": 0.11024500000000001,
+            "warm_p95_ms": 0.11379949999999998,
+            "warm_p99_ms": 0.1209106,
+            "samples_ms": [
+              0.118312,
+              0.113492,
+              0.113562,
+              0.111676,
+              0.111187,
+              0.111188,
+              0.111187,
+              0.10986,
+              0.110628,
+              0.111188,
+              0.11028,
+              0.110699,
+              0.109721,
+              0.110768,
+              0.122572,
+              0.111258,
+              0.108743,
+              0.110768,
+              0.111117,
+              0.109791,
+              0.11021,
+              0.111187,
+              0.109301,
+              0.112165,
+              0.109232,
+              0.109721,
+              0.10979,
+              0.109232,
+              0.111258,
+              0.108813,
+              0.107905,
+              0.10979,
+              0.108882,
+              0.109791,
+              0.11014,
+              0.110349,
+              0.108743,
+              0.109861,
+              0.108324,
+              0.108394
+            ],
+            "warm_rows_per_second": 4644201.551090752
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8525229937301986,
+            "character_perplexity": 6.375885566123726,
+            "next_character_accuracy": 0.5018402085569698,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 5.829517561522718e-06,
+            "mean_prediction_kl_nats": 3.125478532769563e-05,
+            "prediction_kl_p99_nats": 0.00013693641873771206,
+            "maximum_prediction_kl_nats": 0.04956129816142537,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.737525463104248,
+            "maximum_per_target_cross_entropy_increase": 0.2796969413757324
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -1.1982786242631691e-05,
+            "mean_prediction_kl_nats": 2.6956319617727833e-05,
+            "prediction_kl_p99_nats": 0.00012046420390634976,
+            "maximum_prediction_kl_nats": 0.049577409481285674,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.741180419921875,
+            "maximum_per_target_cross_entropy_increase": 0.28632402420043945
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2156785,
+              "unique_rows": 27332,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 53,
+              "compressed_blocks": 175,
+              "zlib_blocks": 175,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27332
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "ea8e9c923a52ba3548854b19f21826cba3cfc333f25192406250623d413a6dc5",
+            "table_sha256": "93986663112648d6711b10d225f692e834dfe6ebcea5624bfc857368f33a39ad",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2166988591197878,
+          "representatives_sha256": "bdfc2ff5485bc8159dfea7f07b84d9fe9fea0769fdc0dc012e2f75b5d5e28045",
+          "structurally_merged_rows": 9446,
+          "backend_artifact_bytes": 2158035,
+          "backend_with_key_registry_bytes": 2755556,
+          "backend_with_datrie_key_index_bytes": 2452995,
+          "full_model_serving_artifact_bytes": 3455554,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9511665284852492,
+            "mean_cosine": 0.9997352426815083,
+            "p05_cosine": 0.9988325331385304,
+            "relative_l2_mean": 0.013997645638866652,
+            "relative_l2_p95": 0.04860716272042506,
+            "relative_l2_max": 0.31180209459341773,
+            "weighted_relative_l2_mean": 0.00548975913955002,
+            "weighted_relative_frobenius": 0.01916368741803261,
+            "weighted_mean_cosine": 0.9999153705346492,
+            "max_relative_norm_change": 0.01100592058332153
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9508873098418595,
+            "mean_cosine": 0.9997414245304309,
+            "p05_cosine": 0.9988216621684859,
+            "relative_l2_mean": 0.010484797159271605,
+            "relative_l2_p95": 0.04876521079590782,
+            "relative_l2_max": 0.3126990872022993,
+            "weighted_relative_l2_mean": 0.002793320906186573,
+            "weighted_relative_frobenius": 0.018629382528077235,
+            "weighted_mean_cosine": 0.9999218470723966,
+            "max_relative_norm_change": 0.010088626688142067
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.028589,
+            "warm_p50_ms": 0.11,
+            "warm_p95_ms": 0.11365629999999999,
+            "warm_p99_ms": 0.13219127999999997,
+            "samples_ms": [
+              0.115448,
+              0.111118,
+              0.112585,
+              0.111188,
+              0.109791,
+              0.113073,
+              0.111118,
+              0.110698,
+              0.110279,
+              0.111117,
+              0.11021,
+              0.11035,
+              0.108324,
+              0.108813,
+              0.109791,
+              0.111606,
+              0.111746,
+              0.110209,
+              0.109721,
+              0.108813,
+              0.108812,
+              0.109302,
+              0.109721,
+              0.108813,
+              0.108813,
+              0.10979,
+              0.109232,
+              0.109372,
+              0.109302,
+              0.110699,
+              0.109791,
+              0.110629,
+              0.10979,
+              0.109721,
+              0.142896,
+              0.113562,
+              0.11035,
+              0.111607,
+              0.108394,
+              0.108813
+            ],
+            "warm_rows_per_second": 4654545.454545454
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8521772767588605,
+            "character_perplexity": 6.3736816952559385,
+            "next_character_accuracy": 0.5020702346265911,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003398297155654553,
+            "mean_prediction_kl_nats": 0.00013342371873271348,
+            "prediction_kl_p99_nats": 0.00014980814582011523,
+            "maximum_prediction_kl_nats": 0.12502342394746385,
+            "top1_changed_fraction": 0.002376936052752645,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.8871172070503235,
+            "maximum_per_target_cross_entropy_increase": 0.2796969413757324
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003576358624182286,
+            "mean_prediction_kl_nats": 0.00012999157531167803,
+            "prediction_kl_p99_nats": 0.00014307763126692507,
+            "maximum_prediction_kl_nats": 0.12617057049907654,
+            "top1_changed_fraction": 0.0013034810611869344,
+            "accuracy_change": 0.000460052139242495,
+            "maximum_absolute_logit_change": 0.8878851532936096,
+            "maximum_per_target_cross_entropy_increase": 0.28632402420043945
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2155118,
+              "unique_rows": 27307,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 52,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27307
+            },
+            "source_float32_sha256": "23fef795d559ef2b26b5103ab065e1c40248974ddd5afae0b8d0d0e33b95942a",
+            "decoded_float32_sha256": "56eea6ba9d9e03d7f3c3f40ee73d05807f60a8149404c5e42586e401ba51e21b",
+            "table_sha256": "3238854efa156d42be7bdcb48de9dccedcb24f755e8e3c2ce154d71cbdd17de1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21731388196349144,
+          "representatives_sha256": "ae1c126285926ec3a37278faaedcc33c201df3c5bea4cbfac3adbc753b12b51c",
+          "structurally_merged_rows": 9471,
+          "backend_artifact_bytes": 2156368,
+          "backend_with_key_registry_bytes": 2753889,
+          "backend_with_datrie_key_index_bytes": 2451328,
+          "full_model_serving_artifact_bytes": 3453887,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9002791692838276,
+            "mean_cosine": 0.9996697757800215,
+            "p05_cosine": 0.9988203220304905,
+            "relative_l2_mean": 0.014320318924229457,
+            "relative_l2_p95": 0.04885864608503015,
+            "relative_l2_max": 0.445566953706329,
+            "weighted_relative_l2_mean": 0.005858387832668077,
+            "weighted_relative_frobenius": 0.024652605165551348,
+            "weighted_mean_cosine": 0.9998401080404868,
+            "max_relative_norm_change": 0.0113042873169545
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9007489979693729,
+            "mean_cosine": 0.9996758896490945,
+            "p05_cosine": 0.9988132913388617,
+            "relative_l2_mean": 0.010810970940916554,
+            "relative_l2_p95": 0.048995893370770364,
+            "relative_l2_max": 0.44674244837039334,
+            "weighted_relative_l2_mean": 0.0031668512815220123,
+            "weighted_relative_frobenius": 0.024233944025561935,
+            "weighted_mean_cosine": 0.9998466319447397,
+            "max_relative_norm_change": 0.010088626688142067
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.211713,
+            "warm_p50_ms": 0.1097205,
+            "warm_p95_ms": 0.1126783,
+            "warm_p99_ms": 0.13611279999999998,
+            "samples_ms": [
+              0.112584,
+              0.110699,
+              0.111188,
+              0.111257,
+              0.111258,
+              0.14995,
+              0.110769,
+              0.110699,
+              0.11021,
+              0.111187,
+              0.10986,
+              0.112165,
+              0.108323,
+              0.11447,
+              0.108882,
+              0.109302,
+              0.11021,
+              0.110769,
+              0.109301,
+              0.109232,
+              0.109791,
+              0.108812,
+              0.107905,
+              0.109301,
+              0.109302,
+              0.110629,
+              0.109791,
+              0.110768,
+              0.108813,
+              0.108813,
+              0.107835,
+              0.107835,
+              0.108324,
+              0.109302,
+              0.109651,
+              0.108324,
+              0.108813,
+              0.10979,
+              0.109232,
+              0.109302
+            ],
+            "warm_rows_per_second": 4666402.358720567
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.852207039291068,
+            "character_perplexity": 6.373871394985632,
+            "next_character_accuracy": 0.5019935592700506,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003100768547929411,
+            "mean_prediction_kl_nats": 0.00023291380840749926,
+            "prediction_kl_p99_nats": 0.00037058985748242746,
+            "maximum_prediction_kl_nats": 0.12502342394746385,
+            "top1_changed_fraction": 0.002836988191995093,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.0748310089111328,
+            "maximum_per_target_cross_entropy_increase": 0.6846189498901367
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00032788353160962004,
+            "mean_prediction_kl_nats": 0.00022920314508750436,
+            "prediction_kl_p99_nats": 0.0003665996871860343,
+            "maximum_prediction_kl_nats": 0.12617057049907654,
+            "top1_changed_fraction": 0.001763533200429382,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 1.0692188739776611,
+            "maximum_per_target_cross_entropy_increase": 0.6830034255981445
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.8525171642296288,
+          "character_perplexity": 6.375848398003521,
+          "next_character_accuracy": 0.5017635332004294,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7264914504842404,
+          "character_perplexity": 5.620898072320001,
+          "next_character_accuracy": 0.5251092540059802,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.97",
+          "backend_with_key_registry_bytes": 7425813,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7263920138538618,
+            "character_perplexity": 5.620339176943785,
+            "next_character_accuracy": 0.5251859234838611,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -9.943168672067081e-05,
+            "mean_prediction_kl_nats": 3.599514161387495e-05,
+            "prediction_kl_p99_nats": 0.00012654597219580023,
+            "maximum_prediction_kl_nats": 0.04607604998831831,
+            "top1_changed_fraction": 0.0013033811239745456,
+            "accuracy_change": 7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.7387614250183105,
+            "maximum_per_target_cross_entropy_increase": 0.36521947383880615
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00019782683373067314,
+              4.029123812401072e-06
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.97",
+          "backend_with_key_registry_bytes": 4134227,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.726390375275437,
+            "character_perplexity": 5.620329967584816,
+            "next_character_accuracy": 0.5251859234838611,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -0.00010107010087641331,
+            "mean_prediction_kl_nats": 3.6004410187967044e-05,
+            "prediction_kl_p99_nats": 0.00012695645761842848,
+            "maximum_prediction_kl_nats": 0.04610446029724359,
+            "top1_changed_fraction": 0.0013033811239745456,
+            "accuracy_change": 7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.739013671875,
+            "maximum_per_target_cross_entropy_increase": 0.36529219150543213
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0001983225788790956,
+              1.5536949280217424e-06
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.97",
+          "backend_with_key_registry_bytes": 2756386,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7263646895656914,
+            "character_perplexity": 5.6201856072746,
+            "next_character_accuracy": 0.5252625929617419,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -0.00012675288472309662,
+            "mean_prediction_kl_nats": 3.98149611035077e-05,
+            "prediction_kl_p99_nats": 0.0001327648061789036,
+            "maximum_prediction_kl_nats": 0.045853842864706854,
+            "top1_changed_fraction": 0.0018400674691405351,
+            "accuracy_change": 0.00015333895576175038,
+            "maximum_absolute_logit_change": 0.7336316108703613,
+            "maximum_per_target_cross_entropy_increase": 0.36336004734039307
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0002373574082006347,
+              -1.4517555775323528e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7264897442538625,
+            "character_perplexity": 5.620888481781141,
+            "next_character_accuracy": 0.5251092540059802,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.70622892227715e-06,
+            "mean_prediction_kl_nats": 3.9210284471012125e-09,
+            "prediction_kl_p99_nats": 2.915575772916698e-08,
+            "maximum_prediction_kl_nats": 9.294681676850027e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011017322540283203,
+            "maximum_per_target_cross_entropy_increase": 0.0009131431579589844
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.726475467567206,
+            "character_perplexity": 5.620808234690389,
+            "next_character_accuracy": 0.5250325845280993,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.5982789308212916e-05,
+            "mean_prediction_kl_nats": 3.616042494524373e-06,
+            "prediction_kl_p99_nats": 2.9782866738580935e-05,
+            "maximum_prediction_kl_nats": 9.914208261234641e-05,
+            "top1_changed_fraction": 0.0005366863451659894,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.031708717346191406,
+            "maximum_per_target_cross_entropy_increase": 0.021615982055664062
+          }
+        }
+      },
+      "checkpoint_sha256": "f773d277a5444631a7ca1865880469f92d01fd664f4da9363621026ccd307845",
+      "registry_sha256": "e22a7692100a89679e3088226c3399678ae46a06d73d93bef7d898aa00f6fb7c"
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "rows": 36778,
+      "dim": 64,
+      "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+      "source_float32_bytes": 9415168,
+      "key_registry_bytes": 597521,
+      "unchanged_backbone_artifact_bytes": 699998,
+      "alternative_datrie_key_index_bytes": 294960,
+      "query_rows": 512,
+      "query_ids_sha256": "c0a9c7f836d519eda638b9a28093508b2d62873b170686d55b9ec727411573db",
+      "frequency_trace_sha256": "efa6b79677263433708f5d18746f076a51a377d034e599be829419ac6115bd49",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 9415168,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "table_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.04457491612993181,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9415972,
+          "backend_with_key_registry_bytes": 10013493,
+          "backend_with_datrie_key_index_bytes": 9710932,
+          "full_model_serving_artifact_bytes": 10713491,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.31226,
+            "warm_p50_ms": 0.047771,
+            "warm_p95_ms": 0.0491715,
+            "warm_p99_ms": 0.049834579999999996,
+            "samples_ms": [
+              0.049238,
+              0.04833,
+              0.048749,
+              0.04875,
+              0.047283,
+              0.047213,
+              0.046793,
+              0.04826,
+              0.046863,
+              0.046794,
+              0.048191,
+              0.046794,
+              0.04826,
+              0.04826,
+              0.045467,
+              0.04826,
+              0.04826,
+              0.047771,
+              0.047282,
+              0.048261,
+              0.047353,
+              0.048331,
+              0.047283,
+              0.047213,
+              0.045886,
+              0.046793,
+              0.047702,
+              0.047772,
+              0.047283,
+              0.046305,
+              0.047842,
+              0.04875,
+              0.047772,
+              0.050216,
+              0.046863,
+              0.047771,
+              0.049168,
+              0.047353,
+              0.047283,
+              0.047772
+            ],
+            "warm_rows_per_second": 10717799.501789788
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853825927869258,
+            "character_perplexity": 6.384198339416614,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9081798,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "table_sha256": "960fa1563e78af85b221076d89eb9f0ecd65b332bd4ee2659401acca84f40fbb",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.7745489759836346,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083008,
+          "backend_with_key_registry_bytes": 9680529,
+          "backend_with_datrie_key_index_bytes": 9377968,
+          "full_model_serving_artifact_bytes": 10380527,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.499553,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.060066549999999996,
+            "warm_p99_ms": 0.07278662,
+            "samples_ms": [
+              0.060134,
+              0.058807,
+              0.05727,
+              0.058178,
+              0.055873,
+              0.056712,
+              0.055803,
+              0.055803,
+              0.056222,
+              0.056292,
+              0.054965,
+              0.056851,
+              0.05727,
+              0.059644,
+              0.058666,
+              0.057759,
+              0.055803,
+              0.059156,
+              0.058178,
+              0.055803,
+              0.056292,
+              0.054406,
+              0.056292,
+              0.055804,
+              0.055804,
+              0.055803,
+              0.055803,
+              0.056781,
+              0.055873,
+              0.056292,
+              0.055384,
+              0.055454,
+              0.056781,
+              0.056292,
+              0.057689,
+              0.056711,
+              0.055873,
+              0.060063,
+              0.080876,
+              0.058178
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853825927869258,
+            "character_perplexity": 6.384198339416614,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9081798,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "table_sha256": "960fa1563e78af85b221076d89eb9f0ecd65b332bd4ee2659401acca84f40fbb",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9328933600336313,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083007,
+          "backend_with_key_registry_bytes": 9680528,
+          "backend_with_datrie_key_index_bytes": 9377967,
+          "full_model_serving_artifact_bytes": 10380526,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.521344,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.05999669999999998,
+            "warm_p99_ms": 0.09123768999999997,
+            "samples_ms": [
+              0.059644,
+              0.059086,
+              0.059225,
+              0.056292,
+              0.056362,
+              0.056362,
+              0.056781,
+              0.055873,
+              0.056292,
+              0.058597,
+              0.056781,
+              0.056781,
+              0.056292,
+              0.106927,
+              0.066698,
+              0.057689,
+              0.056223,
+              0.056292,
+              0.055873,
+              0.054476,
+              0.056781,
+              0.057689,
+              0.056781,
+              0.056292,
+              0.056292,
+              0.054756,
+              0.055314,
+              0.054895,
+              0.054755,
+              0.054825,
+              0.055314,
+              0.055803,
+              0.055804,
+              0.05727,
+              0.056781,
+              0.055873,
+              0.056851,
+              0.056781,
+              0.055803,
+              0.056292
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853825927869258,
+            "character_perplexity": 6.384198339416614,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 9081798,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1150,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1150,
+              "zlib_blocks": 1150,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "table_sha256": "960fa1563e78af85b221076d89eb9f0ecd65b332bd4ee2659401acca84f40fbb",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.791637617861852,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 9083007,
+          "backend_with_key_registry_bytes": 9680528,
+          "backend_with_datrie_key_index_bytes": 9377967,
+          "full_model_serving_artifact_bytes": 10380526,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.503324,
+            "warm_p50_ms": 0.0572,
+            "warm_p95_ms": 0.0601584,
+            "warm_p99_ms": 0.08281867999999998,
+            "samples_ms": [
+              0.060064,
+              0.057689,
+              0.058597,
+              0.056362,
+              0.056781,
+              0.055803,
+              0.060622,
+              0.058177,
+              0.05727,
+              0.057828,
+              0.05727,
+              0.057269,
+              0.0572,
+              0.056711,
+              0.055804,
+              0.056851,
+              0.0572,
+              0.057759,
+              0.057759,
+              0.055803,
+              0.055873,
+              0.055873,
+              0.055803,
+              0.09701,
+              0.058178,
+              0.0572,
+              0.060063,
+              0.056292,
+              0.058178,
+              0.055873,
+              0.055314,
+              0.058248,
+              0.060134,
+              0.060064,
+              0.058178,
+              0.055803,
+              0.056292,
+              0.056293,
+              0.055873,
+              0.056851
+            ],
+            "warm_rows_per_second": 8951048.951048952
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853825927869258,
+            "character_perplexity": 6.384198339416614,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6839176,
+              "unique_rows": 27379,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 856,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 856,
+              "zlib_blocks": 856,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27379
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "7b499bfa05f48b7e1c31f10149e4d29e810350961ea1f67e55e4d8542b296adc",
+            "table_sha256": "666c1328a1d134210be3c20b41c22616a8ee49866e8e7decdd3981323cd472d1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6203860640525818,
+          "representatives_sha256": "d2c58fe5024e67300a190b5313bddd70ad42ec3afe185e3362dbb3ce52f03d93",
+          "structurally_merged_rows": 9399,
+          "backend_artifact_bytes": 6840382,
+          "backend_with_key_registry_bytes": 7437903,
+          "backend_with_datrie_key_index_bytes": 7135342,
+          "full_model_serving_artifact_bytes": 8137901,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900606923999148,
+            "mean_cosine": 0.9997784576355798,
+            "p05_cosine": 0.998848116220339,
+            "relative_l2_mean": 0.01010489966444938,
+            "relative_l2_p95": 0.048224850651301776,
+            "relative_l2_max": 0.14115591128178223,
+            "weighted_relative_l2_mean": 0.002516309229029448,
+            "weighted_relative_frobenius": 0.011360509821225311,
+            "weighted_mean_cosine": 0.9999512639366307,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900606923999148,
+            "mean_cosine": 0.9997784576355798,
+            "p05_cosine": 0.998848116220339,
+            "relative_l2_mean": 0.01010489966444938,
+            "relative_l2_p95": 0.048224850651301776,
+            "relative_l2_max": 0.14115591128178223,
+            "weighted_relative_l2_mean": 0.002516309229029448,
+            "weighted_relative_frobenius": 0.011360509821225311,
+            "weighted_mean_cosine": 0.9999512639366307,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.131,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.06111434999999999,
+            "warm_p99_ms": 0.07000611999999999,
+            "samples_ms": [
+              0.062508,
+              0.061041,
+              0.059156,
+              0.059156,
+              0.0572,
+              0.056781,
+              0.058108,
+              0.056292,
+              0.055803,
+              0.056711,
+              0.056223,
+              0.056292,
+              0.055803,
+              0.055314,
+              0.056362,
+              0.056292,
+              0.055873,
+              0.0748,
+              0.056781,
+              0.054895,
+              0.055314,
+              0.055873,
+              0.056292,
+              0.055874,
+              0.055873,
+              0.055873,
+              0.056781,
+              0.056293,
+              0.056292,
+              0.055314,
+              0.056292,
+              0.056781,
+              0.056292,
+              0.055873,
+              0.058667,
+              0.059644,
+              0.058178,
+              0.056781,
+              0.056292,
+              0.056362
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539171709741622,
+            "character_perplexity": 6.384780880071433,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.124726768285843e-05,
+            "mean_prediction_kl_nats": 7.857263138507182e-06,
+            "prediction_kl_p99_nats": 0.00010876512622539034,
+            "maximum_prediction_kl_nats": 0.0054869359999785315,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.10682880878448486
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.124726768285843e-05,
+            "mean_prediction_kl_nats": 7.857263138507182e-06,
+            "prediction_kl_p99_nats": 0.00010876512622539034,
+            "maximum_prediction_kl_nats": 0.0054869359999785315,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.10682880878448486
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6836039,
+              "unique_rows": 27366,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 856,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 856,
+              "zlib_blocks": 856,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27366
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "0b61fee666a805d5857209965801405cb41299b40a5bd43f939b298d1e2be6d1",
+            "table_sha256": "63c82cd7343837b95fd33d1a151079fd56a99eb850266b5aa9b6bde7879075f9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6236524749547243,
+          "representatives_sha256": "11886570fc035d70d87f25334b52f1d14537fddee3ed7a4239958fb4d236f4a7",
+          "structurally_merged_rows": 9412,
+          "backend_artifact_bytes": 6837245,
+          "backend_with_key_registry_bytes": 7434766,
+          "backend_with_datrie_key_index_bytes": 7132205,
+          "full_model_serving_artifact_bytes": 8134764,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9809576293463765,
+            "mean_cosine": 0.9997725672015289,
+            "p05_cosine": 0.9988457547530647,
+            "relative_l2_mean": 0.010172216018393514,
+            "relative_l2_p95": 0.04829450850377814,
+            "relative_l2_max": 0.1950679758979058,
+            "weighted_relative_l2_mean": 0.0025796313919513427,
+            "weighted_relative_frobenius": 0.012457324903073863,
+            "weighted_mean_cosine": 0.9999459192235313,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9809576293463765,
+            "mean_cosine": 0.9997725672015289,
+            "p05_cosine": 0.9988457547530647,
+            "relative_l2_mean": 0.010172216018393514,
+            "relative_l2_p95": 0.04829450850377814,
+            "relative_l2_max": 0.1950679758979058,
+            "weighted_relative_l2_mean": 0.0025796313919513427,
+            "weighted_relative_frobenius": 0.012457324903073863,
+            "weighted_mean_cosine": 0.9999459192235313,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.846187,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.0606649,
+            "warm_p99_ms": 0.06640261,
+            "samples_ms": [
+              0.061461,
+              0.060623,
+              0.059575,
+              0.060622,
+              0.058177,
+              0.059156,
+              0.058667,
+              0.0572,
+              0.056292,
+              0.055384,
+              0.069562,
+              0.058247,
+              0.0572,
+              0.057201,
+              0.055384,
+              0.055384,
+              0.055384,
+              0.055384,
+              0.054965,
+              0.055873,
+              0.055384,
+              0.055873,
+              0.055384,
+              0.057689,
+              0.057689,
+              0.056222,
+              0.055873,
+              0.056851,
+              0.055384,
+              0.055873,
+              0.055384,
+              0.055384,
+              0.055873,
+              0.055315,
+              0.055384,
+              0.055803,
+              0.055803,
+              0.054406,
+              0.055873,
+              0.054476
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853967702354528,
+            "character_perplexity": 6.3851035200142885,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.000141784535747201,
+            "mean_prediction_kl_nats": 1.1384415248378461e-05,
+            "prediction_kl_p99_nats": 0.00012439289968876123,
+            "maximum_prediction_kl_nats": 0.00827237447897241,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.5608301162719727
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.000141784535747201,
+            "mean_prediction_kl_nats": 1.1384415248378461e-05,
+            "prediction_kl_p99_nats": 0.00012439289968876123,
+            "maximum_prediction_kl_nats": 0.00827237447897241,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.5608301162719727
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6833584,
+              "unique_rows": 27356,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27356
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "340970ca40a2cbc3bb86a8ec96c731b51e67bc4586f55202758eebaa23a3516f",
+            "table_sha256": "584b01d501784e587d59853bd4ef104247034ea52bb5ab199301e5fadfa9e8f6",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6324292970821261,
+          "representatives_sha256": "37d324b2c4872e3e4580f040ba77d1bb6d678c92d38bfa9a8c0c660a6bc22abf",
+          "structurally_merged_rows": 9422,
+          "backend_artifact_bytes": 6834790,
+          "backend_with_key_registry_bytes": 7432311,
+          "backend_with_datrie_key_index_bytes": 7129750,
+          "full_model_serving_artifact_bytes": 8132309,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9704402461322955,
+            "mean_cosine": 0.9997651021883833,
+            "p05_cosine": 0.9988425531711095,
+            "relative_l2_mean": 0.010238032437592758,
+            "relative_l2_p95": 0.048383933605566955,
+            "relative_l2_max": 0.24438774093788204,
+            "weighted_relative_l2_mean": 0.002622011212296494,
+            "weighted_relative_frobenius": 0.013363174052846639,
+            "weighted_mean_cosine": 0.9999410905985338,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9704402461322955,
+            "mean_cosine": 0.9997651021883833,
+            "p05_cosine": 0.9988425531711095,
+            "relative_l2_mean": 0.010238032437592758,
+            "relative_l2_p95": 0.048383933605566955,
+            "relative_l2_max": 0.24438774093788204,
+            "weighted_relative_l2_mean": 0.002622011212296494,
+            "weighted_relative_frobenius": 0.013363174052846639,
+            "weighted_mean_cosine": 0.9999410905985338,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.973927,
+            "warm_p50_ms": 0.056292,
+            "warm_p95_ms": 0.059645,
+            "warm_p99_ms": 0.07809200999999998,
+            "samples_ms": [
+              0.058667,
+              0.059645,
+              0.056781,
+              0.056712,
+              0.0572,
+              0.057689,
+              0.056292,
+              0.054895,
+              0.089886,
+              0.056293,
+              0.056292,
+              0.056781,
+              0.056292,
+              0.055873,
+              0.055873,
+              0.056222,
+              0.056712,
+              0.056292,
+              0.056292,
+              0.056362,
+              0.055384,
+              0.055315,
+              0.054896,
+              0.056292,
+              0.055803,
+              0.054895,
+              0.055803,
+              0.056292,
+              0.055803,
+              0.056292,
+              0.056781,
+              0.055873,
+              0.055384,
+              0.055873,
+              0.054965,
+              0.056362,
+              0.053987,
+              0.056712,
+              0.059645,
+              0.056781
+            ],
+            "warm_rows_per_second": 9095430.967100121
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8540159733975723,
+            "character_perplexity": 6.385411743060209,
+            "next_character_accuracy": 0.5025302867658334,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00019006358810967617,
+            "mean_prediction_kl_nats": 3.3202891648341754e-05,
+            "prediction_kl_p99_nats": 0.00013455703572435869,
+            "maximum_prediction_kl_nats": 0.05639065703611837,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.5608301162719727
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00019006358810967617,
+            "mean_prediction_kl_nats": 3.3202891648341754e-05,
+            "prediction_kl_p99_nats": 0.00013455703572435869,
+            "maximum_prediction_kl_nats": 0.05639065703611837,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.5825309753417969,
+            "maximum_per_target_cross_entropy_increase": 0.5608301162719727
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6830054,
+              "unique_rows": 27341,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 855,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 855,
+              "zlib_blocks": 855,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27341
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "9eecfa9f246dfb68f0fd6ae8c5f3beeb4d8f7def790e5936e186c05033587ef8",
+            "table_sha256": "5774c63ec3757799dddb912010bd97b9da8869dbe730b1070b54751e8a856b04",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6180408620275557,
+          "representatives_sha256": "0899384c5982cc54601899a082a05066a00c9ba276bd16ed3eef6f38e8c3dea3",
+          "structurally_merged_rows": 9437,
+          "backend_artifact_bytes": 6831260,
+          "backend_with_key_registry_bytes": 7428781,
+          "backend_with_datrie_key_index_bytes": 7126220,
+          "full_model_serving_artifact_bytes": 8128779,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9518773821592306,
+            "mean_cosine": 0.9997393157385929,
+            "p05_cosine": 0.9988358590976054,
+            "relative_l2_mean": 0.010413511527011282,
+            "relative_l2_p95": 0.04856855841130637,
+            "relative_l2_max": 0.3090281189559274,
+            "weighted_relative_l2_mean": 0.0028881504015720893,
+            "weighted_relative_frobenius": 0.02021922611928201,
+            "weighted_mean_cosine": 0.9998993340489422,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9518773821592306,
+            "mean_cosine": 0.9997393157385929,
+            "p05_cosine": 0.9988358590976054,
+            "relative_l2_mean": 0.010413511527011282,
+            "relative_l2_p95": 0.04856855841130637,
+            "relative_l2_max": 0.3090281189559274,
+            "weighted_relative_l2_mean": 0.0028881504015720893,
+            "weighted_relative_frobenius": 0.02021922611928201,
+            "weighted_mean_cosine": 0.9998993340489422,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.944174,
+            "warm_p50_ms": 0.055803,
+            "warm_p95_ms": 0.05824785,
+            "warm_p99_ms": 0.05991538,
+            "samples_ms": [
+              0.058178,
+              0.059575,
+              0.060133,
+              0.057759,
+              0.057689,
+              0.055873,
+              0.057759,
+              0.057689,
+              0.057689,
+              0.057689,
+              0.058178,
+              0.058178,
+              0.05727,
+              0.055803,
+              0.055314,
+              0.055803,
+              0.055384,
+              0.057689,
+              0.056222,
+              0.055384,
+              0.054406,
+              0.055803,
+              0.055314,
+              0.055803,
+              0.055734,
+              0.056292,
+              0.055384,
+              0.055803,
+              0.055314,
+              0.055454,
+              0.055873,
+              0.055384,
+              0.055454,
+              0.055873,
+              0.055384,
+              0.056851,
+              0.055385,
+              0.055803,
+              0.055803,
+              0.054895
+            ],
+            "warm_rows_per_second": 9175133.953371683
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853981340930912,
+            "character_perplexity": 6.385190604330218,
+            "next_character_accuracy": 0.5025302867658334,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00015542513888953914,
+            "mean_prediction_kl_nats": 3.9837892344174354e-05,
+            "prediction_kl_p99_nats": 0.00020867086076595511,
+            "maximum_prediction_kl_nats": 0.05639065703611837,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.3523645401000977,
+            "maximum_per_target_cross_entropy_increase": 0.592867374420166
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015542513888953914,
+            "mean_prediction_kl_nats": 3.9837892344174354e-05,
+            "prediction_kl_p99_nats": 0.00020867086076595511,
+            "maximum_prediction_kl_nats": 0.05639065703611837,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.3523645401000977,
+            "maximum_per_target_cross_entropy_increase": 0.592867374420166
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 9415168,
+              "artifact_bytes": 6823416,
+              "unique_rows": 27313,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 854,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 854,
+              "zlib_blocks": 854,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27313
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "54b9125f3f3cc8048738b1898b724c2aa7603d1fffe0fd57fcb85ab8242ebe55",
+            "table_sha256": "12a0e3b6a62dfb6b77ad4b37cac8fa834ddca6e66f29758fcc19a46bef85d36b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6208194300998002,
+          "representatives_sha256": "53a34e444549f34f5c926369fe03d9391a93cfbf4bb9038f79ee3acd446c468d",
+          "structurally_merged_rows": 9465,
+          "backend_artifact_bytes": 6824622,
+          "backend_with_key_registry_bytes": 7422143,
+          "backend_with_datrie_key_index_bytes": 7119582,
+          "full_model_serving_artifact_bytes": 8122141,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9053524674923515,
+            "mean_cosine": 0.9996788540343262,
+            "p05_cosine": 0.9988257235328838,
+            "relative_l2_mean": 0.010728835804298021,
+            "relative_l2_p95": 0.048762315495126315,
+            "relative_l2_max": 0.4349381373732949,
+            "weighted_relative_l2_mean": 0.002949611927462981,
+            "weighted_relative_frobenius": 0.02111180791434024,
+            "weighted_mean_cosine": 0.9998876560063008,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9053524674923515,
+            "mean_cosine": 0.9996788540343262,
+            "p05_cosine": 0.9988257235328838,
+            "relative_l2_mean": 0.010728835804298021,
+            "relative_l2_p95": 0.048762315495126315,
+            "relative_l2_max": 0.4349381373732949,
+            "weighted_relative_l2_mean": 0.002949611927462981,
+            "weighted_relative_frobenius": 0.02111180791434024,
+            "weighted_mean_cosine": 0.9998876560063008,
+            "max_relative_norm_change": 0.01009546294416497
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 8.052917,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.0595785,
+            "warm_p99_ms": 0.07523781999999998,
+            "samples_ms": [
+              0.059575,
+              0.058177,
+              0.055873,
+              0.055873,
+              0.055873,
+              0.057758,
+              0.056362,
+              0.057759,
+              0.055384,
+              0.058178,
+              0.056362,
+              0.055873,
+              0.056781,
+              0.05727,
+              0.055315,
+              0.055315,
+              0.054895,
+              0.056362,
+              0.055803,
+              0.055384,
+              0.055385,
+              0.055314,
+              0.055314,
+              0.055873,
+              0.056292,
+              0.055384,
+              0.055385,
+              0.085207,
+              0.059645,
+              0.055803,
+              0.055873,
+              0.056293,
+              0.055384,
+              0.055803,
+              0.055384,
+              0.055873,
+              0.055803,
+              0.055385,
+              0.054337,
+              0.055873
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539972901438648,
+            "character_perplexity": 6.385292443907039,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00017137695796017206,
+            "mean_prediction_kl_nats": 6.565723955188551e-05,
+            "prediction_kl_p99_nats": 0.00029545771466669854,
+            "maximum_prediction_kl_nats": 0.18560528499201612,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.3523645401000977,
+            "maximum_per_target_cross_entropy_increase": 0.592867374420166
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00017137695796017206,
+            "mean_prediction_kl_nats": 6.565723955188551e-05,
+            "prediction_kl_p99_nats": 0.00029545771466669854,
+            "maximum_prediction_kl_nats": 0.18560528499201612,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.3523645401000977,
+            "maximum_per_target_cross_entropy_increase": 0.592867374420166
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 4707584,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "add9a6b9c5875f02dc14dc3783c9953d7edb14426c4012649076815ddb6e1c71",
+            "table_sha256": "dc1bc47aaa923557f0743007570dfa78218b7b4f83c5f736f5d9ba4446f6a6c1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05553986900486052,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4708389,
+          "backend_with_key_registry_bytes": 5305910,
+          "backend_with_datrie_key_index_bytes": 5003349,
+          "full_model_serving_artifact_bytes": 6005908,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999530139869,
+            "mean_cosine": 0.9999999791887941,
+            "p05_cosine": 0.9999999715778723,
+            "relative_l2_mean": 0.00020657158571956225,
+            "relative_l2_p95": 0.00024197280109949766,
+            "relative_l2_max": 0.0003091615715408284,
+            "weighted_relative_l2_mean": 0.0001174621969176169,
+            "weighted_relative_frobenius": 0.00020737521315361893,
+            "weighted_mean_cosine": 0.999999988256516,
+            "max_relative_norm_change": 0.0001890064061433835
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.351511,
+            "warm_p50_ms": 0.13769199999999998,
+            "warm_p95_ms": 0.141945,
+            "warm_p99_ms": 0.17003546999999997,
+            "samples_ms": [
+              0.140521,
+              0.139124,
+              0.137657,
+              0.136749,
+              0.137727,
+              0.182565,
+              0.141498,
+              0.137168,
+              0.137168,
+              0.136749,
+              0.138146,
+              0.137657,
+              0.138077,
+              0.137657,
+              0.138635,
+              0.136679,
+              0.138146,
+              0.137657,
+              0.137099,
+              0.138566,
+              0.13675,
+              0.137657,
+              0.138076,
+              0.137587,
+              0.136679,
+              0.137657,
+              0.137727,
+              0.138146,
+              0.138566,
+              0.137168,
+              0.137657,
+              0.137168,
+              0.138635,
+              0.150438,
+              0.139543,
+              0.139543,
+              0.137588,
+              0.138077,
+              0.139543,
+              0.137168
+            ],
+            "warm_rows_per_second": 3718444.063562154
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853826562635324,
+            "character_perplexity": 6.3842023918903665,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.347662674319074e-07,
+            "mean_prediction_kl_nats": 4.381973465217552e-09,
+            "prediction_kl_p99_nats": 3.551782450171475e-08,
+            "maximum_prediction_kl_nats": 9.231610310342147e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001482546329498291,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650510,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "add9a6b9c5875f02dc14dc3783c9953d7edb14426c4012649076815ddb6e1c71",
+            "table_sha256": "45733a4f72c3f601b297dd9e696eb7b2b7a960034ab323d3cec5c151a18b7aff",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4225367580074817,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651718,
+          "backend_with_key_registry_bytes": 5249239,
+          "backend_with_datrie_key_index_bytes": 4946678,
+          "full_model_serving_artifact_bytes": 5949237,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999530139869,
+            "mean_cosine": 0.9999999791887941,
+            "p05_cosine": 0.9999999715778723,
+            "relative_l2_mean": 0.00020657158571956225,
+            "relative_l2_p95": 0.00024197280109949766,
+            "relative_l2_max": 0.0003091615715408284,
+            "weighted_relative_l2_mean": 0.0001174621969176169,
+            "weighted_relative_frobenius": 0.00020737521315361893,
+            "weighted_mean_cosine": 0.999999988256516,
+            "max_relative_norm_change": 0.0001890064061433835
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.804073,
+            "warm_p50_ms": 0.1471205,
+            "warm_p95_ms": 0.15100389999999997,
+            "warm_p99_ms": 0.16728484,
+            "samples_ms": [
+              0.150508,
+              0.147575,
+              0.148972,
+              0.147156,
+              0.14946,
+              0.14953,
+              0.147644,
+              0.17167,
+              0.147155,
+              0.147645,
+              0.147016,
+              0.147644,
+              0.147575,
+              0.147645,
+              0.146666,
+              0.146178,
+              0.14527,
+              0.160426,
+              0.147225,
+              0.146178,
+              0.145759,
+              0.147156,
+              0.146248,
+              0.145759,
+              0.147156,
+              0.147086,
+              0.146737,
+              0.146667,
+              0.147644,
+              0.145689,
+              0.145689,
+              0.14527,
+              0.148064,
+              0.1452,
+              0.146667,
+              0.146597,
+              0.147574,
+              0.145689,
+              0.145619,
+              0.146178
+            ],
+            "warm_rows_per_second": 3480140.429104034
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853826562635324,
+            "character_perplexity": 6.3842023918903665,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.347662674319074e-07,
+            "mean_prediction_kl_nats": 4.381973465217552e-09,
+            "prediction_kl_p99_nats": 3.551782450171475e-08,
+            "maximum_prediction_kl_nats": 9.231610310342147e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001482546329498291,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650510,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "add9a6b9c5875f02dc14dc3783c9953d7edb14426c4012649076815ddb6e1c71",
+            "table_sha256": "45733a4f72c3f601b297dd9e696eb7b2b7a960034ab323d3cec5c151a18b7aff",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5809798981063068,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651717,
+          "backend_with_key_registry_bytes": 5249238,
+          "backend_with_datrie_key_index_bytes": 4946677,
+          "full_model_serving_artifact_bytes": 5949236,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999530139869,
+            "mean_cosine": 0.9999999791887941,
+            "p05_cosine": 0.9999999715778723,
+            "relative_l2_mean": 0.00020657158571956225,
+            "relative_l2_p95": 0.00024197280109949766,
+            "relative_l2_max": 0.0003091615715408284,
+            "weighted_relative_l2_mean": 0.0001174621969176169,
+            "weighted_relative_frobenius": 0.00020737521315361893,
+            "weighted_mean_cosine": 0.999999988256516,
+            "max_relative_norm_change": 0.0001890064061433835
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.910581,
+            "warm_p50_ms": 0.1471555,
+            "warm_p95_ms": 0.15245644999999997,
+            "warm_p99_ms": 0.17083389999999998,
+            "samples_ms": [
+              0.150438,
+              0.14953,
+              0.148482,
+              0.147645,
+              0.165594,
+              0.14995,
+              0.148972,
+              0.149041,
+              0.148063,
+              0.147156,
+              0.148064,
+              0.147086,
+              0.147156,
+              0.147156,
+              0.146666,
+              0.146248,
+              0.145689,
+              0.146667,
+              0.147644,
+              0.14527,
+              0.14527,
+              0.147645,
+              0.146667,
+              0.147086,
+              0.146666,
+              0.147086,
+              0.14569,
+              0.146178,
+              0.146178,
+              0.145689,
+              0.174184,
+              0.151765,
+              0.147575,
+              0.146178,
+              0.145689,
+              0.145689,
+              0.147645,
+              0.147645,
+              0.147155,
+              0.145759
+            ],
+            "warm_rows_per_second": 3479312.699831131
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853826562635324,
+            "character_perplexity": 6.3842023918903665,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.347662674319074e-07,
+            "mean_prediction_kl_nats": 4.381973465217552e-09,
+            "prediction_kl_p99_nats": 3.551782450171475e-08,
+            "maximum_prediction_kl_nats": 9.231610310342147e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001482546329498291,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 4650510,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 575,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 575,
+              "zlib_blocks": 575,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "add9a6b9c5875f02dc14dc3783c9953d7edb14426c4012649076815ddb6e1c71",
+            "table_sha256": "45733a4f72c3f601b297dd9e696eb7b2b7a960034ab323d3cec5c151a18b7aff",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.44609333807602525,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 4651717,
+          "backend_with_key_registry_bytes": 5249238,
+          "backend_with_datrie_key_index_bytes": 4946677,
+          "full_model_serving_artifact_bytes": 5949236,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999530139869,
+            "mean_cosine": 0.9999999791887941,
+            "p05_cosine": 0.9999999715778723,
+            "relative_l2_mean": 0.00020657158571956225,
+            "relative_l2_p95": 0.00024197280109949766,
+            "relative_l2_max": 0.0003091615715408284,
+            "weighted_relative_l2_mean": 0.0001174621969176169,
+            "weighted_relative_frobenius": 0.00020737521315361893,
+            "weighted_mean_cosine": 0.999999988256516,
+            "max_relative_norm_change": 0.0001890064061433835
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.812034,
+            "warm_p50_ms": 0.147086,
+            "warm_p95_ms": 0.15106334999999999,
+            "warm_p99_ms": 0.15607305999999999,
+            "samples_ms": [
+              0.150997,
+              0.152324,
+              0.150439,
+              0.14995,
+              0.148553,
+              0.147226,
+              0.146666,
+              0.146667,
+              0.147155,
+              0.148552,
+              0.146667,
+              0.14562,
+              0.146178,
+              0.146666,
+              0.146178,
+              0.148133,
+              0.147156,
+              0.147156,
+              0.147994,
+              0.147086,
+              0.15847,
+              0.149041,
+              0.147086,
+              0.146667,
+              0.147155,
+              0.147156,
+              0.147575,
+              0.145689,
+              0.146248,
+              0.14527,
+              0.147155,
+              0.146667,
+              0.147156,
+              0.147086,
+              0.146667,
+              0.145619,
+              0.146597,
+              0.145689,
+              0.146597,
+              0.146667
+            ],
+            "warm_rows_per_second": 3480956.719198292
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853826562635324,
+            "character_perplexity": 6.3842023918903665,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.347662674319074e-07,
+            "mean_prediction_kl_nats": 4.381973465217552e-09,
+            "prediction_kl_p99_nats": 3.551782450171475e-08,
+            "maximum_prediction_kl_nats": 9.231610310342147e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001482546329498291,
+            "maximum_per_target_cross_entropy_increase": 0.0007162094116210938
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3542163,
+              "unique_rows": 27383,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27383
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "6686cc166ec018c6f58281b13be9d49e7b50f16bc08937faaa161a38c13674ea",
+            "table_sha256": "72f2f63eea66f5b49160da1c9210dd11dcce2cbeff561847c4c10abd0523a5b4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3577422120142728,
+          "representatives_sha256": "ea3df8f03e9e254c1bba48f32255f8b9d75dc0da14c914a9f93c8706ea9cd7be",
+          "structurally_merged_rows": 9395,
+          "backend_artifact_bytes": 3543369,
+          "backend_with_key_registry_bytes": 4140890,
+          "backend_with_datrie_key_index_bytes": 3838329,
+          "full_model_serving_artifact_bytes": 4840888,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900583488604219,
+            "mean_cosine": 0.9997785803340887,
+            "p05_cosine": 0.9988497309240236,
+            "relative_l2_mean": 0.01025296949475231,
+            "relative_l2_p95": 0.048204921643589006,
+            "relative_l2_max": 0.1411682070021142,
+            "weighted_relative_l2_mean": 0.002618490340327802,
+            "weighted_relative_frobenius": 0.011362454733114946,
+            "weighted_mean_cosine": 0.9999512568607424,
+            "max_relative_norm_change": 0.010060688872288616
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900528053809458,
+            "mean_cosine": 0.9997785929759666,
+            "p05_cosine": 0.9988495161403594,
+            "relative_l2_mean": 0.010099256262850595,
+            "relative_l2_p95": 0.04822410935046492,
+            "relative_l2_max": 0.1412116330222307,
+            "weighted_relative_l2_mean": 0.0025162258786515057,
+            "weighted_relative_frobenius": 0.011360453108480639,
+            "weighted_mean_cosine": 0.9999512684129139,
+            "max_relative_norm_change": 0.01005837789888315
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.222644,
+            "warm_p50_ms": 0.146143,
+            "warm_p95_ms": 0.1562882,
+            "warm_p99_ms": 0.16832364,
+            "samples_ms": [
+              0.150857,
+              0.148064,
+              0.147155,
+              0.147645,
+              0.146108,
+              0.151416,
+              0.147574,
+              0.146108,
+              0.146178,
+              0.145689,
+              0.14527,
+              0.1452,
+              0.146597,
+              0.145689,
+              0.145689,
+              0.147085,
+              0.15861,
+              0.147225,
+              0.146248,
+              0.150438,
+              0.156166,
+              0.146178,
+              0.146667,
+              0.146667,
+              0.14527,
+              0.144851,
+              0.174534,
+              0.149531,
+              0.144711,
+              0.146108,
+              0.146666,
+              0.1452,
+              0.144711,
+              0.144781,
+              0.145829,
+              0.145829,
+              0.145759,
+              0.145759,
+              0.14527,
+              0.145201
+            ],
+            "warm_rows_per_second": 3503417.8852220085
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539192812693612,
+            "character_perplexity": 6.384794353858088,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.335775766754529e-05,
+            "mean_prediction_kl_nats": 7.860089630404762e-06,
+            "prediction_kl_p99_nats": 0.0001081220717595102,
+            "maximum_prediction_kl_nats": 0.005482748176321384,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.582134485244751,
+            "maximum_per_target_cross_entropy_increase": 0.10675567388534546
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 9.272293254272358e-05,
+            "mean_prediction_kl_nats": 7.853801367279266e-06,
+            "prediction_kl_p99_nats": 0.00010800525827647296,
+            "maximum_prediction_kl_nats": 0.005482279349342036,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5824252367019653,
+            "maximum_per_target_cross_entropy_increase": 0.10677337646484375
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3540837,
+              "unique_rows": 27370,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27370
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "0b6e274cd163a3050cc5cf3956c9740a9c224513f37ec1b53fd7d568214fe286",
+            "table_sha256": "b9f55fad4e5270d7895a8d87d13647f53ccd4630c1a2ba02bb8a45fb38257a1c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3818652050103992,
+          "representatives_sha256": "03b58da9e10c1c74137221fb8637b90f15bb9cd3ffac7696b72ddd6653ba8fef",
+          "structurally_merged_rows": 9408,
+          "backend_artifact_bytes": 3542043,
+          "backend_with_key_registry_bytes": 4139564,
+          "backend_with_datrie_key_index_bytes": 3837003,
+          "full_model_serving_artifact_bytes": 4839562,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9809678573304468,
+            "mean_cosine": 0.9997726904847208,
+            "p05_cosine": 0.998846390275071,
+            "relative_l2_mean": 0.010320209232536749,
+            "relative_l2_p95": 0.04829327747273836,
+            "relative_l2_max": 0.1950152044633947,
+            "weighted_relative_l2_mean": 0.0026817322477937677,
+            "weighted_relative_frobenius": 0.012459100118378013,
+            "weighted_mean_cosine": 0.9999459122723975,
+            "max_relative_norm_change": 0.010060688872288616
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9809711354383118,
+            "mean_cosine": 0.9997727034164549,
+            "p05_cosine": 0.9988463346832401,
+            "relative_l2_mean": 0.01016656703669211,
+            "relative_l2_p95": 0.04830014203664504,
+            "relative_l2_max": 0.19499627551793236,
+            "weighted_relative_l2_mean": 0.002579537373571873,
+            "weighted_relative_frobenius": 0.012456934608601724,
+            "weighted_mean_cosine": 0.9999459255339357,
+            "max_relative_norm_change": 0.01005837789888315
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.80157,
+            "warm_p50_ms": 0.1475745,
+            "warm_p95_ms": 0.15414704999999998,
+            "warm_p99_ms": 0.16893004,
+            "samples_ms": [
+              0.14995,
+              0.149112,
+              0.150858,
+              0.162242,
+              0.150508,
+              0.153721,
+              0.14995,
+              0.147645,
+              0.147574,
+              0.148133,
+              0.148064,
+              0.146667,
+              0.147156,
+              0.148623,
+              0.146667,
+              0.146178,
+              0.149531,
+              0.147086,
+              0.147575,
+              0.149111,
+              0.147086,
+              0.149041,
+              0.147644,
+              0.147575,
+              0.146597,
+              0.146597,
+              0.146248,
+              0.147155,
+              0.146737,
+              0.173206,
+              0.150997,
+              0.147155,
+              0.147156,
+              0.147156,
+              0.14527,
+              0.147156,
+              0.147574,
+              0.148134,
+              0.146178,
+              0.146178
+            ],
+            "warm_rows_per_second": 3469434.082446493
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539698061616214,
+            "character_perplexity": 6.385116953054496,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001438886433413367,
+            "mean_prediction_kl_nats": 1.1390478563979348e-05,
+            "prediction_kl_p99_nats": 0.00012464599131380375,
+            "maximum_prediction_kl_nats": 0.008272212034854634,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.582134485244751,
+            "maximum_per_target_cross_entropy_increase": 0.5608210563659668
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00014325378614123366,
+            "mean_prediction_kl_nats": 1.1379573729840894e-05,
+            "prediction_kl_p99_nats": 0.00012433828705492853,
+            "maximum_prediction_kl_nats": 0.00826821449514578,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.5824252367019653,
+            "maximum_per_target_cross_entropy_increase": 0.5607891082763672
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3539617,
+              "unique_rows": 27360,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27360
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "52524d8a80bf6126e4a9ec7b09426a0689fb3a44f58eaec989cbf8e43abc5d31",
+            "table_sha256": "ac74792be931d840aca9d47fb9faf3de767caabbb272f56f36c5dc6ec8be24cf",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3639816988725215,
+          "representatives_sha256": "9431822511204c421fc7b57dec7b6e3871f766ba0a2f98650f61532aeeb9d356",
+          "structurally_merged_rows": 9418,
+          "backend_artifact_bytes": 3540823,
+          "backend_with_key_registry_bytes": 4138344,
+          "backend_with_datrie_key_index_bytes": 3835783,
+          "full_model_serving_artifact_bytes": 4838342,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9704420756698033,
+            "mean_cosine": 0.9997652259801274,
+            "p05_cosine": 0.9988430293145306,
+            "relative_l2_mean": 0.010385968950148119,
+            "relative_l2_p95": 0.04835284671843402,
+            "relative_l2_max": 0.24438303843706874,
+            "weighted_relative_l2_mean": 0.002724070911672629,
+            "weighted_relative_frobenius": 0.01336469162681883,
+            "weighted_mean_cosine": 0.9999410843197322,
+            "max_relative_norm_change": 0.010060688872288616
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9704408373854408,
+            "mean_cosine": 0.9997652392798527,
+            "p05_cosine": 0.9988439386618082,
+            "relative_l2_mean": 0.010232378867656454,
+            "relative_l2_p95": 0.04836524448648539,
+            "relative_l2_max": 0.24438888634794073,
+            "weighted_relative_l2_mean": 0.0026219126257521785,
+            "weighted_relative_frobenius": 0.013362577654920042,
+            "weighted_mean_cosine": 0.9999410980709135,
+            "max_relative_norm_change": 0.01005837789888315
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.06557,
+            "warm_p50_ms": 0.146178,
+            "warm_p95_ms": 0.15030519999999997,
+            "warm_p99_ms": 0.17206923999999998,
+            "samples_ms": [
+              0.181657,
+              0.149949,
+              0.147575,
+              0.146737,
+              0.147645,
+              0.147156,
+              0.147156,
+              0.146667,
+              0.145759,
+              0.147156,
+              0.146667,
+              0.146178,
+              0.147086,
+              0.146178,
+              0.146108,
+              0.144712,
+              0.145759,
+              0.146178,
+              0.147156,
+              0.14527,
+              0.146667,
+              0.145759,
+              0.1452,
+              0.145759,
+              0.145759,
+              0.145759,
+              0.157073,
+              0.146178,
+              0.146247,
+              0.145689,
+              0.146178,
+              0.146178,
+              0.145759,
+              0.146248,
+              0.146178,
+              0.146178,
+              0.14527,
+              0.145759,
+              0.144432,
+              0.145759
+            ],
+            "warm_rows_per_second": 3502579.0474626822
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.854018102350402,
+            "character_perplexity": 6.3854253373150796,
+            "next_character_accuracy": 0.5025302867658334,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00019219294784254167,
+            "mean_prediction_kl_nats": 3.3213587724556626e-05,
+            "prediction_kl_p99_nats": 0.00013499927110225605,
+            "maximum_prediction_kl_nats": 0.056391579973223666,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.582134485244751,
+            "maximum_per_target_cross_entropy_increase": 0.5608210563659668
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00019155805998051503,
+            "mean_prediction_kl_nats": 3.3197522686109876e-05,
+            "prediction_kl_p99_nats": 0.00013509073392637801,
+            "maximum_prediction_kl_nats": 0.056395402051164056,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.5824252367019653,
+            "maximum_per_target_cross_entropy_increase": 0.5607891082763672
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3537840,
+              "unique_rows": 27345,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 428,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 428,
+              "zlib_blocks": 428,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27345
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "94fa24d32e5a88de9b1c942b7ab9edcef69331fd8ef535bab494839ab721784b",
+            "table_sha256": "57ebd55f4bb04f32efb851034d1e5b42857f2b971ea9218f16c35a29b0c2dd76",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3652330469340086,
+          "representatives_sha256": "2708ef147a95484ad1214882f63d7ea0dcca875a9e02a63b14ca3f819d1186b1",
+          "structurally_merged_rows": 9433,
+          "backend_artifact_bytes": 3539046,
+          "backend_with_key_registry_bytes": 4136567,
+          "backend_with_datrie_key_index_bytes": 3834006,
+          "full_model_serving_artifact_bytes": 4836565,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.951880122571213,
+            "mean_cosine": 0.9997394374201652,
+            "p05_cosine": 0.9988363151404382,
+            "relative_l2_mean": 0.010561375291258746,
+            "relative_l2_p95": 0.04853784508022435,
+            "relative_l2_max": 0.30901836110861,
+            "weighted_relative_l2_mean": 0.0029901262533581266,
+            "weighted_relative_frobenius": 0.02022010224983534,
+            "weighted_mean_cosine": 0.999899326033451,
+            "max_relative_norm_change": 0.010060688872288616
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9518768396606513,
+            "mean_cosine": 0.9997394490597237,
+            "p05_cosine": 0.9988363326785129,
+            "relative_l2_mean": 0.01040787604509202,
+            "relative_l2_p95": 0.048554263540243614,
+            "relative_l2_max": 0.30902503881007914,
+            "weighted_relative_l2_mean": 0.00288806554005823,
+            "weighted_relative_frobenius": 0.02021895115268188,
+            "weighted_mean_cosine": 0.9998993381404068,
+            "max_relative_norm_change": 0.01005837789888315
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.195685,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.15144045,
+            "warm_p99_ms": 0.16545248999999998,
+            "samples_ms": [
+              0.151905,
+              0.149041,
+              0.148622,
+              0.148064,
+              0.147645,
+              0.150438,
+              0.147086,
+              0.148552,
+              0.146248,
+              0.148133,
+              0.148133,
+              0.147645,
+              0.145619,
+              0.147575,
+              0.146178,
+              0.146108,
+              0.147156,
+              0.147644,
+              0.146667,
+              0.145758,
+              0.147156,
+              0.147574,
+              0.174114,
+              0.151416,
+              0.146667,
+              0.146667,
+              0.148063,
+              0.147156,
+              0.145689,
+              0.147645,
+              0.145759,
+              0.147575,
+              0.145759,
+              0.145759,
+              0.146736,
+              0.145759,
+              0.145759,
+              0.146248,
+              0.14527,
+              0.145759
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539834781980202,
+            "character_perplexity": 6.385204251202659,
+            "next_character_accuracy": 0.5025302867658334,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00015756274046707167,
+            "mean_prediction_kl_nats": 3.984621007166472e-05,
+            "prediction_kl_p99_nats": 0.000208762134777395,
+            "maximum_prediction_kl_nats": 0.056391579973223666,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.3518116474151611,
+            "maximum_per_target_cross_entropy_increase": 0.5926408767700195
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015692787458711856,
+            "mean_prediction_kl_nats": 3.9835150656727545e-05,
+            "prediction_kl_p99_nats": 0.00020869774222090573,
+            "maximum_prediction_kl_nats": 0.056395402051164056,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.351919412612915,
+            "maximum_per_target_cross_entropy_increase": 0.5928516387939453
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 4707584,
+              "artifact_bytes": 3534415,
+              "unique_rows": 27317,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 427,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 427,
+              "zlib_blocks": 427,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27317
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "fa0c7c96c780049c86c8ec04a7d09dc6f2a63808292ecd5be73ea266f0ebdf25",
+            "table_sha256": "f1353fb4a3847262888f7359146087f31e29c9ea150c5ead4e7e488ffa5cc68f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3661111609544605,
+          "representatives_sha256": "a14855332f8c2549544786d698d0785f8c21627102f575e233c074cf72c6ebb3",
+          "structurally_merged_rows": 9461,
+          "backend_artifact_bytes": 3535621,
+          "backend_with_key_registry_bytes": 4133142,
+          "backend_with_datrie_key_index_bytes": 3830581,
+          "full_model_serving_artifact_bytes": 4833140,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9053573483193148,
+            "mean_cosine": 0.9996789749251602,
+            "p05_cosine": 0.9988266659254238,
+            "relative_l2_mean": 0.01087655038235001,
+            "relative_l2_p95": 0.048746361326333955,
+            "relative_l2_max": 0.4349194109717122,
+            "weighted_relative_l2_mean": 0.003051557936101642,
+            "weighted_relative_frobenius": 0.02111267519256833,
+            "weighted_mean_cosine": 0.9998876477320475,
+            "max_relative_norm_change": 0.010100417761457934
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9053566777874397,
+            "mean_cosine": 0.9996789879119171,
+            "p05_cosine": 0.9988261750540566,
+            "relative_l2_mean": 0.010723201142315683,
+            "relative_l2_p95": 0.048746575378579175,
+            "relative_l2_max": 0.4349282171568034,
+            "weighted_relative_l2_mean": 0.0029495295827145374,
+            "weighted_relative_frobenius": 0.02111158170259364,
+            "weighted_mean_cosine": 0.9998876594669917,
+            "max_relative_norm_change": 0.01005837789888315
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 7.52827,
+            "warm_p50_ms": 0.14534,
+            "warm_p95_ms": 0.1558681,
+            "warm_p99_ms": 0.17647416999999999,
+            "samples_ms": [
+              0.155676,
+              0.153232,
+              0.187315,
+              0.15421,
+              0.148552,
+              0.146248,
+              0.145689,
+              0.145759,
+              0.144712,
+              0.146108,
+              0.145689,
+              0.144712,
+              0.146178,
+              0.14527,
+              0.144781,
+              0.144781,
+              0.14534,
+              0.14534,
+              0.143804,
+              0.145689,
+              0.1452,
+              0.14527,
+              0.145689,
+              0.144851,
+              0.143873,
+              0.144223,
+              0.144712,
+              0.145689,
+              0.146178,
+              0.159518,
+              0.1452,
+              0.145201,
+              0.1452,
+              0.1452,
+              0.143804,
+              0.144362,
+              0.143803,
+              0.145689,
+              0.145689,
+              0.145619
+            ],
+            "warm_rows_per_second": 3522774.1846704283
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853999420891706,
+            "character_perplexity": 6.385306049369624,
+            "next_character_accuracy": 0.502453611409293,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00017350807323292404,
+            "mean_prediction_kl_nats": 6.566471728432845e-05,
+            "prediction_kl_p99_nats": 0.00029385215046018174,
+            "maximum_prediction_kl_nats": 0.18563221670097035,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.3518116474151611,
+            "maximum_per_target_cross_entropy_increase": 0.5926408767700195
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00017287319723141798,
+            "mean_prediction_kl_nats": 6.565572079471623e-05,
+            "prediction_kl_p99_nats": 0.00029369762215553655,
+            "maximum_prediction_kl_nats": 0.18562726426991394,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 1.351919412612915,
+            "maximum_per_target_cross_entropy_increase": 0.5928516387939453
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2500904,
+              "unique_rows": 36778,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "fbf67b027d9c0471b313f44fdd647110f6a4ee32fdb01f42ab8203b4476c24a3",
+            "table_sha256": "80c1610db9ec1aeaad5f260db8066dd9509b9548ce61e66c9563ff1efe6127ca",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05942556192167103,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2501752,
+          "backend_with_key_registry_bytes": 3099273,
+          "backend_with_datrie_key_index_bytes": 2796712,
+          "full_model_serving_artifact_bytes": 3799271,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999328779127546,
+            "mean_cosine": 0.9999882584835896,
+            "p05_cosine": 0.9999770406579376,
+            "relative_l2_mean": 0.004739083006836966,
+            "relative_l2_p95": 0.006820293522058443,
+            "relative_l2_max": 0.01165596953583282,
+            "weighted_relative_l2_mean": 0.0030815487651294883,
+            "weighted_relative_frobenius": 0.005367583367488608,
+            "weighted_mean_cosine": 0.9999914177601257,
+            "max_relative_norm_change": 0.0031225575438659937
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.315613,
+            "warm_p50_ms": 0.0965205,
+            "warm_p95_ms": 0.09947924999999999,
+            "warm_p99_ms": 0.10731937,
+            "samples_ms": [
+              0.099385,
+              0.095124,
+              0.097429,
+              0.097009,
+              0.09708,
+              0.09701,
+              0.09652,
+              0.094635,
+              0.097009,
+              0.095543,
+              0.094985,
+              0.096521,
+              0.095124,
+              0.096521,
+              0.09652,
+              0.095124,
+              0.096101,
+              0.096102,
+              0.094636,
+              0.096451,
+              0.096451,
+              0.09701,
+              0.09701,
+              0.09694,
+              0.096451,
+              0.096521,
+              0.094566,
+              0.094984,
+              0.111187,
+              0.09694,
+              0.095124,
+              0.096102,
+              0.10127,
+              0.095962,
+              0.095054,
+              0.097009,
+              0.096521,
+              0.096521,
+              0.09694,
+              0.096521
+            ],
+            "warm_rows_per_second": 5304572.60374739
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853797174879323,
+            "character_perplexity": 6.384014777265012,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.8752576571929952e-05,
+            "mean_prediction_kl_nats": 3.7250146321206883e-06,
+            "prediction_kl_p99_nats": 2.9429470754635976e-05,
+            "maximum_prediction_kl_nats": 0.0001005267416845651,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.03496575355529785,
+            "maximum_per_target_cross_entropy_increase": 0.021662473678588867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802310,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 124,
+              "compressed_blocks": 183,
+              "zlib_blocks": 183,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "fbf67b027d9c0471b313f44fdd647110f6a4ee32fdb01f42ab8203b4476c24a3",
+            "table_sha256": "522dba7f01d79187a2b1c904e92ff5a91853b63da5e6f1a510d50e2cc1994f5a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25204654480330646,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803563,
+          "backend_with_key_registry_bytes": 3401084,
+          "backend_with_datrie_key_index_bytes": 3098523,
+          "full_model_serving_artifact_bytes": 4101082,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999328779127546,
+            "mean_cosine": 0.9999882584835896,
+            "p05_cosine": 0.9999770406579376,
+            "relative_l2_mean": 0.004739083006836966,
+            "relative_l2_p95": 0.006820293522058443,
+            "relative_l2_max": 0.01165596953583282,
+            "weighted_relative_l2_mean": 0.0030815487651294883,
+            "weighted_relative_frobenius": 0.005367583367488608,
+            "weighted_mean_cosine": 0.9999914177601257,
+            "max_relative_norm_change": 0.0031225575438659937
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.971319,
+            "warm_p50_ms": 0.113981,
+            "warm_p95_ms": 0.12459669999999999,
+            "warm_p99_ms": 0.12754929,
+            "samples_ms": [
+              0.127251,
+              0.117823,
+              0.114959,
+              0.113981,
+              0.114051,
+              0.11447,
+              0.115448,
+              0.113981,
+              0.114889,
+              0.113004,
+              0.113632,
+              0.11454,
+              0.116915,
+              0.120128,
+              0.114959,
+              0.112026,
+              0.113493,
+              0.11447,
+              0.113562,
+              0.12774,
+              0.124457,
+              0.113562,
+              0.113562,
+              0.113562,
+              0.11454,
+              0.11447,
+              0.112514,
+              0.117753,
+              0.116356,
+              0.112165,
+              0.113004,
+              0.113003,
+              0.113562,
+              0.113981,
+              0.112165,
+              0.113562,
+              0.111606,
+              0.112095,
+              0.111606,
+              0.112584
+            ],
+            "warm_rows_per_second": 4491976.732964266
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853797174879323,
+            "character_perplexity": 6.384014777265012,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.8752576571929952e-05,
+            "mean_prediction_kl_nats": 3.7250146321206883e-06,
+            "prediction_kl_p99_nats": 2.9429470754635976e-05,
+            "maximum_prediction_kl_nats": 0.0001005267416845651,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.03496575355529785,
+            "maximum_per_target_cross_entropy_increase": 0.021662473678588867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802310,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 124,
+              "compressed_blocks": 183,
+              "zlib_blocks": 183,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "fbf67b027d9c0471b313f44fdd647110f6a4ee32fdb01f42ab8203b4476c24a3",
+            "table_sha256": "522dba7f01d79187a2b1c904e92ff5a91853b63da5e6f1a510d50e2cc1994f5a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.38379638898186386,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803562,
+          "backend_with_key_registry_bytes": 3401083,
+          "backend_with_datrie_key_index_bytes": 3098522,
+          "full_model_serving_artifact_bytes": 4101081,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999328779127546,
+            "mean_cosine": 0.9999882584835896,
+            "p05_cosine": 0.9999770406579376,
+            "relative_l2_mean": 0.004739083006836966,
+            "relative_l2_p95": 0.006820293522058443,
+            "relative_l2_max": 0.01165596953583282,
+            "weighted_relative_l2_mean": 0.0030815487651294883,
+            "weighted_relative_frobenius": 0.005367583367488608,
+            "weighted_mean_cosine": 0.9999914177601257,
+            "max_relative_norm_change": 0.0031225575438659937
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.961891,
+            "warm_p50_ms": 0.11359649999999999,
+            "warm_p95_ms": 0.12108409999999999,
+            "warm_p99_ms": 0.12954287,
+            "samples_ms": [
+              0.130115,
+              0.116845,
+              0.11454,
+              0.11447,
+              0.113981,
+              0.1144,
+              0.113632,
+              0.114051,
+              0.114051,
+              0.116844,
+              0.113143,
+              0.113562,
+              0.113631,
+              0.113143,
+              0.114051,
+              0.111746,
+              0.113143,
+              0.113562,
+              0.119289,
+              0.115866,
+              0.112584,
+              0.120686,
+              0.113143,
+              0.114051,
+              0.111746,
+              0.111677,
+              0.113562,
+              0.113143,
+              0.113562,
+              0.112724,
+              0.113143,
+              0.115378,
+              0.113003,
+              0.114959,
+              0.111607,
+              0.128648,
+              0.112165,
+              0.111187,
+              0.112235,
+              0.114121
+            ],
+            "warm_rows_per_second": 4507181.119136593
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853797174879323,
+            "character_perplexity": 6.384014777265012,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.8752576571929952e-05,
+            "mean_prediction_kl_nats": 3.7250146321206883e-06,
+            "prediction_kl_p99_nats": 2.9429470754635976e-05,
+            "maximum_prediction_kl_nats": 0.0001005267416845651,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.03496575355529785,
+            "maximum_per_target_cross_entropy_increase": 0.021662473678588867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2802310,
+              "unique_rows": 36778,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 307,
+              "max_block_bytes": 8192,
+              "raw_blocks": 124,
+              "compressed_blocks": 183,
+              "zlib_blocks": 183,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 36778
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "fbf67b027d9c0471b313f44fdd647110f6a4ee32fdb01f42ab8203b4476c24a3",
+            "table_sha256": "522dba7f01d79187a2b1c904e92ff5a91853b63da5e6f1a510d50e2cc1994f5a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2576393000781536,
+          "representatives_sha256": "c7545f3e40b9c2c56e00c6fd4bdca8947aa24af4f5a61371a76ae6bd044a19f3",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2803562,
+          "backend_with_key_registry_bytes": 3401083,
+          "backend_with_datrie_key_index_bytes": 3098522,
+          "full_model_serving_artifact_bytes": 4101081,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999328779127546,
+            "mean_cosine": 0.9999882584835896,
+            "p05_cosine": 0.9999770406579376,
+            "relative_l2_mean": 0.004739083006836966,
+            "relative_l2_p95": 0.006820293522058443,
+            "relative_l2_max": 0.01165596953583282,
+            "weighted_relative_l2_mean": 0.0030815487651294883,
+            "weighted_relative_frobenius": 0.005367583367488608,
+            "weighted_mean_cosine": 0.9999914177601257,
+            "max_relative_norm_change": 0.0031225575438659937
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.004005,
+            "warm_p50_ms": 0.1130735,
+            "warm_p95_ms": 0.12035764999999998,
+            "warm_p99_ms": 0.12664727,
+            "samples_ms": [
+              0.117823,
+              0.11454,
+              0.113073,
+              0.114959,
+              0.115937,
+              0.120127,
+              0.12341,
+              0.119638,
+              0.113562,
+              0.11447,
+              0.113073,
+              0.113562,
+              0.113074,
+              0.116426,
+              0.112584,
+              0.112585,
+              0.113143,
+              0.113073,
+              0.113003,
+              0.120197,
+              0.112584,
+              0.112165,
+              0.112654,
+              0.113073,
+              0.113073,
+              0.113073,
+              0.128717,
+              0.112584,
+              0.120197,
+              0.112654,
+              0.112584,
+              0.113143,
+              0.111257,
+              0.118731,
+              0.112096,
+              0.111607,
+              0.113492,
+              0.113073,
+              0.112096,
+              0.113562
+            ],
+            "warm_rows_per_second": 4528028.229425994
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853797174879323,
+            "character_perplexity": 6.384014777265012,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.8752576571929952e-05,
+            "mean_prediction_kl_nats": 3.7250146321206883e-06,
+            "prediction_kl_p99_nats": 2.9429470754635976e-05,
+            "maximum_prediction_kl_nats": 0.0001005267416845651,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.03496575355529785,
+            "maximum_per_target_cross_entropy_increase": 0.021662473678588867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2161673,
+              "unique_rows": 27405,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 52,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27405
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "f26edc2c27db1202b1bd93c6f9887d1355120d2fb8b6911e9be5182e8128ca01",
+            "table_sha256": "d5cfb885300ffd29876b8e66b47d070093f7e9cfc6eea267728af740d86952ba",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.21681339899078012,
+          "representatives_sha256": "5e5affe13c9770ee8e09b268db8739f3b591e94c60fa195def4a4c9afa4d4c54",
+          "structurally_merged_rows": 9373,
+          "backend_artifact_bytes": 2162923,
+          "backend_with_key_registry_bytes": 2760444,
+          "backend_with_datrie_key_index_bytes": 2457883,
+          "full_model_serving_artifact_bytes": 3460442,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9900501912925984,
+            "mean_cosine": 0.9997672440053686,
+            "p05_cosine": 0.9988363234103511,
+            "relative_l2_mean": 0.01374289161617526,
+            "relative_l2_p95": 0.04850331401862334,
+            "relative_l2_max": 0.1411733068123005,
+            "weighted_relative_l2_mean": 0.005256490610976462,
+            "weighted_relative_frobenius": 0.012504361072079999,
+            "weighted_mean_cosine": 0.9999430264833594,
+            "max_relative_norm_change": 0.01171282268094917
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9901436254618594,
+            "mean_cosine": 0.9997735368835137,
+            "p05_cosine": 0.9988227748854258,
+            "relative_l2_mean": 0.01021942420837844,
+            "relative_l2_p95": 0.04874759081758667,
+            "relative_l2_max": 0.1404733245529406,
+            "weighted_relative_l2_mean": 0.00255980257747284,
+            "weighted_relative_frobenius": 0.011554937193940731,
+            "weighted_mean_cosine": 0.9999498965417413,
+            "max_relative_norm_change": 0.010098008799951975
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.389599,
+            "warm_p50_ms": 0.109267,
+            "warm_p95_ms": 0.11188219999999999,
+            "warm_p99_ms": 0.1199661,
+            "samples_ms": [
+              0.11447,
+              0.110699,
+              0.111606,
+              0.109232,
+              0.11035,
+              0.108813,
+              0.109302,
+              0.110349,
+              0.109721,
+              0.11021,
+              0.109861,
+              0.107416,
+              0.11021,
+              0.110628,
+              0.10972,
+              0.107905,
+              0.111187,
+              0.109302,
+              0.111257,
+              0.107835,
+              0.106997,
+              0.107835,
+              0.106508,
+              0.111257,
+              0.12348,
+              0.108394,
+              0.107835,
+              0.111746,
+              0.11021,
+              0.11021,
+              0.107905,
+              0.108394,
+              0.107416,
+              0.107416,
+              0.106927,
+              0.107905,
+              0.107905,
+              0.108324,
+              0.107835,
+              0.108813
+            ],
+            "warm_rows_per_second": 4685769.720043562
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539012885009298,
+            "character_perplexity": 6.384679474765296,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 7.536347135542887e-05,
+            "mean_prediction_kl_nats": 1.1918478848719526e-05,
+            "prediction_kl_p99_nats": 0.0001182874969071734,
+            "maximum_prediction_kl_nats": 0.005813479238591007,
+            "top1_changed_fraction": 0.002376936052752645,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5850428342819214,
+            "maximum_per_target_cross_entropy_increase": 0.11060148477554321
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00010411904161807553,
+            "mean_prediction_kl_nats": 8.02457921924959e-06,
+            "prediction_kl_p99_nats": 0.00011312616276467465,
+            "maximum_prediction_kl_nats": 0.005654594889383709,
+            "top1_changed_fraction": 0.000996779635025303,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5810846090316772,
+            "maximum_per_target_cross_entropy_increase": 0.1088036298751831
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2160841,
+              "unique_rows": 27393,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 52,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27393
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "e0c8f404698ad436b82903190fb44ff1b86d1b272ece6f794e25c18f86e921e0",
+            "table_sha256": "4454d4e7b75dfde20d97502e573db109509ad85ceda581ca2e36fe031b9e1e8e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22280641505494714,
+          "representatives_sha256": "34180d652b027806c369e5c60ee928d969bd24b330aec9f513a07e1ac98d1af9",
+          "structurally_merged_rows": 9385,
+          "backend_artifact_bytes": 2162091,
+          "backend_with_key_registry_bytes": 2759612,
+          "backend_with_datrie_key_index_bytes": 2457051,
+          "full_model_serving_artifact_bytes": 3459610,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9809002275561916,
+            "mean_cosine": 0.9997616418247693,
+            "p05_cosine": 0.9988324180154542,
+            "relative_l2_mean": 0.013804670547443734,
+            "relative_l2_p95": 0.04857311844876219,
+            "relative_l2_max": 0.19525907761117325,
+            "weighted_relative_l2_mean": 0.005316683713011929,
+            "weighted_relative_frobenius": 0.01349805851442408,
+            "weighted_mean_cosine": 0.9999377895885587,
+            "max_relative_norm_change": 0.01171282268094917
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9810075485672025,
+            "mean_cosine": 0.9997679292523991,
+            "p05_cosine": 0.998817713675655,
+            "relative_l2_mean": 0.010282776670718885,
+            "relative_l2_p95": 0.0488810630868605,
+            "relative_l2_max": 0.19477468433844242,
+            "weighted_relative_l2_mean": 0.002621579245133783,
+            "weighted_relative_frobenius": 0.012622164819903855,
+            "weighted_mean_cosine": 0.9999446580075028,
+            "max_relative_norm_change": 0.010098008799951975
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.677694,
+            "warm_p50_ms": 0.108813,
+            "warm_p95_ms": 0.113981,
+            "warm_p99_ms": 0.12173471,
+            "samples_ms": [
+              0.113981,
+              0.112096,
+              0.109791,
+              0.109721,
+              0.126692,
+              0.11028,
+              0.109302,
+              0.108812,
+              0.110769,
+              0.108813,
+              0.108324,
+              0.109302,
+              0.109301,
+              0.108743,
+              0.108812,
+              0.109232,
+              0.109791,
+              0.108813,
+              0.106927,
+              0.109232,
+              0.107416,
+              0.107347,
+              0.108813,
+              0.107835,
+              0.107416,
+              0.113981,
+              0.107416,
+              0.106439,
+              0.107905,
+              0.107835,
+              0.108394,
+              0.108743,
+              0.109372,
+              0.108324,
+              0.110279,
+              0.107835,
+              0.109371,
+              0.108394,
+              0.109372,
+              0.108813
+            ],
+            "warm_rows_per_second": 4705320.136380764
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8539514263478871,
+            "character_perplexity": 6.3849995968727224,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00012550635389250626,
+            "mean_prediction_kl_nats": 1.5419284971761743e-05,
+            "prediction_kl_p99_nats": 0.0001326295120033132,
+            "maximum_prediction_kl_nats": 0.008157706561191278,
+            "top1_changed_fraction": 0.002376936052752645,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5850428342819214,
+            "maximum_per_target_cross_entropy_increase": 0.5561943054199219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00015426336593367745,
+            "mean_prediction_kl_nats": 1.1507709268509601e-05,
+            "prediction_kl_p99_nats": 0.00012408187144064502,
+            "maximum_prediction_kl_nats": 0.008095447209669888,
+            "top1_changed_fraction": 0.000996779635025303,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5810846090316772,
+            "maximum_per_target_cross_entropy_increase": 0.5560650825500488
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2160199,
+              "unique_rows": 27383,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 49,
+              "compressed_blocks": 180,
+              "zlib_blocks": 180,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27383
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "d6a1157c5f60f37187619fbc4ff50a9b918e4d66dfeb79d16fc3c91121228544",
+            "table_sha256": "ef1a9d21b228ad68dfe3d111695162d2548e0825253498343ec06d93910528f4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.22293834504671395,
+          "representatives_sha256": "06cae1a8e19d95f9221a3e4db79c12c38b3a15b1160a2978d286e849085fb4f9",
+          "structurally_merged_rows": 9395,
+          "backend_artifact_bytes": 2161449,
+          "backend_with_key_registry_bytes": 2758970,
+          "backend_with_datrie_key_index_bytes": 2456409,
+          "full_model_serving_artifact_bytes": 3458968,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9707483615619635,
+            "mean_cosine": 0.9997535139232898,
+            "p05_cosine": 0.9988292108161556,
+            "relative_l2_mean": 0.013874160044969629,
+            "relative_l2_p95": 0.048658593607048724,
+            "relative_l2_max": 0.24306846391228168,
+            "weighted_relative_l2_mean": 0.005358170617296778,
+            "weighted_relative_frobenius": 0.014340872424942506,
+            "weighted_mean_cosine": 0.9999329512941609,
+            "max_relative_norm_change": 0.01171282268094917
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.970906149365439,
+            "mean_cosine": 0.9997597891769698,
+            "p05_cosine": 0.9988121313510618,
+            "relative_l2_mean": 0.010353640332799964,
+            "relative_l2_p95": 0.04898206383172248,
+            "relative_l2_max": 0.24246087148998058,
+            "weighted_relative_l2_mean": 0.002664026215183575,
+            "weighted_relative_frobenius": 0.013518784453951401,
+            "weighted_mean_cosine": 0.9999398142624463,
+            "max_relative_norm_change": 0.010098008799951975
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.554285,
+            "warm_p50_ms": 0.11021,
+            "warm_p95_ms": 0.11684755000000001,
+            "warm_p99_ms": 0.13651185999999998,
+            "samples_ms": [
+              0.112584,
+              0.111118,
+              0.113074,
+              0.112095,
+              0.110768,
+              0.113562,
+              0.111187,
+              0.116844,
+              0.110698,
+              0.110698,
+              0.110768,
+              0.108743,
+              0.149041,
+              0.109232,
+              0.109302,
+              0.109232,
+              0.110768,
+              0.112095,
+              0.110209,
+              0.11021,
+              0.11021,
+              0.116426,
+              0.108813,
+              0.116915,
+              0.111746,
+              0.11021,
+              0.109721,
+              0.108324,
+              0.109791,
+              0.110279,
+              0.108813,
+              0.109302,
+              0.109232,
+              0.109302,
+              0.109302,
+              0.110768,
+              0.108813,
+              0.108813,
+              0.110209,
+              0.109302
+            ],
+            "warm_rows_per_second": 4645676.43589511
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.853999535347123,
+            "character_perplexity": 6.385306780202532,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00017362254851536576,
+            "mean_prediction_kl_nats": 3.727564581693561e-05,
+            "prediction_kl_p99_nats": 0.00014125358045744517,
+            "maximum_prediction_kl_nats": 0.05768568200967636,
+            "top1_changed_fraction": 0.002453611409293053,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.5850428342819214,
+            "maximum_per_target_cross_entropy_increase": 0.5561943054199219
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00020238094406088654,
+            "mean_prediction_kl_nats": 3.349076802780913e-05,
+            "prediction_kl_p99_nats": 0.00013267263580251393,
+            "maximum_prediction_kl_nats": 0.05675248248867579,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5810846090316772,
+            "maximum_per_target_cross_entropy_increase": 0.5560650825500488
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2159238,
+              "unique_rows": 27369,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 229,
+              "max_block_bytes": 8192,
+              "raw_blocks": 54,
+              "compressed_blocks": 175,
+              "zlib_blocks": 175,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27369
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "71d8ae71b3626295e60df1ce6558160481731a519f86e15592346beb286ac512",
+            "table_sha256": "40a8d067484b995af8774ab44788662bb13f8816f15edf611320c5a507b9110e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.27339977002702653,
+          "representatives_sha256": "abbd52b531a81904fa1dfdc8657b8ded428c5c5471ba2ce2fb606fdb12a85199",
+          "structurally_merged_rows": 9409,
+          "backend_artifact_bytes": 2160488,
+          "backend_with_key_registry_bytes": 2758009,
+          "backend_with_datrie_key_index_bytes": 2455448,
+          "full_model_serving_artifact_bytes": 3458007,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.9519423666731748,
+            "mean_cosine": 0.9997315251747293,
+            "p05_cosine": 0.9988213978259789,
+            "relative_l2_mean": 0.014023950416281409,
+            "relative_l2_p95": 0.04884440100473431,
+            "relative_l2_max": 0.3088439239490936,
+            "weighted_relative_l2_mean": 0.005432842809384321,
+            "weighted_relative_frobenius": 0.017576692562555705,
+            "weighted_mean_cosine": 0.9999215989916698,
+            "max_relative_norm_change": 0.01171282268094917
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9522378764573203,
+            "mean_cosine": 0.9997378001424586,
+            "p05_cosine": 0.9988051283088357,
+            "relative_l2_mean": 0.01050519037324541,
+            "relative_l2_p95": 0.04912235471432704,
+            "relative_l2_max": 0.30808090618982736,
+            "weighted_relative_l2_mean": 0.0027396680528886347,
+            "weighted_relative_frobenius": 0.016913122642540572,
+            "weighted_mean_cosine": 0.999928465481976,
+            "max_relative_norm_change": 0.010098008799951975
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.420888,
+            "warm_p50_ms": 0.1093015,
+            "warm_p95_ms": 0.11358295,
+            "warm_p99_ms": 0.13072367,
+            "samples_ms": [
+              0.113981,
+              0.111607,
+              0.112095,
+              0.111117,
+              0.110209,
+              0.109791,
+              0.109721,
+              0.108882,
+              0.109302,
+              0.108883,
+              0.109301,
+              0.108394,
+              0.10979,
+              0.106927,
+              0.108324,
+              0.107835,
+              0.106927,
+              0.113562,
+              0.108813,
+              0.109232,
+              0.106927,
+              0.107835,
+              0.108813,
+              0.110769,
+              0.141428,
+              0.113003,
+              0.110768,
+              0.110209,
+              0.108743,
+              0.108324,
+              0.109232,
+              0.109302,
+              0.109231,
+              0.108813,
+              0.111188,
+              0.109302,
+              0.108394,
+              0.107975,
+              0.110699,
+              0.11028
+            ],
+            "warm_rows_per_second": 4684290.700493589
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8541026324868122,
+            "character_perplexity": 6.385965121003553,
+            "next_character_accuracy": 0.5023002606962123,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00027674290380804155,
+            "mean_prediction_kl_nats": 4.089533978135044e-05,
+            "prediction_kl_p99_nats": 0.00015913884361144735,
+            "maximum_prediction_kl_nats": 0.05768568200967636,
+            "top1_changed_fraction": 0.002453611409293053,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.3615862131118774,
+            "maximum_per_target_cross_entropy_increase": 0.5845675468444824
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00030550426441472715,
+            "mean_prediction_kl_nats": 3.712668694624218e-05,
+            "prediction_kl_p99_nats": 0.00014993490974764533,
+            "maximum_prediction_kl_nats": 0.05675248248867579,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.3547651767730713,
+            "maximum_per_target_cross_entropy_increase": 0.5863943099975586
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              36778,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2500904,
+              "artifact_bytes": 2157420,
+              "unique_rows": 27342,
+              "row_map_bytes": 294224,
+              "n_rows": 36778,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 228,
+              "max_block_bytes": 8192,
+              "raw_blocks": 49,
+              "compressed_blocks": 179,
+              "zlib_blocks": 179,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 27342
+            },
+            "source_float32_sha256": "b64693e53f10f160fa384ab8c75dd6a239d68853eb1740a7493797df4b31c874",
+            "decoded_float32_sha256": "e024b76412db848c22f51f6d98ad53262f492c8cb79762aa1f652a285378830e",
+            "table_sha256": "24e92a181c4c69b9f8656d927bc2461c9d867b8e6d211edb3a15eb2e30957dea",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2204549261368811,
+          "representatives_sha256": "9cbd43f53d4fb91de9d18e8d449a3b318a01ede0ae91fc7cd567d5777161b0d0",
+          "structurally_merged_rows": 9436,
+          "backend_artifact_bytes": 2158670,
+          "backend_with_key_registry_bytes": 2756191,
+          "backend_with_datrie_key_index_bytes": 2453630,
+          "full_model_serving_artifact_bytes": 3456189,
+          "fidelity_vs_float32": {
+            "rows": 36778,
+            "minimum_cosine": 0.8993976984974948,
+            "mean_cosine": 0.9996728223469323,
+            "p05_cosine": 0.9988108110186172,
+            "relative_l2_mean": 0.014325679044866257,
+            "relative_l2_p95": 0.049039959300843365,
+            "relative_l2_max": 0.4471761870867479,
+            "weighted_relative_l2_mean": 0.005501955084736431,
+            "weighted_relative_frobenius": 0.01870043506699296,
+            "weighted_mean_cosine": 0.9999082514088644,
+            "max_relative_norm_change": 0.01171282268094917
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 36778,
+            "minimum_cosine": 0.9002733459621711,
+            "mean_cosine": 0.9996790761147037,
+            "p05_cosine": 0.9987953081996668,
+            "relative_l2_mean": 0.010810707385642847,
+            "relative_l2_p95": 0.04928816315452132,
+            "relative_l2_max": 0.44525560469347747,
+            "weighted_relative_l2_mean": 0.0028097726571443588,
+            "weighted_relative_frobenius": 0.018076661725040872,
+            "weighted_mean_cosine": 0.9999151213083863,
+            "max_relative_norm_change": 0.010098008799951975
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.400425,
+            "warm_p50_ms": 0.11017450000000001,
+            "warm_p95_ms": 0.1145224,
+            "warm_p99_ms": 0.12122638,
+            "samples_ms": [
+              0.113003,
+              0.112584,
+              0.11447,
+              0.111118,
+              0.109302,
+              0.111257,
+              0.111187,
+              0.111117,
+              0.108813,
+              0.109302,
+              0.109232,
+              0.110279,
+              0.109232,
+              0.109791,
+              0.10972,
+              0.108953,
+              0.109721,
+              0.111117,
+              0.109371,
+              0.109302,
+              0.11021,
+              0.10986,
+              0.108813,
+              0.109791,
+              0.108812,
+              0.11028,
+              0.11028,
+              0.115518,
+              0.10979,
+              0.111117,
+              0.107346,
+              0.124876,
+              0.10986,
+              0.110209,
+              0.112514,
+              0.110698,
+              0.110349,
+              0.109791,
+              0.11014,
+              0.111257
+            ],
+            "warm_rows_per_second": 4647173.34773473
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8540404612293304,
+            "character_perplexity": 6.385568109863214,
+            "next_character_accuracy": 0.5022235853396718,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00021455637399936685,
+            "mean_prediction_kl_nats": 7.767856944016081e-05,
+            "prediction_kl_p99_nats": 0.00018685498443185095,
+            "maximum_prediction_kl_nats": 0.1874569444533677,
+            "top1_changed_fraction": 0.002606962122373869,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.3615862131118774,
+            "maximum_per_target_cross_entropy_increase": 0.5845675468444824
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00024331594653168061,
+            "mean_prediction_kl_nats": 7.382736956145754e-05,
+            "prediction_kl_p99_nats": 0.00017967533745234001,
+            "maximum_prediction_kl_nats": 0.18743622827197054,
+            "top1_changed_fraction": 0.0012268057046465265,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.3547651767730713,
+            "maximum_per_target_cross_entropy_increase": 0.5863943099975586
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.853825927869258,
+          "character_perplexity": 6.384198339416614,
+          "next_character_accuracy": 0.5023002606962123,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7280639176093653,
+          "character_perplexity": 5.629743702661178,
+          "next_character_accuracy": 0.5292494058115464,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.9",
+          "backend_with_key_registry_bytes": 7422143,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7281426950457552,
+            "character_perplexity": 5.630187216906834,
+            "next_character_accuracy": 0.5290193973779038,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 7.878053941357795e-05,
+            "mean_prediction_kl_nats": 7.239235945488115e-05,
+            "prediction_kl_p99_nats": 0.00025523719050292914,
+            "maximum_prediction_kl_nats": 0.15028831154148714,
+            "top1_changed_fraction": 0.0007666947788085563,
+            "accuracy_change": -0.00023000843364262558,
+            "maximum_absolute_logit_change": 1.3504877090454102,
+            "maximum_per_target_cross_entropy_increase": 0.8670740127563477
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00012532674483123354,
+              0.000296544972959154
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.9",
+          "backend_with_key_registry_bytes": 4133142,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7281424986147633,
+            "character_perplexity": 5.630186110963683,
+            "next_character_accuracy": 0.5290193973779038,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 7.858409296605416e-05,
+            "mean_prediction_kl_nats": 7.239406989054103e-05,
+            "prediction_kl_p99_nats": 0.0002553027836586025,
+            "maximum_prediction_kl_nats": 0.15030648367116142,
+            "top1_changed_fraction": 0.0007666947788085563,
+            "accuracy_change": -0.00023000843364262558,
+            "maximum_absolute_logit_change": 1.349926471710205,
+            "maximum_per_target_cross_entropy_increase": 0.867246150970459
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0001246097273672068,
+              0.00029588735143539364
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.9",
+          "backend_with_key_registry_bytes": 2756191,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7281543275316205,
+            "character_perplexity": 5.6302527103609785,
+            "next_character_accuracy": 0.5291727363336656,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 9.041400935520268e-05,
+            "mean_prediction_kl_nats": 9.501836386167312e-05,
+            "prediction_kl_p99_nats": 0.0002800923076272734,
+            "maximum_prediction_kl_nats": 0.14853157432377162,
+            "top1_changed_fraction": 0.0024534232921873803,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 1.359821081161499,
+            "maximum_per_target_cross_entropy_increase": 0.8680667877197266
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00016767168309531454,
+              0.00033279514032229094
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7280637701909376,
+            "character_perplexity": 5.629742872733274,
+            "next_character_accuracy": 0.5292494058115464,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.4741841682677274e-07,
+            "mean_prediction_kl_nats": 3.973670847115932e-09,
+            "prediction_kl_p99_nats": 2.8094301446586266e-08,
+            "maximum_prediction_kl_nats": 6.983048011522801e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0011174902319908142,
+            "maximum_per_target_cross_entropy_increase": 0.000797271728515625
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.728062761668189,
+            "character_perplexity": 5.629737195012381,
+            "next_character_accuracy": 0.5293260752894273,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.1559405082255191e-06,
+            "mean_prediction_kl_nats": 3.65344786391907e-06,
+            "prediction_kl_p99_nats": 2.9962297667047917e-05,
+            "maximum_prediction_kl_nats": 0.00014314058747329998,
+            "top1_changed_fraction": 0.0011500421682128345,
+            "accuracy_change": 7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.038996338844299316,
+            "maximum_per_target_cross_entropy_increase": 0.033242225646972656
+          }
+        }
+      },
+      "checkpoint_sha256": "b8b0017a1ced25157ff108b6d38a5aaf5dfe56e59ce071a16755aa916bd279f5",
+      "registry_sha256": "e22a7692100a89679e3088226c3399678ae46a06d73d93bef7d898aa00f6fb7c"
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "rows": 43152,
+      "dim": 64,
+      "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+      "source_float32_bytes": 11046912,
+      "key_registry_bytes": 736107,
+      "unchanged_backbone_artifact_bytes": 827998,
+      "alternative_datrie_key_index_bytes": 346160,
+      "query_rows": 512,
+      "query_ids_sha256": "43ca78408803e060726877734dd5761b4e85ad9be7de5a6b6d8601f32db85068",
+      "frequency_trace_sha256": "7ba41132ac5296b1ee890e8c97c4f892398df8fb97e4bbb475dab44b5c5af0cc",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 11046912,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "table_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05877554905600846,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 11047717,
+          "backend_with_key_registry_bytes": 11783824,
+          "backend_with_datrie_key_index_bytes": 11393877,
+          "full_model_serving_artifact_bytes": 12611822,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.23802,
+            "warm_p50_ms": 0.046863,
+            "warm_p95_ms": 0.04781735,
+            "warm_p99_ms": 0.0516192,
+            "samples_ms": [
+              0.053499,
+              0.047352,
+              0.046863,
+              0.046375,
+              0.047283,
+              0.047772,
+              0.047352,
+              0.048679,
+              0.047213,
+              0.047282,
+              0.047282,
+              0.046864,
+              0.046794,
+              0.046863,
+              0.046863,
+              0.047283,
+              0.047353,
+              0.046444,
+              0.047282,
+              0.046864,
+              0.045886,
+              0.046444,
+              0.045886,
+              0.045886,
+              0.045886,
+              0.046304,
+              0.046305,
+              0.046305,
+              0.046305,
+              0.046375,
+              0.046864,
+              0.046375,
+              0.046863,
+              0.046374,
+              0.047352,
+              0.046794,
+              0.046375,
+              0.046794,
+              0.047352,
+              0.047282
+            ],
+            "warm_rows_per_second": 10925463.585344514
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772440363845078,
+            "character_perplexity": 6.535468506423138,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10654345,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "table_sha256": "8480d0c01978ff0fa6f93d6530acada4a8d45fc316a37a67164b316eef6833a2",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9206812500488013,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10655557,
+          "backend_with_key_registry_bytes": 11391664,
+          "backend_with_datrie_key_index_bytes": 11001717,
+          "full_model_serving_artifact_bytes": 12219662,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.194159,
+            "warm_p50_ms": 0.055803,
+            "warm_p95_ms": 0.05771344999999999,
+            "warm_p99_ms": 0.058178,
+            "samples_ms": [
+              0.058178,
+              0.057689,
+              0.05727,
+              0.0572,
+              0.058178,
+              0.055873,
+              0.056781,
+              0.055873,
+              0.055803,
+              0.056711,
+              0.055734,
+              0.055803,
+              0.055314,
+              0.055803,
+              0.055314,
+              0.055804,
+              0.055804,
+              0.054407,
+              0.055803,
+              0.055314,
+              0.054406,
+              0.054336,
+              0.053428,
+              0.054895,
+              0.055314,
+              0.055803,
+              0.055803,
+              0.055384,
+              0.054407,
+              0.054407,
+              0.054476,
+              0.056292,
+              0.055315,
+              0.055384,
+              0.055454,
+              0.055803,
+              0.055384,
+              0.055873,
+              0.055385,
+              0.055803
+            ],
+            "warm_rows_per_second": 9175133.953371683
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772440363845078,
+            "character_perplexity": 6.535468506423138,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10654345,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "table_sha256": "8480d0c01978ff0fa6f93d6530acada4a8d45fc316a37a67164b316eef6833a2",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 1.0852725929580629,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10655556,
+          "backend_with_key_registry_bytes": 11391663,
+          "backend_with_datrie_key_index_bytes": 11001716,
+          "full_model_serving_artifact_bytes": 12219661,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.192204,
+            "warm_p50_ms": 0.0548955,
+            "warm_p95_ms": 0.056892899999999996,
+            "warm_p99_ms": 0.05947874,
+            "samples_ms": [
+              0.057689,
+              0.055384,
+              0.056851,
+              0.055385,
+              0.055384,
+              0.055803,
+              0.056781,
+              0.054826,
+              0.054895,
+              0.054896,
+              0.054407,
+              0.054407,
+              0.054477,
+              0.054476,
+              0.054477,
+              0.055454,
+              0.055873,
+              0.054476,
+              0.055384,
+              0.054477,
+              0.054896,
+              0.053988,
+              0.055873,
+              0.060623,
+              0.053918,
+              0.054826,
+              0.054895,
+              0.054406,
+              0.054895,
+              0.053847,
+              0.054895,
+              0.055384,
+              0.055314,
+              0.055384,
+              0.054057,
+              0.055384,
+              0.054407,
+              0.054896,
+              0.054896,
+              0.054337
+            ],
+            "warm_rows_per_second": 9326811.851608966
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772440363845078,
+            "character_perplexity": 6.535468506423138,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10654345,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "table_sha256": "8480d0c01978ff0fa6f93d6530acada4a8d45fc316a37a67164b316eef6833a2",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9405129118822515,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10655556,
+          "backend_with_key_registry_bytes": 11391663,
+          "backend_with_datrie_key_index_bytes": 11001716,
+          "full_model_serving_artifact_bytes": 12219661,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.215881,
+            "warm_p50_ms": 0.054826,
+            "warm_p95_ms": 0.05629205,
+            "warm_p99_ms": 0.06579252999999999,
+            "samples_ms": [
+              0.056293,
+              0.054336,
+              0.055384,
+              0.054895,
+              0.053987,
+              0.054895,
+              0.055873,
+              0.054407,
+              0.054896,
+              0.054896,
+              0.054407,
+              0.056292,
+              0.055803,
+              0.055803,
+              0.054407,
+              0.055873,
+              0.054756,
+              0.054337,
+              0.054896,
+              0.054895,
+              0.054895,
+              0.054895,
+              0.054965,
+              0.054476,
+              0.055873,
+              0.055384,
+              0.054477,
+              0.053987,
+              0.054406,
+              0.054406,
+              0.071866,
+              0.054337,
+              0.054826,
+              0.054477,
+              0.053499,
+              0.054476,
+              0.054407,
+              0.053429,
+              0.054337,
+              0.054826
+            ],
+            "warm_rows_per_second": 9338634.954218801
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772440363845078,
+            "character_perplexity": 6.535468506423138,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7473752,
+              "unique_rows": 29823,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29823
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "8a35a6bb7b8b8445e7c478a445afbd7401a67bb01ff5e989208f27b0aa65dfa1",
+            "table_sha256": "573970332d020d8c40ce39f2bd889280932f6197833c1a35716ebef2cfc42ef9",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.7199056609533727,
+          "representatives_sha256": "f84ee038c6582695258bf598118e9c5dda39bfc6220d2752237739d1957b8452",
+          "structurally_merged_rows": 13329,
+          "backend_artifact_bytes": 7474959,
+          "backend_with_key_registry_bytes": 8211066,
+          "backend_with_datrie_key_index_bytes": 7821119,
+          "full_model_serving_artifact_bytes": 9039064,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901374270621742,
+            "mean_cosine": 0.9997243918755482,
+            "p05_cosine": 0.9987015070238352,
+            "relative_l2_mean": 0.012410471547235846,
+            "relative_l2_p95": 0.05118710693197225,
+            "relative_l2_max": 0.14041193528604085,
+            "weighted_relative_l2_mean": 0.001980608544931826,
+            "weighted_relative_frobenius": 0.012203466418320411,
+            "weighted_mean_cosine": 0.9999605554841995,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901374270621742,
+            "mean_cosine": 0.9997243918755482,
+            "p05_cosine": 0.9987015070238352,
+            "relative_l2_mean": 0.012410471547235846,
+            "relative_l2_p95": 0.05118710693197225,
+            "relative_l2_max": 0.14041193528604085,
+            "weighted_relative_l2_mean": 0.001980608544931826,
+            "weighted_relative_frobenius": 0.012203466418320411,
+            "weighted_mean_cosine": 0.9999605554841995,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.36228,
+            "warm_p50_ms": 0.054337,
+            "warm_p95_ms": 0.056781,
+            "warm_p99_ms": 0.05793146,
+            "samples_ms": [
+              0.058667,
+              0.056781,
+              0.054826,
+              0.054337,
+              0.054477,
+              0.055873,
+              0.054895,
+              0.05301,
+              0.054476,
+              0.053499,
+              0.053429,
+              0.056781,
+              0.054826,
+              0.054406,
+              0.054896,
+              0.053359,
+              0.054407,
+              0.053988,
+              0.053988,
+              0.053359,
+              0.052939,
+              0.055384,
+              0.055803,
+              0.054337,
+              0.053987,
+              0.054476,
+              0.053987,
+              0.053917,
+              0.053009,
+              0.053428,
+              0.054825,
+              0.05301,
+              0.053499,
+              0.053848,
+              0.053429,
+              0.054406,
+              0.053359,
+              0.053917,
+              0.054476,
+              0.054476
+            ],
+            "warm_rows_per_second": 9422676.997257853
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8771682882462368,
+            "character_perplexity": 6.534973475600116,
+            "next_character_accuracy": 0.49539947860757555,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -7.574526945309828e-05,
+            "mean_prediction_kl_nats": 9.795638979163037e-06,
+            "prediction_kl_p99_nats": 0.00010671248000819322,
+            "maximum_prediction_kl_nats": 0.01692303822047178,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.37192267179489136,
+            "maximum_per_target_cross_entropy_increase": 0.18367242813110352
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -7.574526945309828e-05,
+            "mean_prediction_kl_nats": 9.795638979163037e-06,
+            "prediction_kl_p99_nats": 0.00010671248000819322,
+            "maximum_prediction_kl_nats": 0.01692303822047178,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.37192267179489136,
+            "maximum_per_target_cross_entropy_increase": 0.18367242813110352
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7468886,
+              "unique_rows": 29803,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29803
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "4905a6fad18e32c4059a82c759792fae16d46000850d13902df0df023d5dbe7e",
+            "table_sha256": "d8c3b793fc309483474b6defe53c3e1ae02c927f98806219fdfa1163c586939b",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6770146200433373,
+          "representatives_sha256": "a34e8833b8f4861f00f182ac6f1b04124f83345e2b1b6930eb5030e02ba0e016",
+          "structurally_merged_rows": 13349,
+          "backend_artifact_bytes": 7470093,
+          "backend_with_key_registry_bytes": 8206200,
+          "backend_with_datrie_key_index_bytes": 7816253,
+          "full_model_serving_artifact_bytes": 9034198,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9811231151394353,
+            "mean_cosine": 0.9997164520711441,
+            "p05_cosine": 0.9986965485510646,
+            "relative_l2_mean": 0.012499865036091668,
+            "relative_l2_p95": 0.051271698632055766,
+            "relative_l2_max": 0.1939953608517965,
+            "weighted_relative_l2_mean": 0.0020205899641472323,
+            "weighted_relative_frobenius": 0.01315867579936367,
+            "weighted_mean_cosine": 0.9999569719651504,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9811231151394353,
+            "mean_cosine": 0.9997164520711441,
+            "p05_cosine": 0.9986965485510646,
+            "relative_l2_mean": 0.012499865036091668,
+            "relative_l2_p95": 0.051271698632055766,
+            "relative_l2_max": 0.1939953608517965,
+            "weighted_relative_l2_mean": 0.0020205899641472323,
+            "weighted_relative_frobenius": 0.01315867579936367,
+            "weighted_mean_cosine": 0.9999569719651504,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.567194,
+            "warm_p50_ms": 0.055838,
+            "warm_p95_ms": 0.0572035,
+            "warm_p99_ms": 0.05841985,
+            "samples_ms": [
+              0.059155,
+              0.05727,
+              0.055873,
+              0.055384,
+              0.056362,
+              0.055454,
+              0.056781,
+              0.056851,
+              0.05685,
+              0.056292,
+              0.056292,
+              0.056293,
+              0.055384,
+              0.056292,
+              0.055873,
+              0.055384,
+              0.054895,
+              0.056362,
+              0.056781,
+              0.055314,
+              0.056292,
+              0.055314,
+              0.055873,
+              0.055874,
+              0.055314,
+              0.055733,
+              0.055314,
+              0.055314,
+              0.056712,
+              0.055315,
+              0.054825,
+              0.054756,
+              0.053917,
+              0.055873,
+              0.055244,
+              0.055803,
+              0.055385,
+              0.055315,
+              0.0572,
+              0.054965
+            ],
+            "warm_rows_per_second": 9169382.857552204
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8771938659447684,
+            "character_perplexity": 6.535140627319256,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -5.016918122395854e-05,
+            "mean_prediction_kl_nats": 2.704286829560198e-05,
+            "prediction_kl_p99_nats": 0.00012042148487811871,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.45440253615379333,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -5.016918122395854e-05,
+            "mean_prediction_kl_nats": 2.704286829560198e-05,
+            "prediction_kl_p99_nats": 0.00012042148487811871,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.45440253615379333,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7467319,
+              "unique_rows": 29796,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29796
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "76e59af330807446eb3388016584f5b1ffe5b9530a0dc641f5cfadd3b45bf019",
+            "table_sha256": "55c5d6bc568d7c82b224a6314e8d4e023289730c725eaa47455202b3ca76fc4a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6827592109329998,
+          "representatives_sha256": "cab20745ce73829806d07741efde1373edcc1f289f171b2fb91379dfa4cdcc3d",
+          "structurally_merged_rows": 13356,
+          "backend_artifact_bytes": 7468526,
+          "backend_with_key_registry_bytes": 8204633,
+          "backend_with_datrie_key_index_bytes": 7814686,
+          "full_model_serving_artifact_bytes": 9032631,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9701550536775938,
+            "mean_cosine": 0.999708000910412,
+            "p05_cosine": 0.9986934950654631,
+            "relative_l2_mean": 0.012570300126435703,
+            "relative_l2_p95": 0.05136065697318756,
+            "relative_l2_max": 0.24360219263104912,
+            "weighted_relative_l2_mean": 0.002048947266653511,
+            "weighted_relative_frobenius": 0.013740653481808742,
+            "weighted_mean_cosine": 0.9999537070465959,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9701550536775938,
+            "mean_cosine": 0.999708000910412,
+            "p05_cosine": 0.9986934950654631,
+            "relative_l2_mean": 0.012570300126435703,
+            "relative_l2_p95": 0.05136065697318756,
+            "relative_l2_max": 0.24360219263104912,
+            "weighted_relative_l2_mean": 0.002048947266653511,
+            "weighted_relative_frobenius": 0.013740653481808742,
+            "weighted_mean_cosine": 0.9999537070465959,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.579905,
+            "warm_p50_ms": 0.055384,
+            "warm_p95_ms": 0.05738524999999999,
+            "warm_p99_ms": 0.06937342999999999,
+            "samples_ms": [
+              0.059575,
+              0.05727,
+              0.056362,
+              0.055314,
+              0.054336,
+              0.056781,
+              0.055873,
+              0.055873,
+              0.055454,
+              0.055873,
+              0.055873,
+              0.056362,
+              0.056781,
+              0.05727,
+              0.056781,
+              0.054896,
+              0.054477,
+              0.054966,
+              0.054966,
+              0.055384,
+              0.054895,
+              0.075638,
+              0.054895,
+              0.053987,
+              0.055384,
+              0.054895,
+              0.053917,
+              0.053917,
+              0.053917,
+              0.054476,
+              0.053987,
+              0.054407,
+              0.055454,
+              0.054965,
+              0.054406,
+              0.055803,
+              0.055384,
+              0.054895,
+              0.055873,
+              0.055454
+            ],
+            "warm_rows_per_second": 9244547.161635129
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877203405332208,
+            "character_perplexity": 6.535202968855021,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.063022686975546e-05,
+            "mean_prediction_kl_nats": 2.8766093224460522e-05,
+            "prediction_kl_p99_nats": 0.00013629267134794706,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5846255421638489,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.063022686975546e-05,
+            "mean_prediction_kl_nats": 2.8766093224460522e-05,
+            "prediction_kl_p99_nats": 0.00013629267134794706,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5846255421638489,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7462811,
+              "unique_rows": 29777,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 931,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 931,
+              "zlib_blocks": 931,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29777
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "3331c4ea80f85f10466abdaab1952bd3e75c40cb1a5f35b4f90f614397cf8432",
+            "table_sha256": "6367f0e13a691b1f6c9774871b1373af8ed7f578f39cc3bc277f2594368f6437",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6852218171115965,
+          "representatives_sha256": "44d86fc4452c21f6da8ffbcc5e605d507676bb84feeeeeb1b86615155177f01b",
+          "structurally_merged_rows": 13375,
+          "backend_artifact_bytes": 7464018,
+          "backend_with_key_registry_bytes": 8200125,
+          "backend_with_datrie_key_index_bytes": 7810178,
+          "full_model_serving_artifact_bytes": 9028123,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9510951584267655,
+            "mean_cosine": 0.9996851725896819,
+            "p05_cosine": 0.9986878807415716,
+            "relative_l2_mean": 0.012730953354210144,
+            "relative_l2_p95": 0.05149837886632302,
+            "relative_l2_max": 0.313052181227116,
+            "weighted_relative_l2_mean": 0.002212216378153698,
+            "weighted_relative_frobenius": 0.019003876776819983,
+            "weighted_mean_cosine": 0.9999304818236316,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9510951584267655,
+            "mean_cosine": 0.9996851725896819,
+            "p05_cosine": 0.9986878807415716,
+            "relative_l2_mean": 0.012730953354210144,
+            "relative_l2_p95": 0.05149837886632302,
+            "relative_l2_max": 0.313052181227116,
+            "weighted_relative_l2_mean": 0.002212216378153698,
+            "weighted_relative_frobenius": 0.019003876776819983,
+            "weighted_mean_cosine": 0.9999304818236316,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.525079,
+            "warm_p50_ms": 0.0548605,
+            "warm_p95_ms": 0.05589825,
+            "warm_p99_ms": 0.06893617999999999,
+            "samples_ms": [
+              0.057689,
+              0.055804,
+              0.054895,
+              0.055384,
+              0.054895,
+              0.055454,
+              0.055384,
+              0.054406,
+              0.053987,
+              0.055384,
+              0.054336,
+              0.053428,
+              0.053987,
+              0.054406,
+              0.053499,
+              0.054476,
+              0.055384,
+              0.053429,
+              0.054337,
+              0.053499,
+              0.054895,
+              0.054407,
+              0.054477,
+              0.055385,
+              0.054966,
+              0.053918,
+              0.054337,
+              0.054826,
+              0.055384,
+              0.053498,
+              0.055314,
+              0.054406,
+              0.054895,
+              0.054477,
+              0.054407,
+              0.055803,
+              0.054896,
+              0.076127,
+              0.055384,
+              0.054895
+            ],
+            "warm_rows_per_second": 9332762.187730698
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8769014268564972,
+            "character_perplexity": 6.533229776169881,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003425508440682324,
+            "mean_prediction_kl_nats": 4.486066248487181e-05,
+            "prediction_kl_p99_nats": 0.00028717883435742936,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.9886711835861206,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003425508440682324,
+            "mean_prediction_kl_nats": 4.486066248487181e-05,
+            "prediction_kl_p99_nats": 0.00028717883435742936,
+            "maximum_prediction_kl_nats": 0.030118161308665473,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.9886711835861206,
+            "maximum_per_target_cross_entropy_increase": 0.4206380844116211
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7454598,
+              "unique_rows": 29742,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 930,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 930,
+              "zlib_blocks": 930,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29742
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "9238f59bb5d2e8d5c0cbe6fed8ee9ae2a6a730e6dfda6a2239dfef8ad277d2ba",
+            "table_sha256": "51d61f3f0511a39080d1da0564e367a9ed2814b1f1eaed94ef2771056c7687bd",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6819237689487636,
+          "representatives_sha256": "064b7af427b129290dc557791b38db34694a99a1a4dbab35ebef74e4b4d53644",
+          "structurally_merged_rows": 13410,
+          "backend_artifact_bytes": 7455805,
+          "backend_with_key_registry_bytes": 8191912,
+          "backend_with_datrie_key_index_bytes": 7801965,
+          "full_model_serving_artifact_bytes": 9019910,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9029576241944695,
+            "mean_cosine": 0.9996150002872196,
+            "p05_cosine": 0.9986763907676827,
+            "relative_l2_mean": 0.013093520889840756,
+            "relative_l2_p95": 0.05173769988680542,
+            "relative_l2_max": 0.4406349148093082,
+            "weighted_relative_l2_mean": 0.002310199870706357,
+            "weighted_relative_frobenius": 0.022844354660961463,
+            "weighted_mean_cosine": 0.9999118104322755,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9029576241944695,
+            "mean_cosine": 0.9996150002872196,
+            "p05_cosine": 0.9986763907676827,
+            "relative_l2_mean": 0.013093520889840756,
+            "relative_l2_p95": 0.05173769988680542,
+            "relative_l2_max": 0.4406349148093082,
+            "weighted_relative_l2_mean": 0.002310199870706357,
+            "weighted_relative_frobenius": 0.022844354660961463,
+            "weighted_mean_cosine": 0.9999118104322755,
+            "max_relative_norm_change": 0.010088294764666801
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.67461,
+            "warm_p50_ms": 0.0544415,
+            "warm_p95_ms": 0.05587305,
+            "warm_p99_ms": 0.057023239999999996,
+            "samples_ms": [
+              0.057758,
+              0.055384,
+              0.055384,
+              0.055384,
+              0.055454,
+              0.055873,
+              0.055385,
+              0.055874,
+              0.05294,
+              0.054407,
+              0.054895,
+              0.054337,
+              0.053429,
+              0.053917,
+              0.055384,
+              0.055384,
+              0.054896,
+              0.05308,
+              0.054895,
+              0.054336,
+              0.054825,
+              0.05294,
+              0.054476,
+              0.053428,
+              0.054965,
+              0.055384,
+              0.053917,
+              0.054336,
+              0.053429,
+              0.054407,
+              0.054896,
+              0.05308,
+              0.053918,
+              0.053499,
+              0.053428,
+              0.054895,
+              0.054895,
+              0.053498,
+              0.053987,
+              0.053429
+            ],
+            "warm_rows_per_second": 9404590.24824812
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8769683562712904,
+            "character_perplexity": 6.533667056048789,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00027564211694667493,
+            "mean_prediction_kl_nats": 7.812557434837714e-05,
+            "prediction_kl_p99_nats": 0.0004873318513749142,
+            "maximum_prediction_kl_nats": 0.10622121741628762,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.421809434890747,
+            "maximum_per_target_cross_entropy_increase": 0.9145984649658203
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00027564211694667493,
+            "mean_prediction_kl_nats": 7.812557434837714e-05,
+            "prediction_kl_p99_nats": 0.0004873318513749142,
+            "maximum_prediction_kl_nats": 0.10622121741628762,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.421809434890747,
+            "maximum_per_target_cross_entropy_increase": 0.9145984649658203
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 5523456,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "212e57b5fa9fcef9bbaf640d7bbb586eb6dec1a60e9e380099be530a0d30a4a2",
+            "table_sha256": "90c4d98b998a5e102a57ac4c4bbec828fa37973f1ce190c7e5052edf80b98b29",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0683542201295495,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5524261,
+          "backend_with_key_registry_bytes": 6260368,
+          "backend_with_datrie_key_index_bytes": 5870421,
+          "full_model_serving_artifact_bytes": 7088366,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.999999952237527,
+            "mean_cosine": 0.9999999791989146,
+            "p05_cosine": 0.9999999715381719,
+            "relative_l2_mean": 0.00020643723533316717,
+            "relative_l2_p95": 0.00024222825928337357,
+            "relative_l2_max": 0.0003103547968601321,
+            "weighted_relative_l2_mean": 7.796723903184389e-05,
+            "weighted_relative_frobenius": 0.00020660422892998176,
+            "weighted_mean_cosine": 0.9999999922088666,
+            "max_relative_norm_change": 0.00017841050618007463
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.317848,
+            "warm_p50_ms": 0.139613,
+            "warm_p95_ms": 0.14421844999999994,
+            "warm_p99_ms": 0.17171321999999997,
+            "samples_ms": [
+              0.161403,
+              0.142406,
+              0.139543,
+              0.140032,
+              0.14094,
+              0.139054,
+              0.140451,
+              0.139124,
+              0.139613,
+              0.139543,
+              0.139473,
+              0.138635,
+              0.140032,
+              0.139543,
+              0.140031,
+              0.138565,
+              0.139054,
+              0.139613,
+              0.139613,
+              0.140101,
+              0.138146,
+              0.138146,
+              0.140101,
+              0.140451,
+              0.139613,
+              0.139124,
+              0.138635,
+              0.138076,
+              0.178305,
+              0.143314,
+              0.140032,
+              0.140102,
+              0.141359,
+              0.140102,
+              0.140032,
+              0.138635,
+              0.140032,
+              0.140521,
+              0.139543,
+              0.139123
+            ],
+            "warm_rows_per_second": 3667280.267596857
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877244241302235,
+            "character_perplexity": 6.535469845656627,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.049177481175951e-07,
+            "mean_prediction_kl_nats": 4.309312088974973e-09,
+            "prediction_kl_p99_nats": 3.498371872602242e-08,
+            "maximum_prediction_kl_nats": 7.336224652209635e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001119852066040039,
+            "maximum_per_target_cross_entropy_increase": 0.0007524490356445312
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5455215,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "212e57b5fa9fcef9bbaf640d7bbb586eb6dec1a60e9e380099be530a0d30a4a2",
+            "table_sha256": "1d743e28d52c9816eba61c77df349b65b520ac69ed444b0daef85dd12dcce1d4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5009870349895209,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5456423,
+          "backend_with_key_registry_bytes": 6192530,
+          "backend_with_datrie_key_index_bytes": 5802583,
+          "full_model_serving_artifact_bytes": 7020528,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.999999952237527,
+            "mean_cosine": 0.9999999791989146,
+            "p05_cosine": 0.9999999715381719,
+            "relative_l2_mean": 0.00020643723533316717,
+            "relative_l2_p95": 0.00024222825928337357,
+            "relative_l2_max": 0.0003103547968601321,
+            "weighted_relative_l2_mean": 7.796723903184389e-05,
+            "weighted_relative_frobenius": 0.00020660422892998176,
+            "weighted_mean_cosine": 0.9999999922088666,
+            "max_relative_norm_change": 0.00017841050618007463
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.90355,
+            "warm_p50_ms": 0.1474005,
+            "warm_p95_ms": 0.1495797,
+            "warm_p99_ms": 0.17641738999999998,
+            "samples_ms": [
+              0.149461,
+              0.148553,
+              0.147155,
+              0.148553,
+              0.147156,
+              0.148133,
+              0.147645,
+              0.148553,
+              0.149111,
+              0.147644,
+              0.148553,
+              0.147575,
+              0.147155,
+              0.147156,
+              0.147575,
+              0.147644,
+              0.147226,
+              0.147156,
+              0.146666,
+              0.145759,
+              0.147156,
+              0.192134,
+              0.151835,
+              0.148133,
+              0.148064,
+              0.148064,
+              0.146597,
+              0.147575,
+              0.145689,
+              0.146597,
+              0.146666,
+              0.147645,
+              0.147156,
+              0.147225,
+              0.146178,
+              0.147155,
+              0.146667,
+              0.146177,
+              0.147156,
+              0.147575
+            ],
+            "warm_rows_per_second": 3473529.6013242835
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877244241302235,
+            "character_perplexity": 6.535469845656627,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.049177481175951e-07,
+            "mean_prediction_kl_nats": 4.309312088974973e-09,
+            "prediction_kl_p99_nats": 3.498371872602242e-08,
+            "maximum_prediction_kl_nats": 7.336224652209635e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001119852066040039,
+            "maximum_per_target_cross_entropy_increase": 0.0007524490356445312
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5455215,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "212e57b5fa9fcef9bbaf640d7bbb586eb6dec1a60e9e380099be530a0d30a4a2",
+            "table_sha256": "1d743e28d52c9816eba61c77df349b65b520ac69ed444b0daef85dd12dcce1d4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6599411331117153,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5456422,
+          "backend_with_key_registry_bytes": 6192529,
+          "backend_with_datrie_key_index_bytes": 5802582,
+          "full_model_serving_artifact_bytes": 7020527,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.999999952237527,
+            "mean_cosine": 0.9999999791989146,
+            "p05_cosine": 0.9999999715381719,
+            "relative_l2_mean": 0.00020643723533316717,
+            "relative_l2_p95": 0.00024222825928337357,
+            "relative_l2_max": 0.0003103547968601321,
+            "weighted_relative_l2_mean": 7.796723903184389e-05,
+            "weighted_relative_frobenius": 0.00020660422892998176,
+            "weighted_mean_cosine": 0.9999999922088666,
+            "max_relative_norm_change": 0.00017841050618007463
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.925829,
+            "warm_p50_ms": 0.147575,
+            "warm_p95_ms": 0.16536259999999997,
+            "warm_p99_ms": 0.19463553999999997,
+            "samples_ms": [
+              0.150439,
+              0.148064,
+              0.160775,
+              0.1496,
+              0.149041,
+              0.21106,
+              0.153791,
+              0.148063,
+              0.147645,
+              0.148064,
+              0.148553,
+              0.147644,
+              0.146248,
+              0.165174,
+              0.168946,
+              0.149461,
+              0.146667,
+              0.147644,
+              0.146597,
+              0.145759,
+              0.147644,
+              0.147156,
+              0.146248,
+              0.147575,
+              0.147156,
+              0.147017,
+              0.145689,
+              0.146666,
+              0.159378,
+              0.148971,
+              0.147574,
+              0.147226,
+              0.147575,
+              0.146667,
+              0.146667,
+              0.146667,
+              0.145689,
+              0.147575,
+              0.146178,
+              0.146667
+            ],
+            "warm_rows_per_second": 3469422.327630018
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877244241302235,
+            "character_perplexity": 6.535469845656627,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.049177481175951e-07,
+            "mean_prediction_kl_nats": 4.309312088974973e-09,
+            "prediction_kl_p99_nats": 3.498371872602242e-08,
+            "maximum_prediction_kl_nats": 7.336224652209635e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001119852066040039,
+            "maximum_per_target_cross_entropy_increase": 0.0007524490356445312
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5455215,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "212e57b5fa9fcef9bbaf640d7bbb586eb6dec1a60e9e380099be530a0d30a4a2",
+            "table_sha256": "1d743e28d52c9816eba61c77df349b65b520ac69ed444b0daef85dd12dcce1d4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5223842598497868,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5456422,
+          "backend_with_key_registry_bytes": 6192529,
+          "backend_with_datrie_key_index_bytes": 5802582,
+          "full_model_serving_artifact_bytes": 7020527,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.999999952237527,
+            "mean_cosine": 0.9999999791989146,
+            "p05_cosine": 0.9999999715381719,
+            "relative_l2_mean": 0.00020643723533316717,
+            "relative_l2_p95": 0.00024222825928337357,
+            "relative_l2_max": 0.0003103547968601321,
+            "weighted_relative_l2_mean": 7.796723903184389e-05,
+            "weighted_relative_frobenius": 0.00020660422892998176,
+            "weighted_mean_cosine": 0.9999999922088666,
+            "max_relative_norm_change": 0.00017841050618007463
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.927156,
+            "warm_p50_ms": 0.1472255,
+            "warm_p95_ms": 0.15281984999999995,
+            "warm_p99_ms": 0.17174175,
+            "samples_ms": [
+              0.152324,
+              0.14995,
+              0.148553,
+              0.148064,
+              0.148064,
+              0.147993,
+              0.162241,
+              0.151276,
+              0.148552,
+              0.148552,
+              0.147156,
+              0.147225,
+              0.147156,
+              0.147156,
+              0.147644,
+              0.147575,
+              0.146597,
+              0.146597,
+              0.147226,
+              0.146667,
+              0.147645,
+              0.147086,
+              0.147156,
+              0.146248,
+              0.147156,
+              0.147086,
+              0.146667,
+              0.147644,
+              0.147645,
+              0.145758,
+              0.147575,
+              0.147086,
+              0.147645,
+              0.177816,
+              0.148552,
+              0.146597,
+              0.146667,
+              0.147156,
+              0.147156,
+              0.147155
+            ],
+            "warm_rows_per_second": 3477658.4219445675
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877244241302235,
+            "character_perplexity": 6.535469845656627,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.049177481175951e-07,
+            "mean_prediction_kl_nats": 4.309312088974973e-09,
+            "prediction_kl_p99_nats": 3.498371872602242e-08,
+            "maximum_prediction_kl_nats": 7.336224652209635e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001119852066040039,
+            "maximum_per_target_cross_entropy_increase": 0.0007524490356445312
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3882363,
+              "unique_rows": 29824,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29824
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "9640ced718266675406375e98d479e25432f8c5824aa00d1cbc9d9466572d157",
+            "table_sha256": "b8b2ee3f87c9066969a1eb6381b347b672ba6cb101bfc84a86e152bce94815eb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.406329584075138,
+          "representatives_sha256": "4d39c273c7801f244bdc864f10b3b9cec557ac92c039ad051a7df02e48959e14",
+          "structurally_merged_rows": 13328,
+          "backend_artifact_bytes": 3883569,
+          "backend_with_key_registry_bytes": 4619676,
+          "backend_with_datrie_key_index_bytes": 4229729,
+          "full_model_serving_artifact_bytes": 5447674,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901359988769479,
+            "mean_cosine": 0.9997243911150577,
+            "p05_cosine": 0.998701582408625,
+            "relative_l2_mean": 0.012552533723385375,
+            "relative_l2_p95": 0.051191088644676495,
+            "relative_l2_max": 0.1404184277793818,
+            "weighted_relative_l2_mean": 0.002046682131465092,
+            "weighted_relative_frobenius": 0.012205143139227746,
+            "weighted_mean_cosine": 0.9999605527530744,
+            "max_relative_norm_change": 0.010145906005057173
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901350207672447,
+            "mean_cosine": 0.9997243975370762,
+            "p05_cosine": 0.9987013964404386,
+            "relative_l2_mean": 0.012410022358831409,
+            "relative_l2_p95": 0.051198839042667935,
+            "relative_l2_max": 0.14042520696577482,
+            "weighted_relative_l2_mean": 0.0019803323994328197,
+            "weighted_relative_frobenius": 0.012203608015228266,
+            "weighted_mean_cosine": 0.9999605594959479,
+            "max_relative_norm_change": 0.010085298327435002
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.270578,
+            "warm_p50_ms": 0.1476095,
+            "warm_p95_ms": 0.15102145,
+            "warm_p99_ms": 0.15583103,
+            "samples_ms": [
+              0.150997,
+              0.14953,
+              0.151486,
+              0.149531,
+              0.148064,
+              0.148063,
+              0.149041,
+              0.147645,
+              0.147645,
+              0.147086,
+              0.147016,
+              0.148553,
+              0.148552,
+              0.147644,
+              0.147994,
+              0.147156,
+              0.148063,
+              0.147086,
+              0.147645,
+              0.147574,
+              0.146597,
+              0.146667,
+              0.147574,
+              0.146248,
+              0.146666,
+              0.148134,
+              0.146178,
+              0.146667,
+              0.158609,
+              0.148622,
+              0.146667,
+              0.148063,
+              0.147086,
+              0.147575,
+              0.147086,
+              0.147645,
+              0.147156,
+              0.146666,
+              0.146667,
+              0.147156
+            ],
+            "warm_rows_per_second": 3468611.437610723
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877168853361512,
+            "character_perplexity": 6.5349771686144935,
+            "next_character_accuracy": 0.49539947860757555,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -7.518019682302672e-05,
+            "mean_prediction_kl_nats": 9.795772424569903e-06,
+            "prediction_kl_p99_nats": 0.00010697166204515648,
+            "maximum_prediction_kl_nats": 0.016904514918556646,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.3721555471420288,
+            "maximum_per_target_cross_entropy_increase": 0.1838548183441162
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -7.538509912339956e-05,
+            "mean_prediction_kl_nats": 9.794082950592873e-06,
+            "prediction_kl_p99_nats": 0.00010678432447086124,
+            "maximum_prediction_kl_nats": 0.016922180537672565,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.37213319540023804,
+            "maximum_per_target_cross_entropy_increase": 0.1836996078491211
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3879963,
+              "unique_rows": 29804,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29804
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "1d0186d6610372f7e7cf9c0bdb919c93be38e0923ea8bebbb8c1e10e9693ecdf",
+            "table_sha256": "ba1abb815031f6d09a15c3d915199b9e5fb476c2d95d3f92f044aa5d5579f8c7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4629533898551017,
+          "representatives_sha256": "13e2eaff298ad79ed375c10a562953bc213cf6eb7194aa52470ea8ba63509403",
+          "structurally_merged_rows": 13348,
+          "backend_artifact_bytes": 3881169,
+          "backend_with_key_registry_bytes": 4617276,
+          "backend_with_datrie_key_index_bytes": 4227329,
+          "full_model_serving_artifact_bytes": 5445274,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9811277047037894,
+            "mean_cosine": 0.9997164512755508,
+            "p05_cosine": 0.9986966362509793,
+            "relative_l2_mean": 0.012641831401540108,
+            "relative_l2_p95": 0.05127963928816258,
+            "relative_l2_max": 0.19396570003323146,
+            "weighted_relative_l2_mean": 0.0020866221878897153,
+            "weighted_relative_frobenius": 0.013160371895786201,
+            "weighted_mean_cosine": 0.9999569690400654,
+            "max_relative_norm_change": 0.010145906005057173
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9811243907892742,
+            "mean_cosine": 0.9997164577430483,
+            "p05_cosine": 0.9986972952572108,
+            "relative_l2_mean": 0.012499417060502187,
+            "relative_l2_p95": 0.051283627134803604,
+            "relative_l2_max": 0.19396372523399272,
+            "weighted_relative_l2_mean": 0.0020203178548211255,
+            "weighted_relative_frobenius": 0.013159117282672982,
+            "weighted_mean_cosine": 0.9999569754682313,
+            "max_relative_norm_change": 0.010085298327435002
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.178317,
+            "warm_p50_ms": 0.147575,
+            "warm_p95_ms": 0.1491109,
+            "warm_p99_ms": 0.1555935,
+            "samples_ms": [
+              0.150439,
+              0.148552,
+              0.147575,
+              0.147645,
+              0.147575,
+              0.148064,
+              0.148553,
+              0.148133,
+              0.148622,
+              0.149041,
+              0.147645,
+              0.147575,
+              0.147155,
+              0.147575,
+              0.158889,
+              0.148064,
+              0.146178,
+              0.146178,
+              0.146667,
+              0.146667,
+              0.148064,
+              0.146178,
+              0.147575,
+              0.145759,
+              0.147645,
+              0.147226,
+              0.146248,
+              0.146667,
+              0.145759,
+              0.147575,
+              0.147156,
+              0.147086,
+              0.145689,
+              0.147645,
+              0.147085,
+              0.146597,
+              0.146178,
+              0.146108,
+              0.147575,
+              0.147156
+            ],
+            "warm_rows_per_second": 3469422.327630018
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8771944360852009,
+            "character_perplexity": 6.535144353268222,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.9599069232447145e-05,
+            "mean_prediction_kl_nats": 2.7040531143815635e-05,
+            "prediction_kl_p99_nats": 0.0001212205948734834,
+            "maximum_prediction_kl_nats": 0.030108628146649247,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.4547811448574066,
+            "maximum_per_target_cross_entropy_increase": 0.42043161392211914
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.980397677484597e-05,
+            "mean_prediction_kl_nats": 2.7045709011130913e-05,
+            "prediction_kl_p99_nats": 0.0001210610821354744,
+            "maximum_prediction_kl_nats": 0.0301333351480087,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.4548949599266052,
+            "maximum_per_target_cross_entropy_increase": 0.4206087589263916
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3879148,
+              "unique_rows": 29797,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29797
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "137c54c851ee9aef9c2f59e5cee561bc162292c80f0e5da5cbb5b2bf4309a815",
+            "table_sha256": "7653a1ca0100a0c56b2af12aa58e4fa8dd0b6e891d4d809e7bce133c1becfc59",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3883936258498579,
+          "representatives_sha256": "60f10fc23f54f0ee0daca046aaba8f2642f7fb595eed113e2b98c6fc86038a5f",
+          "structurally_merged_rows": 13355,
+          "backend_artifact_bytes": 3880354,
+          "backend_with_key_registry_bytes": 4616461,
+          "backend_with_datrie_key_index_bytes": 4226514,
+          "full_model_serving_artifact_bytes": 5444459,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9701552429340661,
+            "mean_cosine": 0.9997080003704789,
+            "p05_cosine": 0.998692743504631,
+            "relative_l2_mean": 0.01271223511424447,
+            "relative_l2_p95": 0.05137353966363325,
+            "relative_l2_max": 0.24360749548388305,
+            "weighted_relative_l2_mean": 0.002114968820646803,
+            "weighted_relative_frobenius": 0.013742242501495193,
+            "weighted_mean_cosine": 0.9999537044720979,
+            "max_relative_norm_change": 0.010145906005057173
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9701453061361723,
+            "mean_cosine": 0.9997080063633795,
+            "p05_cosine": 0.9986928810695538,
+            "relative_l2_mean": 0.012569856943483957,
+            "relative_l2_p95": 0.0513781474701145,
+            "relative_l2_max": 0.24365314010630398,
+            "weighted_relative_l2_mean": 0.0020486727955327188,
+            "weighted_relative_frobenius": 0.013741028017087598,
+            "weighted_mean_cosine": 0.9999537109984574,
+            "max_relative_norm_change": 0.010085298327435002
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.226089,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.16056194999999995,
+            "warm_p99_ms": 0.24260743999999992,
+            "samples_ms": [
+              0.14995,
+              0.148134,
+              0.148134,
+              0.147225,
+              0.146737,
+              0.148552,
+              0.148133,
+              0.148553,
+              0.146248,
+              0.148063,
+              0.147156,
+              0.147644,
+              0.181727,
+              0.151765,
+              0.147644,
+              0.147574,
+              0.146667,
+              0.147156,
+              0.145759,
+              0.146736,
+              0.147156,
+              0.146667,
+              0.146248,
+              0.147575,
+              0.146178,
+              0.146667,
+              0.147156,
+              0.146178,
+              0.146597,
+              0.146667,
+              0.147086,
+              0.147016,
+              0.146178,
+              0.147575,
+              0.145759,
+              0.147645,
+              0.146667,
+              0.145759,
+              0.281531,
+              0.159448
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772039686603894,
+            "character_perplexity": 6.535206650320062,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.006692141793789e-05,
+            "mean_prediction_kl_nats": 2.8764179419291013e-05,
+            "prediction_kl_p99_nats": 0.0001373004646596293,
+            "maximum_prediction_kl_nats": 0.030108628146649247,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5845257639884949,
+            "maximum_per_target_cross_entropy_increase": 0.42043161392211914
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.0271830913642586e-05,
+            "mean_prediction_kl_nats": 2.8768364376307013e-05,
+            "prediction_kl_p99_nats": 0.00013665960831430523,
+            "maximum_prediction_kl_nats": 0.0301333351480087,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.5844752788543701,
+            "maximum_per_target_cross_entropy_increase": 0.4206087589263916
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3876935,
+              "unique_rows": 29778,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29778
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "e434feffabfbc8116628e58406f42b8cc8207c53c795caf18a5f3dce23f1fbdc",
+            "table_sha256": "09dcfe5cdd90d9a99c06c8eb3588fd6cc523f743071e4fbc422417216eaed5f1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3968824229668826,
+          "representatives_sha256": "c5bc80eab280d3eae987b35d58945c2c403667bb392c94616c14def6b5313cfe",
+          "structurally_merged_rows": 13374,
+          "backend_artifact_bytes": 3878141,
+          "backend_with_key_registry_bytes": 4614248,
+          "backend_with_datrie_key_index_bytes": 4224301,
+          "full_model_serving_artifact_bytes": 5442246,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.95109107112859,
+            "mean_cosine": 0.9996851734688298,
+            "p05_cosine": 0.9986880269709896,
+            "relative_l2_mean": 0.012872793154547231,
+            "relative_l2_p95": 0.05149540003059486,
+            "relative_l2_max": 0.3130204723240637,
+            "weighted_relative_l2_mean": 0.002278146478787276,
+            "weighted_relative_frobenius": 0.019003676722386505,
+            "weighted_mean_cosine": 0.9999304849711296,
+            "max_relative_norm_change": 0.010145906005057173
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9511049942344023,
+            "mean_cosine": 0.9996851795755632,
+            "p05_cosine": 0.9986874967079526,
+            "relative_l2_mean": 0.012730502151193564,
+            "relative_l2_p95": 0.05150844694982633,
+            "relative_l2_max": 0.31304083713182396,
+            "weighted_relative_l2_mean": 0.0022119122255464248,
+            "weighted_relative_frobenius": 0.01900275506586697,
+            "weighted_mean_cosine": 0.9999304925324197,
+            "max_relative_norm_change": 0.010085298327435002
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.034513,
+            "warm_p50_ms": 0.1476445,
+            "warm_p95_ms": 0.15286874999999997,
+            "warm_p99_ms": 0.17421059,
+            "samples_ms": [
+              0.151835,
+              0.14946,
+              0.149041,
+              0.148552,
+              0.148553,
+              0.148553,
+              0.148552,
+              0.149041,
+              0.147993,
+              0.148553,
+              0.148064,
+              0.181238,
+              0.152324,
+              0.148972,
+              0.147645,
+              0.146736,
+              0.147645,
+              0.147156,
+              0.147644,
+              0.146667,
+              0.147505,
+              0.148063,
+              0.147156,
+              0.147156,
+              0.146178,
+              0.146248,
+              0.147086,
+              0.147575,
+              0.146109,
+              0.147645,
+              0.147575,
+              0.147156,
+              0.146248,
+              0.147155,
+              0.147226,
+              0.146178,
+              0.146667,
+              0.147644,
+              0.163219,
+              0.148552
+            ],
+            "warm_rows_per_second": 3467789.1828005784
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8769020492525026,
+            "character_perplexity": 6.5332338424272605,
+            "next_character_accuracy": 0.49524612789449474,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003419286610716499,
+            "mean_prediction_kl_nats": 4.486075688066997e-05,
+            "prediction_kl_p99_nats": 0.00028680683746140797,
+            "maximum_prediction_kl_nats": 0.030108628146649247,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.9884049892425537,
+            "maximum_per_target_cross_entropy_increase": 0.42043161392211914
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0003421335087105394,
+            "mean_prediction_kl_nats": 4.486310455467269e-05,
+            "prediction_kl_p99_nats": 0.00028727213267286655,
+            "maximum_prediction_kl_nats": 0.0301333351480087,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.9884847402572632,
+            "maximum_per_target_cross_entropy_increase": 0.4206087589263916
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3872672,
+              "unique_rows": 29743,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 465,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 465,
+              "zlib_blocks": 465,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29743
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "53ebd25388250f9b4d6fc0dea0b9513e4484d137ff218e9794f89bd8bef08e9b",
+            "table_sha256": "dd0a70a5f8029e1e7e09ceaf44f3084c81a74c19029ed8926cda58a2d3edc03d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4126182380132377,
+          "representatives_sha256": "8870b968e8cd56e4698498505b13e7f0d1419dd3859ad36a5917ef111bdcfc5a",
+          "structurally_merged_rows": 13409,
+          "backend_artifact_bytes": 3873878,
+          "backend_with_key_registry_bytes": 4609985,
+          "backend_with_datrie_key_index_bytes": 4220038,
+          "full_model_serving_artifact_bytes": 5437983,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9029568391232163,
+            "mean_cosine": 0.9996149997015428,
+            "p05_cosine": 0.9986758813379707,
+            "relative_l2_mean": 0.013235200765704624,
+            "relative_l2_p95": 0.05174014608774899,
+            "relative_l2_max": 0.4406441354927482,
+            "weighted_relative_l2_mean": 0.002376078832953385,
+            "weighted_relative_frobenius": 0.02284375735876039,
+            "weighted_mean_cosine": 0.9999118142079768,
+            "max_relative_norm_change": 0.010145906005057173
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9029504707467081,
+            "mean_cosine": 0.9996150045673875,
+            "p05_cosine": 0.9986755277169472,
+            "relative_l2_mean": 0.013093074009532956,
+            "relative_l2_p95": 0.05173732092541074,
+            "relative_l2_max": 0.4406531373114421,
+            "weighted_relative_l2_mean": 0.002309894378455299,
+            "weighted_relative_frobenius": 0.0228432212925786,
+            "weighted_mean_cosine": 0.9999118214769647,
+            "max_relative_norm_change": 0.010085298327435002
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.968235,
+            "warm_p50_ms": 0.1475745,
+            "warm_p95_ms": 0.15090589999999998,
+            "warm_p99_ms": 0.17322221,
+            "samples_ms": [
+              0.150857,
+              0.149042,
+              0.148064,
+              0.148553,
+              0.148064,
+              0.147086,
+              0.147156,
+              0.147505,
+              0.147156,
+              0.147156,
+              0.148133,
+              0.147156,
+              0.147086,
+              0.146667,
+              0.147994,
+              0.186896,
+              0.150508,
+              0.147645,
+              0.147575,
+              0.147994,
+              0.147575,
+              0.151835,
+              0.146178,
+              0.145759,
+              0.147574,
+              0.147086,
+              0.147645,
+              0.147644,
+              0.147645,
+              0.147156,
+              0.146178,
+              0.147645,
+              0.146667,
+              0.147156,
+              0.147575,
+              0.146667,
+              0.146737,
+              0.147644,
+              0.146667,
+              0.146178
+            ],
+            "warm_rows_per_second": 3469434.082446493
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8769689418982365,
+            "character_perplexity": 6.5336708823413945,
+            "next_character_accuracy": 0.4951694525379543,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00027505665125251234,
+            "mean_prediction_kl_nats": 7.810417882368735e-05,
+            "prediction_kl_p99_nats": 0.0004862708800758725,
+            "maximum_prediction_kl_nats": 0.10616205347563132,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.4215319156646729,
+            "maximum_per_target_cross_entropy_increase": 0.9142379760742188
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0002752615125946606,
+            "mean_prediction_kl_nats": 7.81205352925241e-05,
+            "prediction_kl_p99_nats": 0.0004863201053157216,
+            "maximum_prediction_kl_nats": 0.10619663094734044,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 1.421834945678711,
+            "maximum_per_target_cross_entropy_increase": 0.9144940376281738
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2934336,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "2ac1cbfa580f67daaec9296dbc36834c852d35f0c2ac598a3062f05020c54a6d",
+            "table_sha256": "c6b56112cce3e1b0060ebf715a19f2aa46b58a9555a1fddb0277cd94bbec29c3",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05933483806438744,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2935184,
+          "backend_with_key_registry_bytes": 3671291,
+          "backend_with_datrie_key_index_bytes": 3281344,
+          "full_model_serving_artifact_bytes": 4499289,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999211334377017,
+            "mean_cosine": 0.9999884214594844,
+            "p05_cosine": 0.9999770988080822,
+            "relative_l2_mean": 0.004703892852436545,
+            "relative_l2_p95": 0.006808280335029292,
+            "relative_l2_max": 0.012559680173836917,
+            "weighted_relative_l2_mean": 0.0020427094037580255,
+            "weighted_relative_frobenius": 0.005389228558747884,
+            "weighted_mean_cosine": 0.9999943438751884,
+            "max_relative_norm_change": 0.0031613003512570913
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.275314,
+            "warm_p50_ms": 0.09746350000000001,
+            "warm_p95_ms": 0.10044209999999996,
+            "warm_p99_ms": 0.13248015,
+            "samples_ms": [
+              0.097987,
+              0.097918,
+              0.097918,
+              0.09701,
+              0.097428,
+              0.097429,
+              0.095962,
+              0.097009,
+              0.1452,
+              0.112585,
+              0.098895,
+              0.099803,
+              0.097918,
+              0.097918,
+              0.098407,
+              0.097499,
+              0.095682,
+              0.096102,
+              0.09701,
+              0.09694,
+              0.09708,
+              0.097988,
+              0.097009,
+              0.09701,
+              0.09701,
+              0.097498,
+              0.096521,
+              0.096521,
+              0.096939,
+              0.097917,
+              0.097499,
+              0.097918,
+              0.097499,
+              0.098406,
+              0.09701,
+              0.097499,
+              0.09701,
+              0.097009,
+              0.09694,
+              0.098407
+            ],
+            "warm_rows_per_second": 5253248.652059489
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772194514216143,
+            "character_perplexity": 6.535307834147485,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.458466068578227e-05,
+            "mean_prediction_kl_nats": 3.7257925306687268e-06,
+            "prediction_kl_p99_nats": 2.9096108127972065e-05,
+            "maximum_prediction_kl_nats": 0.00010730878408645676,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.04188680648803711,
+            "maximum_per_target_cross_entropy_increase": 0.021907806396484375
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288614,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 187,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "2ac1cbfa580f67daaec9296dbc36834c852d35f0c2ac598a3062f05020c54a6d",
+            "table_sha256": "c1f6b7272b67c0a95e089109a7f335761d0d41f274542bf2a0963570fd069540",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2841149701271206,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3289867,
+          "backend_with_key_registry_bytes": 4025974,
+          "backend_with_datrie_key_index_bytes": 3636027,
+          "full_model_serving_artifact_bytes": 4853972,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999211334377017,
+            "mean_cosine": 0.9999884214594844,
+            "p05_cosine": 0.9999770988080822,
+            "relative_l2_mean": 0.004703892852436545,
+            "relative_l2_p95": 0.006808280335029292,
+            "relative_l2_max": 0.012559680173836917,
+            "weighted_relative_l2_mean": 0.0020427094037580255,
+            "weighted_relative_frobenius": 0.005389228558747884,
+            "weighted_mean_cosine": 0.9999943438751884,
+            "max_relative_norm_change": 0.0031613003512570913
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.226962,
+            "warm_p50_ms": 0.112165,
+            "warm_p95_ms": 0.11365624999999999,
+            "warm_p99_ms": 0.12324402,
+            "samples_ms": [
+              0.115447,
+              0.112654,
+              0.113073,
+              0.112095,
+              0.112165,
+              0.112585,
+              0.112585,
+              0.112584,
+              0.113562,
+              0.113073,
+              0.112654,
+              0.112166,
+              0.112655,
+              0.111677,
+              0.112096,
+              0.11021,
+              0.112655,
+              0.110839,
+              0.112166,
+              0.128229,
+              0.111606,
+              0.112165,
+              0.111676,
+              0.111677,
+              0.111676,
+              0.112585,
+              0.110699,
+              0.11021,
+              0.112235,
+              0.112585,
+              0.112654,
+              0.110699,
+              0.111118,
+              0.110699,
+              0.113073,
+              0.111606,
+              0.110768,
+              0.11021,
+              0.112096,
+              0.112096
+            ],
+            "warm_rows_per_second": 4564703.784603041
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772194514216143,
+            "character_perplexity": 6.535307834147485,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.458466068578227e-05,
+            "mean_prediction_kl_nats": 3.7257925306687268e-06,
+            "prediction_kl_p99_nats": 2.9096108127972065e-05,
+            "maximum_prediction_kl_nats": 0.00010730878408645676,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.04188680648803711,
+            "maximum_per_target_cross_entropy_increase": 0.021907806396484375
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288614,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 187,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "2ac1cbfa580f67daaec9296dbc36834c852d35f0c2ac598a3062f05020c54a6d",
+            "table_sha256": "c1f6b7272b67c0a95e089109a7f335761d0d41f274542bf2a0963570fd069540",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4498774129897356,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3289866,
+          "backend_with_key_registry_bytes": 4025973,
+          "backend_with_datrie_key_index_bytes": 3636026,
+          "full_model_serving_artifact_bytes": 4853971,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999211334377017,
+            "mean_cosine": 0.9999884214594844,
+            "p05_cosine": 0.9999770988080822,
+            "relative_l2_mean": 0.004703892852436545,
+            "relative_l2_p95": 0.006808280335029292,
+            "relative_l2_max": 0.012559680173836917,
+            "weighted_relative_l2_mean": 0.0020427094037580255,
+            "weighted_relative_frobenius": 0.005389228558747884,
+            "weighted_mean_cosine": 0.9999943438751884,
+            "max_relative_norm_change": 0.0031613003512570913
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.159285,
+            "warm_p50_ms": 0.11171149999999999,
+            "warm_p95_ms": 0.1150044,
+            "warm_p99_ms": 0.13465499999999997,
+            "samples_ms": [
+              0.114959,
+              0.113003,
+              0.112514,
+              0.113562,
+              0.112026,
+              0.146667,
+              0.115867,
+              0.113073,
+              0.111746,
+              0.112515,
+              0.111118,
+              0.110699,
+              0.112654,
+              0.111188,
+              0.112096,
+              0.110629,
+              0.11021,
+              0.112095,
+              0.112165,
+              0.110769,
+              0.112165,
+              0.112515,
+              0.110629,
+              0.112654,
+              0.111677,
+              0.111257,
+              0.113073,
+              0.111188,
+              0.110699,
+              0.110699,
+              0.112165,
+              0.11021,
+              0.110768,
+              0.111677,
+              0.111257,
+              0.111257,
+              0.112095,
+              0.111606,
+              0.110768,
+              0.111257
+            ],
+            "warm_rows_per_second": 4583234.492420208
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772194514216143,
+            "character_perplexity": 6.535307834147485,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.458466068578227e-05,
+            "mean_prediction_kl_nats": 3.7257925306687268e-06,
+            "prediction_kl_p99_nats": 2.9096108127972065e-05,
+            "maximum_prediction_kl_nats": 0.00010730878408645676,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.04188680648803711,
+            "maximum_per_target_cross_entropy_increase": 0.021907806396484375
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288614,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 187,
+              "compressed_blocks": 173,
+              "zlib_blocks": 173,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "2ac1cbfa580f67daaec9296dbc36834c852d35f0c2ac598a3062f05020c54a6d",
+            "table_sha256": "c1f6b7272b67c0a95e089109a7f335761d0d41f274542bf2a0963570fd069540",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2968744949903339,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3289866,
+          "backend_with_key_registry_bytes": 4025973,
+          "backend_with_datrie_key_index_bytes": 3636026,
+          "full_model_serving_artifact_bytes": 4853971,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999211334377017,
+            "mean_cosine": 0.9999884214594844,
+            "p05_cosine": 0.9999770988080822,
+            "relative_l2_mean": 0.004703892852436545,
+            "relative_l2_p95": 0.006808280335029292,
+            "relative_l2_max": 0.012559680173836917,
+            "weighted_relative_l2_mean": 0.0020427094037580255,
+            "weighted_relative_frobenius": 0.005389228558747884,
+            "weighted_mean_cosine": 0.9999943438751884,
+            "max_relative_norm_change": 0.0031613003512570913
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.164453,
+            "warm_p50_ms": 0.111607,
+            "warm_p95_ms": 0.11356535,
+            "warm_p99_ms": 0.12420416,
+            "samples_ms": [
+              0.114959,
+              0.113143,
+              0.113073,
+              0.113073,
+              0.110629,
+              0.113004,
+              0.112584,
+              0.113003,
+              0.113492,
+              0.113073,
+              0.111676,
+              0.112654,
+              0.111607,
+              0.111607,
+              0.111677,
+              0.111188,
+              0.110279,
+              0.111607,
+              0.110699,
+              0.11021,
+              0.111676,
+              0.110768,
+              0.110629,
+              0.111257,
+              0.111676,
+              0.111676,
+              0.111606,
+              0.112095,
+              0.110768,
+              0.11028,
+              0.111118,
+              0.111607,
+              0.130115,
+              0.11021,
+              0.110768,
+              0.111606,
+              0.111187,
+              0.110698,
+              0.108813,
+              0.112096
+            ],
+            "warm_rows_per_second": 4587525.872033116
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8772194514216143,
+            "character_perplexity": 6.535307834147485,
+            "next_character_accuracy": 0.4953228032510351,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -2.458466068578227e-05,
+            "mean_prediction_kl_nats": 3.7257925306687268e-06,
+            "prediction_kl_p99_nats": 2.9096108127972065e-05,
+            "maximum_prediction_kl_nats": 0.00010730878408645676,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.04188680648803711,
+            "maximum_per_target_cross_entropy_increase": 0.021907806396484375
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2379583,
+              "unique_rows": 29847,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 71,
+              "compressed_blocks": 178,
+              "zlib_blocks": 178,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29847
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "6d66c0bfd5543334bcb73d019de8b8b4b1b38fd95f9880f4375fb90ea837117c",
+            "table_sha256": "2e10776d273d205120149583a3e4758e4a4912fc03dbce073a78c5e772eef25e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23807862401008606,
+          "representatives_sha256": "c5951879742dcb40fbdb0518d2f79b502806f8e52e309338331414737bac02e5",
+          "structurally_merged_rows": 13305,
+          "backend_artifact_bytes": 2380833,
+          "backend_with_key_registry_bytes": 3116940,
+          "backend_with_datrie_key_index_bytes": 2726993,
+          "full_model_serving_artifact_bytes": 3944938,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901475114542572,
+            "mean_cosine": 0.9997133396421275,
+            "p05_cosine": 0.9986894419312247,
+            "relative_l2_mean": 0.015794454168486457,
+            "relative_l2_p95": 0.05149892399538544,
+            "relative_l2_max": 0.14034170133988702,
+            "weighted_relative_l2_mean": 0.003753597272702232,
+            "weighted_relative_frobenius": 0.0133093761146089,
+            "weighted_mean_cosine": 0.9999552172022823,
+            "max_relative_norm_change": 0.01184111110318379
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.990135508727166,
+            "mean_cosine": 0.9997185262944867,
+            "p05_cosine": 0.9986738463742685,
+            "relative_l2_mean": 0.012552149296026199,
+            "relative_l2_p95": 0.051718263226385855,
+            "relative_l2_max": 0.1404126776934458,
+            "weighted_relative_l2_mean": 0.0020091129867621264,
+            "weighted_relative_frobenius": 0.01244834613064305,
+            "weighted_mean_cosine": 0.9999594602328237,
+            "max_relative_norm_change": 0.010095277078878997
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.017077,
+            "warm_p50_ms": 0.108778,
+            "warm_p95_ms": 0.11601279999999996,
+            "warm_p99_ms": 0.12795555,
+            "samples_ms": [
+              0.113492,
+              0.111117,
+              0.110349,
+              0.128718,
+              0.109302,
+              0.110698,
+              0.11028,
+              0.109721,
+              0.107416,
+              0.108813,
+              0.10979,
+              0.108743,
+              0.108324,
+              0.108324,
+              0.10979,
+              0.108324,
+              0.107416,
+              0.108324,
+              0.107905,
+              0.107905,
+              0.108394,
+              0.109302,
+              0.108883,
+              0.115447,
+              0.109721,
+              0.109302,
+              0.109232,
+              0.107905,
+              0.108394,
+              0.108393,
+              0.107835,
+              0.109302,
+              0.107835,
+              0.107835,
+              0.107835,
+              0.110698,
+              0.108394,
+              0.108324,
+              0.107905,
+              0.126763
+            ],
+            "warm_rows_per_second": 4706834.102483958
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.877132831222215,
+            "character_perplexity": 6.534741768996447,
+            "next_character_accuracy": 0.49562950467719674,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00011119897922794746,
+            "mean_prediction_kl_nats": 1.3663462342206782e-05,
+            "prediction_kl_p99_nats": 0.00011834122541509815,
+            "maximum_prediction_kl_nats": 0.01791453215246488,
+            "top1_changed_fraction": 0.002376936052752645,
+            "accuracy_change": 0.0004600521392424395,
+            "maximum_absolute_logit_change": 0.3684694766998291,
+            "maximum_per_target_cross_entropy_increase": 0.17836976051330566
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -8.661644797814854e-05,
+            "mean_prediction_kl_nats": 9.926255770447644e-06,
+            "prediction_kl_p99_nats": 0.00011290883215839557,
+            "maximum_prediction_kl_nats": 0.01800184768005272,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.3697659969329834,
+            "maximum_per_target_cross_entropy_increase": 0.18305516242980957
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2378155,
+              "unique_rows": 29827,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 71,
+              "compressed_blocks": 178,
+              "zlib_blocks": 178,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29827
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "b729a52ed75f57d8d872a3a339100a2bf16cc4392b747efe0a684192c9635936",
+            "table_sha256": "a60156342c173dde8c6dcb645547d787177fa54a3e90961c78478c2af5728767",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25508715701289475,
+          "representatives_sha256": "5b810087fc04119dec569a0ed5e0d67ffe99962113fca6aec0bbb3278a241f73",
+          "structurally_merged_rows": 13325,
+          "backend_artifact_bytes": 2379405,
+          "backend_with_key_registry_bytes": 3115512,
+          "backend_with_datrie_key_index_bytes": 2725565,
+          "full_model_serving_artifact_bytes": 3943510,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9810367637945125,
+            "mean_cosine": 0.9997053753890165,
+            "p05_cosine": 0.9986822306235927,
+            "relative_l2_mean": 0.015881604219005543,
+            "relative_l2_p95": 0.051603757393284606,
+            "relative_l2_max": 0.19497180693208166,
+            "weighted_relative_l2_mean": 0.0037924838223366837,
+            "weighted_relative_frobenius": 0.014189580581151816,
+            "weighted_mean_cosine": 0.9999516331953032,
+            "max_relative_norm_change": 0.01184111110318379
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9810632185328769,
+            "mean_cosine": 0.9997105512825292,
+            "p05_cosine": 0.9986681096578764,
+            "relative_l2_mean": 0.012641758762971559,
+            "relative_l2_p95": 0.05181365555230398,
+            "relative_l2_max": 0.194871458842179,
+            "weighted_relative_l2_mean": 0.0020492382753159143,
+            "weighted_relative_frobenius": 0.013392380945672376,
+            "weighted_mean_cosine": 0.9999558576885209,
+            "max_relative_norm_change": 0.010095277078878997
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.125889,
+            "warm_p50_ms": 0.106927,
+            "warm_p95_ms": 0.1098994,
+            "warm_p99_ms": 0.11791423,
+            "samples_ms": [
+              0.110629,
+              0.107835,
+              0.107835,
+              0.106927,
+              0.108324,
+              0.109861,
+              0.108743,
+              0.108813,
+              0.106857,
+              0.107835,
+              0.106438,
+              0.106508,
+              0.106927,
+              0.106997,
+              0.106927,
+              0.106997,
+              0.106019,
+              0.107416,
+              0.107835,
+              0.10553,
+              0.122572,
+              0.108394,
+              0.107416,
+              0.106857,
+              0.106927,
+              0.107346,
+              0.10602,
+              0.105112,
+              0.106927,
+              0.106019,
+              0.106927,
+              0.106438,
+              0.106369,
+              0.107416,
+              0.106927,
+              0.10602,
+              0.10595,
+              0.106508,
+              0.106927,
+              0.107486
+            ],
+            "warm_rows_per_second": 4788313.522309613
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8771582425836568,
+            "character_perplexity": 6.534907827791349,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -8.579012066808811e-05,
+            "mean_prediction_kl_nats": 3.137851799195357e-05,
+            "prediction_kl_p99_nats": 0.00013102815635868638,
+            "maximum_prediction_kl_nats": 0.03130812199619916,
+            "top1_changed_fraction": 0.002683637478914277,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.46176108717918396,
+            "maximum_per_target_cross_entropy_increase": 0.4255211353302002
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -6.120696473476546e-05,
+            "mean_prediction_kl_nats": 2.7501241235541264e-05,
+            "prediction_kl_p99_nats": 0.00012287957135383222,
+            "maximum_prediction_kl_nats": 0.030504890121537204,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.4579961895942688,
+            "maximum_per_target_cross_entropy_increase": 0.4258437156677246
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2377769,
+              "unique_rows": 29821,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 73,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29821
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "115f6261b3cbe6655b7e135b2f32fdca5578e89cf4214ced50a0406053548c76",
+            "table_sha256": "58effb10cfc7ec7e38a869e5a2bfb52f9e666911643bd558330de3f31fda30f1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24021192686632276,
+          "representatives_sha256": "dbb73c2f0f3c858d4a43facc7c2385f6331eff0e78a56521e5d8fb196e4fac1f",
+          "structurally_merged_rows": 13331,
+          "backend_artifact_bytes": 2379019,
+          "backend_with_key_registry_bytes": 3115126,
+          "backend_with_datrie_key_index_bytes": 2725179,
+          "full_model_serving_artifact_bytes": 3943124,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9718663746106818,
+            "mean_cosine": 0.9996986927185848,
+            "p05_cosine": 0.9986778996457422,
+            "relative_l2_mean": 0.01593737000666218,
+            "relative_l2_p95": 0.05164042874828437,
+            "relative_l2_max": 0.23754541086938025,
+            "weighted_relative_l2_mean": 0.0038149122698589153,
+            "weighted_relative_frobenius": 0.014632505319454783,
+            "weighted_mean_cosine": 0.9999490403153539,
+            "max_relative_norm_change": 0.01184111110318379
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.971988892125288,
+            "mean_cosine": 0.9997038738568005,
+            "p05_cosine": 0.9986650205358348,
+            "relative_l2_mean": 0.012698022992704637,
+            "relative_l2_p95": 0.051902060540808904,
+            "relative_l2_max": 0.2370694668141154,
+            "weighted_relative_l2_mean": 0.0020718489413359344,
+            "weighted_relative_frobenius": 0.01386121950714379,
+            "weighted_mean_cosine": 0.9999532611190162,
+            "max_relative_norm_change": 0.010095277078878997
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.002899,
+            "warm_p50_ms": 0.1073465,
+            "warm_p95_ms": 0.11318825,
+            "warm_p99_ms": 0.13591303999999998,
+            "samples_ms": [
+              0.10986,
+              0.107835,
+              0.106439,
+              0.106438,
+              0.113073,
+              0.109791,
+              0.108324,
+              0.106508,
+              0.106438,
+              0.108812,
+              0.107835,
+              0.106857,
+              0.149042,
+              0.115378,
+              0.107835,
+              0.106927,
+              0.107835,
+              0.106927,
+              0.107416,
+              0.105949,
+              0.107835,
+              0.106857,
+              0.107835,
+              0.108324,
+              0.106438,
+              0.106928,
+              0.107835,
+              0.107346,
+              0.107347,
+              0.107416,
+              0.106438,
+              0.106438,
+              0.107346,
+              0.106997,
+              0.105949,
+              0.106928,
+              0.105949,
+              0.106927,
+              0.108813,
+              0.107905
+            ],
+            "warm_rows_per_second": 4769601.244567825
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8771634736025458,
+            "character_perplexity": 6.534942012107043,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -8.05595368682254e-05,
+            "mean_prediction_kl_nats": 3.282020287449531e-05,
+            "prediction_kl_p99_nats": 0.00014358032176465654,
+            "maximum_prediction_kl_nats": 0.03130812199619916,
+            "top1_changed_fraction": 0.002683637478914277,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.5839344263076782,
+            "maximum_per_target_cross_entropy_increase": 0.4255211353302002
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -5.597625233961335e-05,
+            "mean_prediction_kl_nats": 2.8922105282300183e-05,
+            "prediction_kl_p99_nats": 0.00012901098501385112,
+            "maximum_prediction_kl_nats": 0.030504890121537204,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.5850692987442017,
+            "maximum_per_target_cross_entropy_increase": 0.4258437156677246
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2376392,
+              "unique_rows": 29802,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 77,
+              "compressed_blocks": 172,
+              "zlib_blocks": 172,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29802
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "5d7ec9791c81359ad1c407a5e62ea64b81ea827f1ba565257771dcefc50ee1eb",
+            "table_sha256": "28680da4d7eec2caecfcc6d9ff90c6c462f723ee96724f0e1a4689c7f173fd25",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.29219344910234213,
+          "representatives_sha256": "4a40c9f9526483f4a76ea25a46a74bbfd0333639fe41ce63a88008fc05d6e3c5",
+          "structurally_merged_rows": 13350,
+          "backend_artifact_bytes": 2377642,
+          "backend_with_key_registry_bytes": 3113749,
+          "backend_with_datrie_key_index_bytes": 2723802,
+          "full_model_serving_artifact_bytes": 3941747,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9508160845312954,
+            "mean_cosine": 0.9996751721259401,
+            "p05_cosine": 0.998671347364355,
+            "relative_l2_mean": 0.016100586464595373,
+            "relative_l2_p95": 0.05178025972616924,
+            "relative_l2_max": 0.31401738190123984,
+            "weighted_relative_l2_mean": 0.003975753280806931,
+            "weighted_relative_frobenius": 0.01963455685845534,
+            "weighted_mean_cosine": 0.9999259144129621,
+            "max_relative_norm_change": 0.01184111110318379
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.950807329596665,
+            "mean_cosine": 0.9996803199105813,
+            "p05_cosine": 0.9986574164925269,
+            "relative_l2_mean": 0.01286334642602158,
+            "relative_l2_p95": 0.052039602686126125,
+            "relative_l2_max": 0.3140450860026669,
+            "weighted_relative_l2_mean": 0.002234223796431955,
+            "weighted_relative_frobenius": 0.019059819155137006,
+            "weighted_mean_cosine": 0.9999301556627495,
+            "max_relative_norm_change": 0.010095277078878997
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.699159,
+            "warm_p50_ms": 0.108813,
+            "warm_p95_ms": 0.11120795,
+            "warm_p99_ms": 0.13388807999999996,
+            "samples_ms": [
+              0.111606,
+              0.111187,
+              0.109372,
+              0.108813,
+              0.108813,
+              0.11021,
+              0.11028,
+              0.109231,
+              0.108813,
+              0.108813,
+              0.108813,
+              0.108813,
+              0.108883,
+              0.108813,
+              0.108324,
+              0.108813,
+              0.108813,
+              0.108324,
+              0.108812,
+              0.108883,
+              0.109301,
+              0.108883,
+              0.108324,
+              0.108883,
+              0.108813,
+              0.107905,
+              0.109651,
+              0.108813,
+              0.108394,
+              0.108324,
+              0.110699,
+              0.148134,
+              0.108813,
+              0.108393,
+              0.109302,
+              0.108323,
+              0.109302,
+              0.109302,
+              0.108393,
+              0.108324
+            ],
+            "warm_rows_per_second": 4705320.136380764
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8768621728990524,
+            "character_perplexity": 6.532973326079643,
+            "next_character_accuracy": 0.49547615396411593,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003817905848742269,
+            "mean_prediction_kl_nats": 4.888279063807856e-05,
+            "prediction_kl_p99_nats": 0.0002892620817657262,
+            "maximum_prediction_kl_nats": 0.03130812199619916,
+            "top1_changed_fraction": 0.002683637478914277,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.9851020574569702,
+            "maximum_per_target_cross_entropy_increase": 0.4255211353302002
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00035721470619078837,
+            "mean_prediction_kl_nats": 4.502350122816192e-05,
+            "prediction_kl_p99_nats": 0.00027518929094581124,
+            "maximum_prediction_kl_nats": 0.030504890121537204,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.00015335071308081316,
+            "maximum_absolute_logit_change": 0.9834340810775757,
+            "maximum_per_target_cross_entropy_increase": 0.4258437156677246
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2374029,
+              "unique_rows": 29766,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 80,
+              "compressed_blocks": 169,
+              "zlib_blocks": 169,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29766
+            },
+            "source_float32_sha256": "530a17bab5f26cb25db40425b1f57616f527687e9c87188ad04b27a87bdf7499",
+            "decoded_float32_sha256": "5fb1b69083eeb75566bd08b09655b73f2bcd4e9326a9a4b2108e81cd81172d94",
+            "table_sha256": "67ef7eb622861792ba7891ca23e20d3617c4bf8423ec6edeca09fe0e6b2b459e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2369166729040444,
+          "representatives_sha256": "27ad7f329d093b6bd2bf2d359586473ab4ceee5466007315ad1c08b3678b61fc",
+          "structurally_merged_rows": 13386,
+          "backend_artifact_bytes": 2375279,
+          "backend_with_key_registry_bytes": 3111386,
+          "backend_with_datrie_key_index_bytes": 2721439,
+          "full_model_serving_artifact_bytes": 3939384,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9028863763223173,
+            "mean_cosine": 0.9996009633335711,
+            "p05_cosine": 0.9986613733646358,
+            "relative_l2_mean": 0.01647700353742353,
+            "relative_l2_p95": 0.05197424947071407,
+            "relative_l2_max": 0.44076765865474365,
+            "weighted_relative_l2_mean": 0.004060801898233982,
+            "weighted_relative_frobenius": 0.023043644896926015,
+            "weighted_mean_cosine": 0.9999097692978524,
+            "max_relative_norm_change": 0.01184111110318379
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9030375219130348,
+            "mean_cosine": 0.999606075750037,
+            "p05_cosine": 0.9986471498976491,
+            "relative_l2_mean": 0.013243753300374974,
+            "relative_l2_p95": 0.052220655036914476,
+            "relative_l2_max": 0.44045396153669425,
+            "weighted_relative_l2_mean": 0.0023202173505376656,
+            "weighted_relative_frobenius": 0.022549180092356604,
+            "weighted_mean_cosine": 0.9999140294942955,
+            "max_relative_norm_change": 0.010095277078878997
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.68114,
+            "warm_p50_ms": 0.109092,
+            "warm_p95_ms": 0.11626874999999998,
+            "warm_p99_ms": 0.12742882,
+            "samples_ms": [
+              0.111677,
+              0.110699,
+              0.111118,
+              0.130534,
+              0.109651,
+              0.109372,
+              0.113073,
+              0.111188,
+              0.108812,
+              0.11028,
+              0.109302,
+              0.108882,
+              0.109721,
+              0.108324,
+              0.108813,
+              0.109302,
+              0.110209,
+              0.108813,
+              0.109301,
+              0.108813,
+              0.108324,
+              0.11454,
+              0.108743,
+              0.109301,
+              0.109651,
+              0.108883,
+              0.108743,
+              0.115937,
+              0.108393,
+              0.108813,
+              0.113981,
+              0.108324,
+              0.108813,
+              0.107346,
+              0.108812,
+              0.108324,
+              0.108324,
+              0.108324,
+              0.122572,
+              0.108813
+            ],
+            "warm_rows_per_second": 4693286.400469329
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8769360013925565,
+            "character_perplexity": 6.533455663463312,
+            "next_character_accuracy": 0.49539947860757555,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0003079875540441543,
+            "mean_prediction_kl_nats": 8.006796692217607e-05,
+            "prediction_kl_p99_nats": 0.00045658951732107804,
+            "maximum_prediction_kl_nats": 0.10787614291341004,
+            "top1_changed_fraction": 0.002913663548535501,
+            "accuracy_change": 0.0002300260696212475,
+            "maximum_absolute_logit_change": 1.4234192371368408,
+            "maximum_per_target_cross_entropy_increase": 0.9190587997436523
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.0002834098608936371,
+            "mean_prediction_kl_nats": 7.585275770922256e-05,
+            "prediction_kl_p99_nats": 0.00045597743366669087,
+            "maximum_prediction_kl_nats": 0.10639203174675102,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.4199752807617188,
+            "maximum_per_target_cross_entropy_increase": 0.9124231338500977
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.8772440363845078,
+          "character_perplexity": 6.535468506423138,
+          "next_character_accuracy": 0.4951694525379543,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7466553011190267,
+          "character_perplexity": 5.73538741541858,
+          "next_character_accuracy": 0.5228091696695546,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.9",
+          "backend_with_key_registry_bytes": 8191912,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7467407476364325,
+            "character_perplexity": 5.735877505237137,
+            "next_character_accuracy": 0.522579161235912,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 8.545016806342631e-05,
+            "mean_prediction_kl_nats": 7.555171199507978e-05,
+            "prediction_kl_p99_nats": 0.0002332713868702684,
+            "maximum_prediction_kl_nats": 0.07069631943714265,
+            "top1_changed_fraction": 0.0017633979912596795,
+            "accuracy_change": -0.00023000843364262558,
+            "maximum_absolute_logit_change": 1.421870231628418,
+            "maximum_per_target_cross_entropy_increase": 0.5875310897827148
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00011373525728950033,
+              0.0002831974613994154
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.9",
+          "backend_with_key_registry_bytes": 4609985,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7467389892458764,
+            "character_perplexity": 5.735867419333168,
+            "next_character_accuracy": 0.522579161235912,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 8.369162879872298e-05,
+            "mean_prediction_kl_nats": 7.55530360250437e-05,
+            "prediction_kl_p99_nats": 0.00023711060763044312,
+            "maximum_prediction_kl_nats": 0.07071264041728009,
+            "top1_changed_fraction": 0.0017633979912596795,
+            "accuracy_change": -0.00023000843364262558,
+            "maximum_absolute_logit_change": 1.4215927124023438,
+            "maximum_per_target_cross_entropy_increase": 0.5875155925750732
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00011714467232062939,
+              0.0002800202357481195
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.9",
+          "backend_with_key_registry_bytes": 3111386,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7467207411986971,
+            "character_perplexity": 5.735762751908877,
+            "next_character_accuracy": 0.5227325001916737,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 6.544222091906036e-05,
+            "mean_prediction_kl_nats": 7.611414126180771e-05,
+            "prediction_kl_p99_nats": 0.00023912776528949614,
+            "maximum_prediction_kl_nats": 0.07220868673265157,
+            "top1_changed_fraction": 0.002300084336425669,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 1.4234991073608398,
+            "maximum_per_target_cross_entropy_increase": 0.597667932510376
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00014768831565003417,
+              0.00027000310437506474
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7466544953558614,
+            "character_perplexity": 5.735382794056524,
+            "next_character_accuracy": 0.5227325001916737,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -8.057628406771341e-07,
+            "mean_prediction_kl_nats": 3.845799707402909e-09,
+            "prediction_kl_p99_nats": 2.6922498327991973e-08,
+            "maximum_prediction_kl_nats": 8.843846398377895e-08,
+            "top1_changed_fraction": 7.666947788085564e-05,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.0010104477405548096,
+            "maximum_per_target_cross_entropy_increase": 0.0008120536804199219
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7466401825079891,
+            "character_perplexity": 5.735300704982569,
+            "next_character_accuracy": 0.5226558307137928,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.5118496752060422e-05,
+            "mean_prediction_kl_nats": 3.526689483178103e-06,
+            "prediction_kl_p99_nats": 2.802159804706195e-05,
+            "maximum_prediction_kl_nats": 0.00010887467438350836,
+            "top1_changed_fraction": 0.0010733726903319788,
+            "accuracy_change": -0.00015333895576175038,
+            "maximum_absolute_logit_change": 0.04378390312194824,
+            "maximum_per_target_cross_entropy_increase": 0.02187180519104004
+          }
+        }
+      },
+      "checkpoint_sha256": "b1dc4a4b7a8ae2ed1ef9688aa0cccf047c766581b08fe1608fc5625cfc93d0d6",
+      "registry_sha256": "abab407b9c927abc758d3d85a11cec2c2535254fe5af55b6cce10b650a992d4d"
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "rows": 43152,
+      "dim": 64,
+      "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+      "source_float32_bytes": 11046912,
+      "key_registry_bytes": 736107,
+      "unchanged_backbone_artifact_bytes": 827998,
+      "alternative_datrie_key_index_bytes": 346160,
+      "query_rows": 512,
+      "query_ids_sha256": "43ca78408803e060726877734dd5761b4e85ad9be7de5a6b6d8601f32db85068",
+      "frequency_trace_sha256": "7ba41132ac5296b1ee890e8c97c4f892398df8fb97e4bbb475dab44b5c5af0cc",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 11046912,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "table_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.05895057111047208,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 11047717,
+          "backend_with_key_registry_bytes": 11783824,
+          "backend_with_datrie_key_index_bytes": 11393877,
+          "full_model_serving_artifact_bytes": 12611822,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.240883,
+            "warm_p50_ms": 0.0468635,
+            "warm_p95_ms": 0.0497059,
+            "warm_p99_ms": 0.07372593999999998,
+            "samples_ms": [
+              0.049238,
+              0.046305,
+              0.088489,
+              0.049657,
+              0.046793,
+              0.046374,
+              0.046375,
+              0.04875,
+              0.046794,
+              0.046235,
+              0.047283,
+              0.046794,
+              0.048191,
+              0.046794,
+              0.047283,
+              0.047282,
+              0.046794,
+              0.046724,
+              0.046305,
+              0.046793,
+              0.047283,
+              0.046375,
+              0.046375,
+              0.047282,
+              0.047282,
+              0.050635,
+              0.049238,
+              0.046444,
+              0.047841,
+              0.047352,
+              0.04826,
+              0.046794,
+              0.046864,
+              0.047772,
+              0.046374,
+              0.046863,
+              0.046864,
+              0.046375,
+              0.046374,
+              0.047352
+            ],
+            "warm_rows_per_second": 10925347.01846853
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873996702168374,
+            "character_perplexity": 6.514280077498528,
+            "next_character_accuracy": 0.5035270664008588,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10651825,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "table_sha256": "135de811416f938de0eb92c8b6a88aa9a431a4329bf7d25c64da79dc7640765d",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.912386961048469,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10653037,
+          "backend_with_key_registry_bytes": 11389144,
+          "backend_with_datrie_key_index_bytes": 10999197,
+          "full_model_serving_artifact_bytes": 12217142,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.196884,
+            "warm_p50_ms": 0.0549305,
+            "warm_p95_ms": 0.05731885,
+            "warm_p99_ms": 0.06519124,
+            "samples_ms": [
+              0.05727,
+              0.055873,
+              0.069631,
+              0.056781,
+              0.058247,
+              0.056292,
+              0.055803,
+              0.054895,
+              0.055803,
+              0.056223,
+              0.056781,
+              0.056362,
+              0.054896,
+              0.053988,
+              0.054965,
+              0.053918,
+              0.054407,
+              0.055873,
+              0.056711,
+              0.055384,
+              0.055873,
+              0.055315,
+              0.053987,
+              0.056362,
+              0.055803,
+              0.055384,
+              0.053498,
+              0.053987,
+              0.05294,
+              0.054336,
+              0.054895,
+              0.05308,
+              0.054476,
+              0.053498,
+              0.054476,
+              0.053498,
+              0.053429,
+              0.05294,
+              0.05294,
+              0.053499
+            ],
+            "warm_rows_per_second": 9320869.09822412
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873996702168374,
+            "character_perplexity": 6.514280077498528,
+            "next_character_accuracy": 0.5035270664008588,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10651825,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "table_sha256": "135de811416f938de0eb92c8b6a88aa9a431a4329bf7d25c64da79dc7640765d",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 1.0875776370521635,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10653036,
+          "backend_with_key_registry_bytes": 11389143,
+          "backend_with_datrie_key_index_bytes": 10999196,
+          "full_model_serving_artifact_bytes": 12217141,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.188851,
+            "warm_p50_ms": 0.055384,
+            "warm_p95_ms": 0.0569173,
+            "warm_p99_ms": 0.06571843,
+            "samples_ms": [
+              0.058177,
+              0.055384,
+              0.056292,
+              0.054895,
+              0.055804,
+              0.055873,
+              0.053987,
+              0.053499,
+              0.054896,
+              0.053499,
+              0.053918,
+              0.053428,
+              0.07054,
+              0.055384,
+              0.055384,
+              0.056851,
+              0.055385,
+              0.055734,
+              0.055733,
+              0.055803,
+              0.055314,
+              0.054826,
+              0.054895,
+              0.055804,
+              0.055734,
+              0.055803,
+              0.056292,
+              0.054825,
+              0.055803,
+              0.055803,
+              0.054826,
+              0.054896,
+              0.056851,
+              0.055384,
+              0.054406,
+              0.056292,
+              0.053847,
+              0.052939,
+              0.053498,
+              0.055384
+            ],
+            "warm_rows_per_second": 9244547.161635129
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873996702168374,
+            "character_perplexity": 6.514280077498528,
+            "next_character_accuracy": 0.5035270664008588,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10651825,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "table_sha256": "135de811416f938de0eb92c8b6a88aa9a431a4329bf7d25c64da79dc7640765d",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9435423500835896,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10653036,
+          "backend_with_key_registry_bytes": 11389143,
+          "backend_with_datrie_key_index_bytes": 10999196,
+          "full_model_serving_artifact_bytes": 12217141,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.176001,
+            "warm_p50_ms": 0.055873,
+            "warm_p95_ms": 0.05729095,
+            "warm_p99_ms": 0.05858326,
+            "samples_ms": [
+              0.059155,
+              0.056781,
+              0.054825,
+              0.054895,
+              0.055803,
+              0.056223,
+              0.055314,
+              0.055314,
+              0.056292,
+              0.056292,
+              0.055385,
+              0.056292,
+              0.056292,
+              0.055873,
+              0.056292,
+              0.054407,
+              0.055873,
+              0.056362,
+              0.056362,
+              0.056362,
+              0.056223,
+              0.056222,
+              0.055384,
+              0.055314,
+              0.056711,
+              0.055385,
+              0.057689,
+              0.056711,
+              0.05727,
+              0.056711,
+              0.055733,
+              0.055384,
+              0.055315,
+              0.055734,
+              0.056362,
+              0.055384,
+              0.055384,
+              0.055873,
+              0.055385,
+              0.054407
+            ],
+            "warm_rows_per_second": 9163638.966942888
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873996702168374,
+            "character_perplexity": 6.514280077498528,
+            "next_character_accuracy": 0.5035270664008588,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7466080,
+              "unique_rows": 29797,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29797
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "e6f1a59b18732b2ccca059d7eb3e4d64ff74d96378a19c7ee039c9349d3c48a6",
+            "table_sha256": "bc350fda73574e114a7cadc5cf7f0dff8aa38624fe0814b623f43ec25628ed63",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6810067519545555,
+          "representatives_sha256": "3652f5e1dbffd87708445a47cdbb024b4e5d7094650aad799d8e62ad245812dd",
+          "structurally_merged_rows": 13355,
+          "backend_artifact_bytes": 7467287,
+          "backend_with_key_registry_bytes": 8203394,
+          "backend_with_datrie_key_index_bytes": 7813447,
+          "full_model_serving_artifact_bytes": 9031392,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900334924016594,
+            "mean_cosine": 0.9997199486281269,
+            "p05_cosine": 0.9986676323241817,
+            "relative_l2_mean": 0.012526903122645183,
+            "relative_l2_p95": 0.05181032951262053,
+            "relative_l2_max": 0.14116478475441507,
+            "weighted_relative_l2_mean": 0.002007054021764998,
+            "weighted_relative_frobenius": 0.012525398130393038,
+            "weighted_mean_cosine": 0.9999602049532175,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900334924016594,
+            "mean_cosine": 0.9997199486281269,
+            "p05_cosine": 0.9986676323241817,
+            "relative_l2_mean": 0.012526903122645183,
+            "relative_l2_p95": 0.05181032951262053,
+            "relative_l2_max": 0.14116478475441507,
+            "weighted_relative_l2_mean": 0.002007054021764998,
+            "weighted_relative_frobenius": 0.012525398130393038,
+            "weighted_mean_cosine": 0.9999602049532175,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.74934,
+            "warm_p50_ms": 0.0558385,
+            "warm_p95_ms": 0.058321149999999995,
+            "warm_p99_ms": 0.06943399,
+            "samples_ms": [
+              0.058178,
+              0.05727,
+              0.056781,
+              0.057759,
+              0.056293,
+              0.055803,
+              0.055314,
+              0.056292,
+              0.054825,
+              0.056292,
+              0.055315,
+              0.055803,
+              0.056711,
+              0.054336,
+              0.055803,
+              0.054756,
+              0.0748,
+              0.061041,
+              0.055873,
+              0.055873,
+              0.054896,
+              0.055874,
+              0.056292,
+              0.055873,
+              0.055873,
+              0.055803,
+              0.056292,
+              0.056362,
+              0.056781,
+              0.055803,
+              0.055804,
+              0.054826,
+              0.054895,
+              0.055873,
+              0.055733,
+              0.055733,
+              0.055315,
+              0.055804,
+              0.054826,
+              0.055803
+            ],
+            "warm_rows_per_second": 9169300.751273762
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874021198972967,
+            "character_perplexity": 6.514439658499254,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.4497104641860765e-05,
+            "mean_prediction_kl_nats": 7.042508406295861e-06,
+            "prediction_kl_p99_nats": 0.00011149122424128026,
+            "maximum_prediction_kl_nats": 0.006084268086667243,
+            "top1_changed_fraction": 0.0006134028523232633,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.360864520072937,
+            "maximum_per_target_cross_entropy_increase": 0.08151006698608398
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 2.4497104641860765e-05,
+            "mean_prediction_kl_nats": 7.042508406295861e-06,
+            "prediction_kl_p99_nats": 0.00011149122424128026,
+            "maximum_prediction_kl_nats": 0.006084268086667243,
+            "top1_changed_fraction": 0.0006134028523232633,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.360864520072937,
+            "maximum_per_target_cross_entropy_increase": 0.08151006698608398
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7461116,
+              "unique_rows": 29777,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 931,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 931,
+              "zlib_blocks": 931,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29777
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "9f3eed8a373ac6e2b6ca62816734806b6987c4b9bd3514d1bb7aa8f33095cb6e",
+            "table_sha256": "1113a1cbe20f280a6e6c0b9db01883080e7aa1c4b5b231399c21c5e1f5d95fe4",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6789274350740016,
+          "representatives_sha256": "f1d3dab05a26df4964bf133a26202cb3e62b81bf9d91e50daad9713a0a5a6bc6",
+          "structurally_merged_rows": 13375,
+          "backend_artifact_bytes": 7462323,
+          "backend_with_key_registry_bytes": 8198430,
+          "backend_with_datrie_key_index_bytes": 7808483,
+          "full_model_serving_artifact_bytes": 9026428,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9801761387231435,
+            "mean_cosine": 0.999709929561454,
+            "p05_cosine": 0.9986587196347765,
+            "relative_l2_mean": 0.01263662077792843,
+            "relative_l2_p95": 0.05195302074014606,
+            "relative_l2_max": 0.1987708157070306,
+            "weighted_relative_l2_mean": 0.0020355184953020798,
+            "weighted_relative_frobenius": 0.013253868377612358,
+            "weighted_mean_cosine": 0.9999578304533462,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9801761387231435,
+            "mean_cosine": 0.999709929561454,
+            "p05_cosine": 0.9986587196347765,
+            "relative_l2_mean": 0.01263662077792843,
+            "relative_l2_p95": 0.05195302074014606,
+            "relative_l2_max": 0.1987708157070306,
+            "weighted_relative_l2_mean": 0.0020355184953020798,
+            "weighted_relative_frobenius": 0.013253868377612358,
+            "weighted_mean_cosine": 0.9999578304533462,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.488692,
+            "warm_p50_ms": 0.0544415,
+            "warm_p95_ms": 0.055803,
+            "warm_p99_ms": 0.05665517,
+            "samples_ms": [
+              0.0572,
+              0.055734,
+              0.054826,
+              0.055803,
+              0.054825,
+              0.055803,
+              0.055384,
+              0.054407,
+              0.053848,
+              0.055803,
+              0.053918,
+              0.054895,
+              0.054895,
+              0.053918,
+              0.054476,
+              0.05252,
+              0.054825,
+              0.053847,
+              0.05301,
+              0.054407,
+              0.054966,
+              0.054896,
+              0.05287,
+              0.054337,
+              0.053917,
+              0.054406,
+              0.054406,
+              0.054965,
+              0.053428,
+              0.053359,
+              0.053499,
+              0.054476,
+              0.054896,
+              0.054896,
+              0.053988,
+              0.054407,
+              0.054337,
+              0.055315,
+              0.054826,
+              0.053429
+            ],
+            "warm_rows_per_second": 9404590.24824812
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874016033993057,
+            "character_perplexity": 6.5144060116361855,
+            "next_character_accuracy": 0.5036804171139396,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.9332011543706106e-05,
+            "mean_prediction_kl_nats": 1.4418529893776803e-05,
+            "prediction_kl_p99_nats": 0.00012110718802732223,
+            "maximum_prediction_kl_nats": 0.022813439426192204,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.360864520072937,
+            "maximum_per_target_cross_entropy_increase": 0.353954553604126
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.9332011543706106e-05,
+            "mean_prediction_kl_nats": 1.4418529893776803e-05,
+            "prediction_kl_p99_nats": 0.00012110718802732223,
+            "maximum_prediction_kl_nats": 0.022813439426192204,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.360864520072937,
+            "maximum_per_target_cross_entropy_increase": 0.353954553604126
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7458808,
+              "unique_rows": 29767,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 931,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 931,
+              "zlib_blocks": 931,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29767
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "040815345c80f0bb2398856e2464c38ef258c14a58bc8cd72ad18a329d881b2b",
+            "table_sha256": "2acf8ed5238bb7eab2d52639b9d31c3aec424c86375473c0ac44b15c568f4f9f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6844950481317937,
+          "representatives_sha256": "dbdaaf7bd53b24b9909da72b1886fb7acf31042b9137425933ea1675db39a68b",
+          "structurally_merged_rows": 13385,
+          "backend_artifact_bytes": 7460015,
+          "backend_with_key_registry_bytes": 8196122,
+          "backend_with_datrie_key_index_bytes": 7806175,
+          "full_model_serving_artifact_bytes": 9024120,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9700479192000054,
+            "mean_cosine": 0.9997034923496534,
+            "p05_cosine": 0.9986566517495193,
+            "relative_l2_mean": 0.012692843287476942,
+            "relative_l2_p95": 0.05202228637995757,
+            "relative_l2_max": 0.24495158161554725,
+            "weighted_relative_l2_mean": 0.002078217974107309,
+            "weighted_relative_frobenius": 0.01413688195204179,
+            "weighted_mean_cosine": 0.9999530586187222,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9700479192000054,
+            "mean_cosine": 0.9997034923496534,
+            "p05_cosine": 0.9986566517495193,
+            "relative_l2_mean": 0.012692843287476942,
+            "relative_l2_p95": 0.05202228637995757,
+            "relative_l2_max": 0.24495158161554725,
+            "weighted_relative_l2_mean": 0.002078217974107309,
+            "weighted_relative_frobenius": 0.01413688195204179,
+            "weighted_mean_cosine": 0.9999530586187222,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.694933,
+            "warm_p50_ms": 0.0544415,
+            "warm_p95_ms": 0.055873,
+            "warm_p99_ms": 0.055873,
+            "samples_ms": [
+              0.055873,
+              0.055803,
+              0.055384,
+              0.054407,
+              0.055315,
+              0.055385,
+              0.054965,
+              0.054476,
+              0.054407,
+              0.055873,
+              0.053987,
+              0.054476,
+              0.054825,
+              0.054336,
+              0.053429,
+              0.053499,
+              0.054477,
+              0.054966,
+              0.053499,
+              0.053429,
+              0.053498,
+              0.055873,
+              0.055873,
+              0.055384,
+              0.055734,
+              0.055314,
+              0.054336,
+              0.055314,
+              0.05301,
+              0.054895,
+              0.053569,
+              0.053429,
+              0.053848,
+              0.053498,
+              0.053568,
+              0.053917,
+              0.053499,
+              0.053499,
+              0.055315,
+              0.053499
+            ],
+            "warm_rows_per_second": 9404590.24824812
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8738604000223773,
+            "character_perplexity": 6.513392227653635,
+            "next_character_accuracy": 0.5038337678270204,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00013629285728137262,
+            "mean_prediction_kl_nats": 3.678425188654329e-05,
+            "prediction_kl_p99_nats": 0.0001588043345496865,
+            "maximum_prediction_kl_nats": 0.03321836029867732,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.40522003173828125,
+            "maximum_per_target_cross_entropy_increase": 0.373732328414917
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00013629285728137262,
+            "mean_prediction_kl_nats": 3.678425188654329e-05,
+            "prediction_kl_p99_nats": 0.0001588043345496865,
+            "maximum_prediction_kl_nats": 0.03321836029867732,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.40522003173828125,
+            "maximum_per_target_cross_entropy_increase": 0.373732328414917
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7455090,
+              "unique_rows": 29751,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 930,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 930,
+              "zlib_blocks": 930,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29751
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "21aeab503f5167197e19e2bacc9b24daf83bde215cdf92ecf53cd8c7869438c7",
+            "table_sha256": "471e28d4ce98ba96d6e521559d47a96b0f95383516d8c2c9a2c8e6300b3f2181",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6882852690760046,
+          "representatives_sha256": "9472bfcc8138076a97955f7e03d674e66f41b00a37eec5d1b506a610ab62477e",
+          "structurally_merged_rows": 13401,
+          "backend_artifact_bytes": 7456297,
+          "backend_with_key_registry_bytes": 8192404,
+          "backend_with_datrie_key_index_bytes": 7802457,
+          "full_model_serving_artifact_bytes": 9020402,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9511890967280789,
+            "mean_cosine": 0.9996853054841821,
+            "p05_cosine": 0.998652364283855,
+            "relative_l2_mean": 0.012823303720665598,
+            "relative_l2_p95": 0.05210850837998779,
+            "relative_l2_max": 0.31190380849243704,
+            "weighted_relative_l2_mean": 0.0021191932688392873,
+            "weighted_relative_frobenius": 0.01549617638905431,
+            "weighted_mean_cosine": 0.9999475656981209,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9511890967280789,
+            "mean_cosine": 0.9996853054841821,
+            "p05_cosine": 0.998652364283855,
+            "relative_l2_mean": 0.012823303720665598,
+            "relative_l2_p95": 0.05210850837998779,
+            "relative_l2_max": 0.31190380849243704,
+            "weighted_relative_l2_mean": 0.0021191932688392873,
+            "weighted_relative_frobenius": 0.01549617638905431,
+            "weighted_mean_cosine": 0.9999475656981209,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.810381,
+            "warm_p50_ms": 0.0553845,
+            "warm_p95_ms": 0.058111499999999996,
+            "warm_p99_ms": 0.07896801999999997,
+            "samples_ms": [
+              0.058178,
+              0.057759,
+              0.058108,
+              0.055873,
+              0.055803,
+              0.055873,
+              0.053987,
+              0.055314,
+              0.053987,
+              0.055384,
+              0.055384,
+              0.057689,
+              0.055384,
+              0.055873,
+              0.054895,
+              0.055803,
+              0.055804,
+              0.055804,
+              0.053848,
+              0.055384,
+              0.053918,
+              0.055803,
+              0.055803,
+              0.09226,
+              0.056292,
+              0.055315,
+              0.055385,
+              0.054965,
+              0.054895,
+              0.056851,
+              0.055384,
+              0.055454,
+              0.055873,
+              0.054406,
+              0.056781,
+              0.054406,
+              0.053498,
+              0.054826,
+              0.054896,
+              0.053918
+            ],
+            "warm_rows_per_second": 9244463.703743827
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8737053970996589,
+            "character_perplexity": 6.512382711062569,
+            "next_character_accuracy": 0.5038337678270204,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.00029126264351335006,
+            "mean_prediction_kl_nats": 7.012482966510538e-05,
+            "prediction_kl_p99_nats": 0.00021856286480779978,
+            "maximum_prediction_kl_nats": 0.16057564868335505,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.6747455596923828,
+            "maximum_per_target_cross_entropy_increase": 0.704582154750824
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00029126264351335006,
+            "mean_prediction_kl_nats": 7.012482966510538e-05,
+            "prediction_kl_p99_nats": 0.00021856286480779978,
+            "maximum_prediction_kl_nats": 0.16057564868335505,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.6747455596923828,
+            "maximum_per_target_cross_entropy_increase": 0.704582154750824
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7447623,
+              "unique_rows": 29720,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 929,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 929,
+              "zlib_blocks": 929,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29720
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "fa04c36d71797751dc8dff98932c0d08480d29168cd1219aa9bbd45fa892e823",
+            "table_sha256": "8554325ce8d9cc6b9aaae4e9bd8bf607a17749be533f5e93dfa09fe2d5c5ec3a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6912711260374635,
+          "representatives_sha256": "abcf9fbaa2f2ed444d9b68b184addbd08254ddd1d9be6eef0ebcdf187d0aab12",
+          "structurally_merged_rows": 13432,
+          "backend_artifact_bytes": 7448830,
+          "backend_with_key_registry_bytes": 8184937,
+          "backend_with_datrie_key_index_bytes": 7794990,
+          "full_model_serving_artifact_bytes": 9012935,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9025613601953411,
+            "mean_cosine": 0.9996067258313748,
+            "p05_cosine": 0.9986418040995083,
+            "relative_l2_mean": 0.013220066766763107,
+            "relative_l2_p95": 0.052349069892072136,
+            "relative_l2_max": 0.4405381737648303,
+            "weighted_relative_l2_mean": 0.0023323067816422806,
+            "weighted_relative_frobenius": 0.02297713792438167,
+            "weighted_mean_cosine": 0.9999051293131374,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9025613601953411,
+            "mean_cosine": 0.9996067258313748,
+            "p05_cosine": 0.9986418040995083,
+            "relative_l2_mean": 0.013220066766763107,
+            "relative_l2_p95": 0.052349069892072136,
+            "relative_l2_max": 0.4405381737648303,
+            "weighted_relative_l2_mean": 0.0023323067816422806,
+            "weighted_relative_frobenius": 0.02297713792438167,
+            "weighted_mean_cosine": 0.9999051293131374,
+            "max_relative_norm_change": 0.010097123753310348
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.38882,
+            "warm_p50_ms": 0.054372000000000004,
+            "warm_p95_ms": 0.06370569999999995,
+            "warm_p99_ms": 0.07939648,
+            "samples_ms": [
+              0.056362,
+              0.056781,
+              0.055454,
+              0.055873,
+              0.055384,
+              0.054476,
+              0.055873,
+              0.055804,
+              0.055384,
+              0.053987,
+              0.053918,
+              0.053918,
+              0.054337,
+              0.053429,
+              0.056781,
+              0.056362,
+              0.053917,
+              0.053918,
+              0.053988,
+              0.053988,
+              0.054826,
+              0.053848,
+              0.054337,
+              0.054337,
+              0.054337,
+              0.079969,
+              0.078501,
+              0.062927,
+              0.054337,
+              0.053848,
+              0.053917,
+              0.054895,
+              0.055314,
+              0.054407,
+              0.054407,
+              0.054058,
+              0.055804,
+              0.053918,
+              0.053988,
+              0.054337
+            ],
+            "warm_rows_per_second": 9416611.49120871
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8741347379235438,
+            "character_perplexity": 6.51517934313239,
+            "next_character_accuracy": 0.504140469253182,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.00013804528254298488,
+            "mean_prediction_kl_nats": 0.00026054510540956394,
+            "prediction_kl_p99_nats": 0.0009175388561113203,
+            "maximum_prediction_kl_nats": 0.4085219028683875,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": 0.0006134028523232526,
+            "maximum_absolute_logit_change": 1.6836999654769897,
+            "maximum_per_target_cross_entropy_increase": 1.219319224357605
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00013804528254298488,
+            "mean_prediction_kl_nats": 0.00026054510540956394,
+            "prediction_kl_p99_nats": 0.0009175388561113203,
+            "maximum_prediction_kl_nats": 0.4085219028683875,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": 0.0006134028523232526,
+            "maximum_absolute_logit_change": 1.6836999654769897,
+            "maximum_per_target_cross_entropy_increase": 1.219319224357605
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 5523456,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b9e46c364634283ab41e551138f1ada23921e31ee48a04dd3989a3da162f7b1f",
+            "table_sha256": "be124675b47f909e61b0388745ad00b3ed3a74bff02b3b5a333d38787d391165",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07052363315597177,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5524261,
+          "backend_with_key_registry_bytes": 6260368,
+          "backend_with_datrie_key_index_bytes": 5870421,
+          "full_model_serving_artifact_bytes": 7088366,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999539845378,
+            "mean_cosine": 0.9999999792071412,
+            "p05_cosine": 0.9999999715996549,
+            "relative_l2_mean": 0.00020637351738737785,
+            "relative_l2_p95": 0.00024209629415095646,
+            "relative_l2_max": 0.0003075455058483477,
+            "weighted_relative_l2_mean": 7.822433519936367e-05,
+            "weighted_relative_frobenius": 0.00020811630848376357,
+            "weighted_mean_cosine": 0.9999999921676113,
+            "max_relative_norm_change": 0.00018268239076675474
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.313238,
+            "warm_p50_ms": 0.139613,
+            "warm_p95_ms": 0.14054195,
+            "warm_p99_ms": 0.15278376,
+            "samples_ms": [
+              0.140102,
+              0.140521,
+              0.140032,
+              0.139613,
+              0.139543,
+              0.140521,
+              0.139543,
+              0.139124,
+              0.138704,
+              0.140032,
+              0.140032,
+              0.139962,
+              0.140032,
+              0.138635,
+              0.140032,
+              0.160356,
+              0.14094,
+              0.140032,
+              0.139124,
+              0.139124,
+              0.138216,
+              0.139613,
+              0.140032,
+              0.140032,
+              0.140032,
+              0.140102,
+              0.139613,
+              0.139543,
+              0.139473,
+              0.138635,
+              0.139543,
+              0.138146,
+              0.139613,
+              0.139543,
+              0.139613,
+              0.138705,
+              0.138705,
+              0.139124,
+              0.139612,
+              0.138635
+            ],
+            "warm_rows_per_second": 3667280.267596857
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739957233721811,
+            "character_perplexity": 6.514273701349109,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -9.787957139825886e-07,
+            "mean_prediction_kl_nats": 4.398342473752485e-09,
+            "prediction_kl_p99_nats": 3.380791472690338e-08,
+            "maximum_prediction_kl_nats": 9.409525687431273e-08,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.001085519790649414,
+            "maximum_per_target_cross_entropy_increase": 0.0008978843688964844
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5452876,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b9e46c364634283ab41e551138f1ada23921e31ee48a04dd3989a3da162f7b1f",
+            "table_sha256": "47d81729a61e6f79f28618ae7a0f10d49efd41fdc2fae99dbdf19e801e0afc05",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5023319700267166,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5454084,
+          "backend_with_key_registry_bytes": 6190191,
+          "backend_with_datrie_key_index_bytes": 5800244,
+          "full_model_serving_artifact_bytes": 7018189,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999539845378,
+            "mean_cosine": 0.9999999792071412,
+            "p05_cosine": 0.9999999715996549,
+            "relative_l2_mean": 0.00020637351738737785,
+            "relative_l2_p95": 0.00024209629415095646,
+            "relative_l2_max": 0.0003075455058483477,
+            "weighted_relative_l2_mean": 7.822433519936367e-05,
+            "weighted_relative_frobenius": 0.00020811630848376357,
+            "weighted_mean_cosine": 0.9999999921676113,
+            "max_relative_norm_change": 0.00018268239076675474
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.930509,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.15575609999999998,
+            "warm_p99_ms": 0.17258563,
+            "samples_ms": [
+              0.153232,
+              0.155117,
+              0.149111,
+              0.147156,
+              0.147645,
+              0.147085,
+              0.147156,
+              0.147156,
+              0.147155,
+              0.146248,
+              0.146666,
+              0.147156,
+              0.146666,
+              0.148064,
+              0.147575,
+              0.151346,
+              0.146667,
+              0.147156,
+              0.147156,
+              0.146666,
+              0.146597,
+              0.152813,
+              0.146178,
+              0.146667,
+              0.147156,
+              0.167899,
+              0.175582,
+              0.14995,
+              0.152394,
+              0.148064,
+              0.146178,
+              0.147644,
+              0.147086,
+              0.147645,
+              0.147644,
+              0.147156,
+              0.145759,
+              0.147645,
+              0.147156,
+              0.147644
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739957233721811,
+            "character_perplexity": 6.514273701349109,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -9.787957139825886e-07,
+            "mean_prediction_kl_nats": 4.398342473752485e-09,
+            "prediction_kl_p99_nats": 3.380791472690338e-08,
+            "maximum_prediction_kl_nats": 9.409525687431273e-08,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.001085519790649414,
+            "maximum_per_target_cross_entropy_increase": 0.0008978843688964844
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5452876,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b9e46c364634283ab41e551138f1ada23921e31ee48a04dd3989a3da162f7b1f",
+            "table_sha256": "47d81729a61e6f79f28618ae7a0f10d49efd41fdc2fae99dbdf19e801e0afc05",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6999258659780025,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5454083,
+          "backend_with_key_registry_bytes": 6190190,
+          "backend_with_datrie_key_index_bytes": 5800243,
+          "full_model_serving_artifact_bytes": 7018188,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999539845378,
+            "mean_cosine": 0.9999999792071412,
+            "p05_cosine": 0.9999999715996549,
+            "relative_l2_mean": 0.00020637351738737785,
+            "relative_l2_p95": 0.00024209629415095646,
+            "relative_l2_max": 0.0003075455058483477,
+            "weighted_relative_l2_mean": 7.822433519936367e-05,
+            "weighted_relative_frobenius": 0.00020811630848376357,
+            "weighted_mean_cosine": 0.9999999921676113,
+            "max_relative_norm_change": 0.00018268239076675474
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.930508,
+            "warm_p50_ms": 0.147574,
+            "warm_p95_ms": 0.1495578,
+            "warm_p99_ms": 0.16496409999999997,
+            "samples_ms": [
+              0.14946,
+              0.148063,
+              0.149041,
+              0.147645,
+              0.146667,
+              0.147575,
+              0.148134,
+              0.147156,
+              0.147574,
+              0.147644,
+              0.147575,
+              0.146178,
+              0.147226,
+              0.147645,
+              0.147574,
+              0.147645,
+              0.173626,
+              0.151416,
+              0.148063,
+              0.146178,
+              0.147225,
+              0.146667,
+              0.147155,
+              0.147645,
+              0.146667,
+              0.147644,
+              0.147086,
+              0.147156,
+              0.148064,
+              0.145759,
+              0.147225,
+              0.146178,
+              0.147644,
+              0.146178,
+              0.146178,
+              0.147086,
+              0.147575,
+              0.147644,
+              0.145829,
+              0.145759
+            ],
+            "warm_rows_per_second": 3469445.8373426213
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739957233721811,
+            "character_perplexity": 6.514273701349109,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -9.787957139825886e-07,
+            "mean_prediction_kl_nats": 4.398342473752485e-09,
+            "prediction_kl_p99_nats": 3.380791472690338e-08,
+            "maximum_prediction_kl_nats": 9.409525687431273e-08,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.001085519790649414,
+            "maximum_per_target_cross_entropy_increase": 0.0008978843688964844
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5452876,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "b9e46c364634283ab41e551138f1ada23921e31ee48a04dd3989a3da162f7b1f",
+            "table_sha256": "47d81729a61e6f79f28618ae7a0f10d49efd41fdc2fae99dbdf19e801e0afc05",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5259647469501942,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5454083,
+          "backend_with_key_registry_bytes": 6190190,
+          "backend_with_datrie_key_index_bytes": 5800243,
+          "full_model_serving_artifact_bytes": 7018188,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999539845378,
+            "mean_cosine": 0.9999999792071412,
+            "p05_cosine": 0.9999999715996549,
+            "relative_l2_mean": 0.00020637351738737785,
+            "relative_l2_p95": 0.00024209629415095646,
+            "relative_l2_max": 0.0003075455058483477,
+            "weighted_relative_l2_mean": 7.822433519936367e-05,
+            "weighted_relative_frobenius": 0.00020811630848376357,
+            "weighted_mean_cosine": 0.9999999921676113,
+            "max_relative_norm_change": 0.00018268239076675474
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.901175,
+            "warm_p50_ms": 0.146667,
+            "warm_p95_ms": 0.14946705,
+            "warm_p99_ms": 0.16160935,
+            "samples_ms": [
+              0.149041,
+              0.164197,
+              0.145689,
+              0.146178,
+              0.147156,
+              0.148133,
+              0.147645,
+              0.146667,
+              0.147156,
+              0.148552,
+              0.148134,
+              0.14534,
+              0.145759,
+              0.147225,
+              0.147156,
+              0.146667,
+              0.147086,
+              0.147086,
+              0.146177,
+              0.146597,
+              0.145689,
+              0.147156,
+              0.145758,
+              0.146248,
+              0.147155,
+              0.146737,
+              0.147645,
+              0.157562,
+              0.147645,
+              0.145759,
+              0.145759,
+              0.1452,
+              0.146597,
+              0.145689,
+              0.146108,
+              0.14527,
+              0.1452,
+              0.146108,
+              0.146667,
+              0.146178
+            ],
+            "warm_rows_per_second": 3490901.157042825
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739957233721811,
+            "character_perplexity": 6.514273701349109,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -9.787957139825886e-07,
+            "mean_prediction_kl_nats": 4.398342473752485e-09,
+            "prediction_kl_p99_nats": 3.380791472690338e-08,
+            "maximum_prediction_kl_nats": 9.409525687431273e-08,
+            "top1_changed_fraction": 7.667535654040791e-05,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.001085519790649414,
+            "maximum_per_target_cross_entropy_increase": 0.0008978843688964844
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3877911,
+              "unique_rows": 29798,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29798
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "9d9b25970b5839baa32f46c4eddf5e0afa57cf97b2dc9a28b62711e129a6908c",
+            "table_sha256": "9bbe88814651c53a7c993e9a381fce1e95d41be8f2f7c6bc5c45dd69a37f958d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4008830760139972,
+          "representatives_sha256": "bdaa9b3d678298c3f1664248618576322980c801ca815d8de513407a699cddd1",
+          "structurally_merged_rows": 13354,
+          "backend_artifact_bytes": 3879117,
+          "backend_with_key_registry_bytes": 4615224,
+          "backend_with_datrie_key_index_bytes": 4225277,
+          "full_model_serving_artifact_bytes": 5443222,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.990039451270731,
+            "mean_cosine": 0.9997200119638027,
+            "p05_cosine": 0.9986673654831411,
+            "relative_l2_mean": 0.012667019417472036,
+            "relative_l2_p95": 0.051792523979475126,
+            "relative_l2_max": 0.14112562218626845,
+            "weighted_relative_l2_mean": 0.0020723638537687695,
+            "weighted_relative_frobenius": 0.012524791627337375,
+            "weighted_mean_cosine": 0.9999602331100651,
+            "max_relative_norm_change": 0.010122543655169182
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900394695708842,
+            "mean_cosine": 0.9997200247157288,
+            "p05_cosine": 0.9986673862818956,
+            "relative_l2_mean": 0.012524519177028527,
+            "relative_l2_p95": 0.05177717868029783,
+            "relative_l2_max": 0.14112538288419477,
+            "weighted_relative_l2_mean": 0.0020059476275550033,
+            "weighted_relative_frobenius": 0.012523978773244526,
+            "weighted_mean_cosine": 0.9999602374746445,
+            "max_relative_norm_change": 0.01009751476207093
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.298026,
+            "warm_p50_ms": 0.1475745,
+            "warm_p95_ms": 0.15098279999999994,
+            "warm_p99_ms": 0.17603133999999998,
+            "samples_ms": [
+              0.185428,
+              0.150438,
+              0.149041,
+              0.147156,
+              0.148134,
+              0.147575,
+              0.149041,
+              0.148553,
+              0.147086,
+              0.146666,
+              0.147156,
+              0.148134,
+              0.147155,
+              0.146667,
+              0.147086,
+              0.147575,
+              0.147645,
+              0.147575,
+              0.147156,
+              0.146667,
+              0.146667,
+              0.147156,
+              0.147155,
+              0.146667,
+              0.147575,
+              0.148063,
+              0.161334,
+              0.148134,
+              0.147644,
+              0.146667,
+              0.147575,
+              0.147574,
+              0.147575,
+              0.147226,
+              0.146736,
+              0.145759,
+              0.147225,
+              0.147645,
+              0.147156,
+              0.147645
+            ],
+            "warm_rows_per_second": 3469434.082446493
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8740206558292583,
+            "character_perplexity": 6.514436120223299,
+            "next_character_accuracy": 0.5036804171139396,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 2.3953947775293576e-05,
+            "mean_prediction_kl_nats": 7.010273872200154e-06,
+            "prediction_kl_p99_nats": 0.0001103468003908952,
+            "maximum_prediction_kl_nats": 0.006080347595238767,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308086867,
+            "maximum_absolute_logit_change": 0.36091315746307373,
+            "maximum_per_target_cross_entropy_increase": 0.08162784576416016
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 2.4932767893362518e-05,
+            "mean_prediction_kl_nats": 7.003602602614312e-06,
+            "prediction_kl_p99_nats": 0.00011116864650160212,
+            "maximum_prediction_kl_nats": 0.006079277598338604,
+            "top1_changed_fraction": 0.0006134028523232633,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.3609464168548584,
+            "maximum_per_target_cross_entropy_increase": 0.08144903182983398
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3875474,
+              "unique_rows": 29778,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29778
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "782fdd16bf022b85f452a3fa63c38ab86fc43c1e772b1c73e5f0738982fde123",
+            "table_sha256": "79a91ba546e5db38ec196257377e96f0cab6400b051782c78d0d6de8e9240dc5",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.40349130099639297,
+          "representatives_sha256": "daf77d5f2edc82e66988154f46072fa9c85cefe26e5049a12be4d4dff99966b4",
+          "structurally_merged_rows": 13374,
+          "backend_artifact_bytes": 3876680,
+          "backend_with_key_registry_bytes": 4612787,
+          "backend_with_datrie_key_index_bytes": 4222840,
+          "full_model_serving_artifact_bytes": 5440785,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9801798714782947,
+            "mean_cosine": 0.9997099931922108,
+            "p05_cosine": 0.9986591974401371,
+            "relative_l2_mean": 0.012776640825745606,
+            "relative_l2_p95": 0.05196765183434268,
+            "relative_l2_max": 0.19874691425676086,
+            "weighted_relative_l2_mean": 0.0021007940848287313,
+            "weighted_relative_frobenius": 0.013253196770836724,
+            "weighted_mean_cosine": 0.9999578590980495,
+            "max_relative_norm_change": 0.010122543655169182
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9801729436886374,
+            "mean_cosine": 0.9997100055449711,
+            "p05_cosine": 0.9986594034629189,
+            "relative_l2_mean": 0.012634240162831973,
+            "relative_l2_p95": 0.05195050037136643,
+            "relative_l2_max": 0.19878048097632814,
+            "weighted_relative_l2_mean": 0.002034410223639944,
+            "weighted_relative_frobenius": 0.01325250282123261,
+            "weighted_mean_cosine": 0.9999578633213264,
+            "max_relative_norm_change": 0.01009751476207093
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.255353,
+            "warm_p50_ms": 0.14785399999999999,
+            "warm_p95_ms": 0.15053229999999998,
+            "warm_p99_ms": 0.16041869999999997,
+            "samples_ms": [
+              0.150438,
+              0.149041,
+              0.149041,
+              0.148063,
+              0.146248,
+              0.148134,
+              0.147574,
+              0.148134,
+              0.148064,
+              0.146667,
+              0.148064,
+              0.147156,
+              0.148134,
+              0.148063,
+              0.147575,
+              0.146667,
+              0.146178,
+              0.148064,
+              0.165594,
+              0.148064,
+              0.147645,
+              0.146178,
+              0.146667,
+              0.148063,
+              0.148063,
+              0.146248,
+              0.146247,
+              0.14953,
+              0.148133,
+              0.147645,
+              0.146667,
+              0.147156,
+              0.148064,
+              0.147086,
+              0.152324,
+              0.147086,
+              0.148064,
+              0.146178,
+              0.145689,
+              0.146667
+            ],
+            "warm_rows_per_second": 3462875.539383446
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8740154708462469,
+            "character_perplexity": 6.514402343070254,
+            "next_character_accuracy": 0.50375709247048,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.8768854005388793e-05,
+            "mean_prediction_kl_nats": 1.4386399137375463e-05,
+            "prediction_kl_p99_nats": 0.00012141775829092279,
+            "maximum_prediction_kl_nats": 0.022824656101379563,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.36091315746307373,
+            "maximum_per_target_cross_entropy_increase": 0.35405421257019043
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.9747669048305204e-05,
+            "mean_prediction_kl_nats": 1.4377007304061832e-05,
+            "prediction_kl_p99_nats": 0.00012129024920230822,
+            "maximum_prediction_kl_nats": 0.0228160493711172,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.3609464168548584,
+            "maximum_per_target_cross_entropy_increase": 0.3538210391998291
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3874277,
+              "unique_rows": 29768,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29768
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "9bd68315e40ae307540c7d256d24998d9d3202ef99e8f5166e7fe238096854d7",
+            "table_sha256": "6aed3044f8176c82215592f19b3fe5e54556a8974232dfbcfa9fc41c56806047",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4015690570231527,
+          "representatives_sha256": "4ed7525d92e17bb55e1ad0327daad3d71d881ca5f358f7438bf7f26113916e33",
+          "structurally_merged_rows": 13384,
+          "backend_artifact_bytes": 3875483,
+          "backend_with_key_registry_bytes": 4611590,
+          "backend_with_datrie_key_index_bytes": 4221643,
+          "full_model_serving_artifact_bytes": 5439588,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9700413472050464,
+            "mean_cosine": 0.9997035559009319,
+            "p05_cosine": 0.998656604137302,
+            "relative_l2_mean": 0.012832814803887876,
+            "relative_l2_p95": 0.052022599300334385,
+            "relative_l2_max": 0.24497778247547566,
+            "weighted_relative_l2_mean": 0.0021434550655841113,
+            "weighted_relative_frobenius": 0.014136114202284165,
+            "weighted_mean_cosine": 0.9999530878739694,
+            "max_relative_norm_change": 0.010122543655169182
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9700313980960931,
+            "mean_cosine": 0.999703568234334,
+            "p05_cosine": 0.9986563464479082,
+            "relative_l2_mean": 0.012690462636334787,
+            "relative_l2_p95": 0.05202736453606879,
+            "relative_l2_max": 0.245019579774079,
+            "weighted_relative_l2_mean": 0.0020771063840673383,
+            "weighted_relative_frobenius": 0.014135485364462215,
+            "weighted_mean_cosine": 0.9999530921948487,
+            "max_relative_norm_change": 0.01009751476207093
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.326869,
+            "warm_p50_ms": 0.14736500000000002,
+            "warm_p95_ms": 0.14915294999999998,
+            "warm_p99_ms": 0.15864066999999998,
+            "samples_ms": [
+              0.14995,
+              0.148064,
+              0.148134,
+              0.146666,
+              0.147645,
+              0.148134,
+              0.148482,
+              0.148133,
+              0.147575,
+              0.148064,
+              0.148063,
+              0.148064,
+              0.147645,
+              0.147155,
+              0.147156,
+              0.148134,
+              0.146178,
+              0.149111,
+              0.148623,
+              0.147156,
+              0.164197,
+              0.148064,
+              0.148064,
+              0.146736,
+              0.147575,
+              0.147574,
+              0.146178,
+              0.146667,
+              0.146248,
+              0.146667,
+              0.146667,
+              0.146667,
+              0.146597,
+              0.146667,
+              0.146178,
+              0.147156,
+              0.146736,
+              0.146667,
+              0.146736,
+              0.146667
+            ],
+            "warm_rows_per_second": 3474366.369219285
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8738598211558746,
+            "character_perplexity": 6.513388457270146,
+            "next_character_accuracy": 0.5039104431835608,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0001368716447210878,
+            "mean_prediction_kl_nats": 3.6732209213622236e-05,
+            "prediction_kl_p99_nats": 0.00015693520409458672,
+            "maximum_prediction_kl_nats": 0.033190273506776724,
+            "top1_changed_fraction": 0.000996779635025303,
+            "accuracy_change": 0.00038337678270206066,
+            "maximum_absolute_logit_change": 0.40544557571411133,
+            "maximum_per_target_cross_entropy_increase": 0.37369251251220703
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00013589298201857356,
+            "mean_prediction_kl_nats": 3.673704880259792e-05,
+            "prediction_kl_p99_nats": 0.00015812882003475985,
+            "maximum_prediction_kl_nats": 0.03321187035576082,
+            "top1_changed_fraction": 0.0009201042784848949,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.40515899658203125,
+            "maximum_per_target_cross_entropy_increase": 0.3736705780029297
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3872396,
+              "unique_rows": 29752,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 465,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 465,
+              "zlib_blocks": 465,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29752
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "c1894e6d14d5007517c3fb7175d56704105bc24327207f4d75212cc5133dbfc5",
+            "table_sha256": "0adfe65ef6a0467d9e0a6275605eb7935e2535b649cbbc56d8654e12a6ddc2bc",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4069029809907079,
+          "representatives_sha256": "0c7cc9af822d1589ee21fce800aac5ed8e254f42d9fac525e20b9dd249062fcf",
+          "structurally_merged_rows": 13400,
+          "backend_artifact_bytes": 3873602,
+          "backend_with_key_registry_bytes": 4609709,
+          "backend_with_datrie_key_index_bytes": 4219762,
+          "full_model_serving_artifact_bytes": 5437707,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9511896509087922,
+            "mean_cosine": 0.9996853683765607,
+            "p05_cosine": 0.998652332990108,
+            "relative_l2_mean": 0.012963202589690545,
+            "relative_l2_p95": 0.05210069536939933,
+            "relative_l2_max": 0.3119094889464882,
+            "weighted_relative_l2_mean": 0.0021843990687356023,
+            "weighted_relative_frobenius": 0.01549541807315949,
+            "weighted_mean_cosine": 0.9999475954868816,
+            "max_relative_norm_change": 0.010122543655169182
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9512025302127041,
+            "mean_cosine": 0.9996853806504409,
+            "p05_cosine": 0.9986528086901074,
+            "relative_l2_mean": 0.012820928349103153,
+            "relative_l2_p95": 0.05210575018214038,
+            "relative_l2_max": 0.31186810336214976,
+            "weighted_relative_l2_mean": 0.002118075869077449,
+            "weighted_relative_frobenius": 0.015494646561231546,
+            "weighted_mean_cosine": 0.9999476007700012,
+            "max_relative_norm_change": 0.01009751476207093
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.180622,
+            "warm_p50_ms": 0.1476095,
+            "warm_p95_ms": 0.15099685,
+            "warm_p99_ms": 0.15603036,
+            "samples_ms": [
+              0.149949,
+              0.148622,
+              0.149041,
+              0.14946,
+              0.150508,
+              0.148063,
+              0.148134,
+              0.148064,
+              0.146666,
+              0.147156,
+              0.152324,
+              0.147156,
+              0.147156,
+              0.147155,
+              0.145829,
+              0.147155,
+              0.147156,
+              0.147575,
+              0.147644,
+              0.147156,
+              0.1584,
+              0.147645,
+              0.147645,
+              0.147644,
+              0.146108,
+              0.148064,
+              0.146667,
+              0.147156,
+              0.147644,
+              0.145759,
+              0.150438,
+              0.14527,
+              0.147575,
+              0.146248,
+              0.147645,
+              0.147156,
+              0.146248,
+              0.150927,
+              0.147645,
+              0.145689
+            ],
+            "warm_rows_per_second": 3468611.437610723
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873704802799334,
+            "character_perplexity": 6.512378840752558,
+            "next_character_accuracy": 0.5038337678270204,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0002918567705643621,
+            "mean_prediction_kl_nats": 7.006744225829511e-05,
+            "prediction_kl_p99_nats": 0.0002180392407785873,
+            "maximum_prediction_kl_nats": 0.16059932138241623,
+            "top1_changed_fraction": 0.0010734549915657108,
+            "accuracy_change": 0.0003067014261616263,
+            "maximum_absolute_logit_change": 0.6744060516357422,
+            "maximum_per_target_cross_entropy_increase": 0.704634964466095
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00029087825956077327,
+            "mean_prediction_kl_nats": 7.008232032422754e-05,
+            "prediction_kl_p99_nats": 0.00021922514854452263,
+            "maximum_prediction_kl_nats": 0.16065407099670095,
+            "top1_changed_fraction": 0.000996779635025303,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.6747474670410156,
+            "maximum_per_target_cross_entropy_increase": 0.7047379016876221
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3868961,
+              "unique_rows": 29721,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 465,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 465,
+              "zlib_blocks": 465,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29721
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "5f67c5c9174b17f9a730562a640f6edddc1fb2410ce66b1209ed34b965469a37",
+            "table_sha256": "871d86a620030f43e4f7cc52a88633bc1c53230496a9c57a2d84b023ee409808",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.40092847193591297,
+          "representatives_sha256": "a2ea579cb5a89fa4b15bac149075de300a30d73418c9b6b5e8a088103115f9b7",
+          "structurally_merged_rows": 13431,
+          "backend_artifact_bytes": 3870167,
+          "backend_with_key_registry_bytes": 4606274,
+          "backend_with_datrie_key_index_bytes": 4216327,
+          "full_model_serving_artifact_bytes": 5434272,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9025562211609032,
+            "mean_cosine": 0.9996050977484005,
+            "p05_cosine": 0.998641546072824,
+            "relative_l2_mean": 0.013367946057538882,
+            "relative_l2_p95": 0.052355489437242816,
+            "relative_l2_max": 0.44056088115148856,
+            "weighted_relative_l2_mean": 0.0023998581099841584,
+            "weighted_relative_frobenius": 0.02303287968306604,
+            "weighted_mean_cosine": 0.9999046537840203,
+            "max_relative_norm_change": 0.010122543655169182
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9025561051703608,
+            "mean_cosine": 0.9996051090786908,
+            "p05_cosine": 0.9986406985794307,
+            "relative_l2_mean": 0.013225819021885743,
+            "relative_l2_p95": 0.05235133994154282,
+            "relative_l2_max": 0.44059198975890207,
+            "weighted_relative_l2_mean": 0.002333617266413956,
+            "weighted_relative_frobenius": 0.023032520866436014,
+            "weighted_mean_cosine": 0.9999046585494379,
+            "max_relative_norm_change": 0.01009751476207093
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.272882,
+            "warm_p50_ms": 0.146911,
+            "warm_p95_ms": 0.14981974999999997,
+            "warm_p99_ms": 0.1753093,
+            "samples_ms": [
+              0.164616,
+              0.149041,
+              0.148064,
+              0.148134,
+              0.147575,
+              0.147505,
+              0.147645,
+              0.147226,
+              0.146248,
+              0.145759,
+              0.147645,
+              0.146248,
+              0.146178,
+              0.146667,
+              0.146248,
+              0.146667,
+              0.146667,
+              0.148064,
+              0.145689,
+              0.146178,
+              0.147086,
+              0.1452,
+              0.147156,
+              0.147086,
+              0.146667,
+              0.147645,
+              0.146736,
+              0.182146,
+              0.147086,
+              0.146597,
+              0.146667,
+              0.146597,
+              0.147156,
+              0.146248,
+              0.146248,
+              0.148064,
+              0.147575,
+              0.146666,
+              0.146667,
+              0.147156
+            ],
+            "warm_rows_per_second": 3485103.2257625363
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874134437886126,
+            "character_perplexity": 6.515177388335096,
+            "next_character_accuracy": 0.504140469253182,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001377452037514349,
+            "mean_prediction_kl_nats": 0.00026050593387185866,
+            "prediction_kl_p99_nats": 0.0009142191542520585,
+            "maximum_prediction_kl_nats": 0.4085835746528589,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": 0.0006134028523232526,
+            "maximum_absolute_logit_change": 1.6836234331130981,
+            "maximum_per_target_cross_entropy_increase": 1.2192572355270386
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.00013872413524800646,
+            "mean_prediction_kl_nats": 0.000260535456554229,
+            "prediction_kl_p99_nats": 0.0009141126919950614,
+            "maximum_prediction_kl_nats": 0.4085141934177651,
+            "top1_changed_fraction": 0.0014568317742677504,
+            "accuracy_change": 0.0005367274957828183,
+            "maximum_absolute_logit_change": 1.683741807937622,
+            "maximum_per_target_cross_entropy_increase": 1.2193512916564941
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2934336,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "bb7617c7380056f8d86ab747df137ba8166ea9c736901a80e4911c8d837e3aa2",
+            "table_sha256": "61f44b3bbe97af40b409ed69d9a05639fccb6f8c969bbfc0894eb7d256edc14c",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06563159497454762,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2935184,
+          "backend_with_key_registry_bytes": 3671291,
+          "backend_with_datrie_key_index_bytes": 3281344,
+          "full_model_serving_artifact_bytes": 4499289,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999336997816471,
+            "mean_cosine": 0.9999885057292354,
+            "p05_cosine": 0.9999772675626297,
+            "relative_l2_mean": 0.004687375390845569,
+            "relative_l2_p95": 0.006792605888808079,
+            "relative_l2_max": 0.011515823593947355,
+            "weighted_relative_l2_mean": 0.00203790374860136,
+            "weighted_relative_frobenius": 0.0053141135041913715,
+            "weighted_mean_cosine": 0.9999943497303216,
+            "max_relative_norm_change": 0.0029012066989757127
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.278667,
+            "warm_p50_ms": 0.095578,
+            "warm_p95_ms": 0.0980534,
+            "warm_p99_ms": 0.11980672999999997,
+            "samples_ms": [
+              0.09659,
+              0.097987,
+              0.094635,
+              0.095683,
+              0.096521,
+              0.095613,
+              0.095543,
+              0.096032,
+              0.094565,
+              0.094705,
+              0.09659,
+              0.096102,
+              0.096521,
+              0.094635,
+              0.095473,
+              0.095543,
+              0.095123,
+              0.095613,
+              0.132908,
+              0.099315,
+              0.095054,
+              0.096451,
+              0.095962,
+              0.094565,
+              0.094147,
+              0.095613,
+              0.095613,
+              0.095054,
+              0.094565,
+              0.094146,
+              0.094635,
+              0.09659,
+              0.095613,
+              0.094146,
+              0.094076,
+              0.096032,
+              0.095055,
+              0.094705,
+              0.093657,
+              0.097009
+            ],
+            "warm_rows_per_second": 5356881.290673586
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739410775865617,
+            "character_perplexity": 6.513917733471119,
+            "next_character_accuracy": 0.503373715687778,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -5.5623034793995104e-05,
+            "mean_prediction_kl_nats": 3.7121507843531695e-06,
+            "prediction_kl_p99_nats": 2.7568171146506205e-05,
+            "maximum_prediction_kl_nats": 0.0001025896388855517,
+            "top1_changed_fraction": 0.000843428921944487,
+            "accuracy_change": -0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.02931845188140869,
+            "maximum_per_target_cross_entropy_increase": 0.022075176239013672
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288858,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 189,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "bb7617c7380056f8d86ab747df137ba8166ea9c736901a80e4911c8d837e3aa2",
+            "table_sha256": "74f913424babe120d7ec58657fcaa8254d64ec23a6f925f5caa137efd6a1ebba",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.27589925192296505,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290111,
+          "backend_with_key_registry_bytes": 4026218,
+          "backend_with_datrie_key_index_bytes": 3636271,
+          "full_model_serving_artifact_bytes": 4854216,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999336997816471,
+            "mean_cosine": 0.9999885057292354,
+            "p05_cosine": 0.9999772675626297,
+            "relative_l2_mean": 0.004687375390845569,
+            "relative_l2_p95": 0.006792605888808079,
+            "relative_l2_max": 0.011515823593947355,
+            "weighted_relative_l2_mean": 0.00203790374860136,
+            "weighted_relative_frobenius": 0.0053141135041913715,
+            "weighted_mean_cosine": 0.9999943497303216,
+            "max_relative_norm_change": 0.0029012066989757127
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.276688,
+            "warm_p50_ms": 0.111676,
+            "warm_p95_ms": 0.1168729,
+            "warm_p99_ms": 0.13844921999999998,
+            "samples_ms": [
+              0.11447,
+              0.113143,
+              0.111746,
+              0.11028,
+              0.112096,
+              0.110698,
+              0.112165,
+              0.111676,
+              0.112165,
+              0.111606,
+              0.111117,
+              0.111118,
+              0.113562,
+              0.110699,
+              0.110768,
+              0.151905,
+              0.116845,
+              0.111746,
+              0.110628,
+              0.111187,
+              0.117403,
+              0.112584,
+              0.110209,
+              0.11021,
+              0.112584,
+              0.111257,
+              0.112584,
+              0.111676,
+              0.112514,
+              0.110698,
+              0.111746,
+              0.111257,
+              0.112165,
+              0.111187,
+              0.111607,
+              0.111187,
+              0.111606,
+              0.114051,
+              0.112165,
+              0.11028
+            ],
+            "warm_rows_per_second": 4584691.428776102
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739410775865617,
+            "character_perplexity": 6.513917733471119,
+            "next_character_accuracy": 0.503373715687778,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -5.5623034793995104e-05,
+            "mean_prediction_kl_nats": 3.7121507843531695e-06,
+            "prediction_kl_p99_nats": 2.7568171146506205e-05,
+            "maximum_prediction_kl_nats": 0.0001025896388855517,
+            "top1_changed_fraction": 0.000843428921944487,
+            "accuracy_change": -0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.02931845188140869,
+            "maximum_per_target_cross_entropy_increase": 0.022075176239013672
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288858,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 189,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "bb7617c7380056f8d86ab747df137ba8166ea9c736901a80e4911c8d837e3aa2",
+            "table_sha256": "74f913424babe120d7ec58657fcaa8254d64ec23a6f925f5caa137efd6a1ebba",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.43378512701019645,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290110,
+          "backend_with_key_registry_bytes": 4026217,
+          "backend_with_datrie_key_index_bytes": 3636270,
+          "full_model_serving_artifact_bytes": 4854215,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999336997816471,
+            "mean_cosine": 0.9999885057292354,
+            "p05_cosine": 0.9999772675626297,
+            "relative_l2_mean": 0.004687375390845569,
+            "relative_l2_p95": 0.006792605888808079,
+            "relative_l2_max": 0.011515823593947355,
+            "weighted_relative_l2_mean": 0.00203790374860136,
+            "weighted_relative_frobenius": 0.0053141135041913715,
+            "weighted_mean_cosine": 0.9999943497303216,
+            "max_relative_norm_change": 0.0029012066989757127
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.233666,
+            "warm_p50_ms": 0.112095,
+            "warm_p95_ms": 0.11398545,
+            "warm_p99_ms": 0.13829239999999998,
+            "samples_ms": [
+              0.114051,
+              0.113981,
+              0.113981,
+              0.111606,
+              0.110698,
+              0.113562,
+              0.112165,
+              0.111677,
+              0.153791,
+              0.113562,
+              0.112235,
+              0.112096,
+              0.112515,
+              0.112026,
+              0.112096,
+              0.111257,
+              0.112654,
+              0.113073,
+              0.111746,
+              0.112095,
+              0.111606,
+              0.112095,
+              0.112095,
+              0.113982,
+              0.111606,
+              0.112584,
+              0.112654,
+              0.111257,
+              0.111187,
+              0.111606,
+              0.112165,
+              0.111676,
+              0.111676,
+              0.110279,
+              0.111606,
+              0.113073,
+              0.111606,
+              0.111676,
+              0.113562,
+              0.111258
+            ],
+            "warm_rows_per_second": 4567554.306614925
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739410775865617,
+            "character_perplexity": 6.513917733471119,
+            "next_character_accuracy": 0.503373715687778,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -5.5623034793995104e-05,
+            "mean_prediction_kl_nats": 3.7121507843531695e-06,
+            "prediction_kl_p99_nats": 2.7568171146506205e-05,
+            "maximum_prediction_kl_nats": 0.0001025896388855517,
+            "top1_changed_fraction": 0.000843428921944487,
+            "accuracy_change": -0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.02931845188140869,
+            "maximum_per_target_cross_entropy_increase": 0.022075176239013672
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3288858,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 189,
+              "compressed_blocks": 171,
+              "zlib_blocks": 171,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "bb7617c7380056f8d86ab747df137ba8166ea9c736901a80e4911c8d837e3aa2",
+            "table_sha256": "74f913424babe120d7ec58657fcaa8254d64ec23a6f925f5caa137efd6a1ebba",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2810117790941149,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290110,
+          "backend_with_key_registry_bytes": 4026217,
+          "backend_with_datrie_key_index_bytes": 3636270,
+          "full_model_serving_artifact_bytes": 4854215,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999336997816471,
+            "mean_cosine": 0.9999885057292354,
+            "p05_cosine": 0.9999772675626297,
+            "relative_l2_mean": 0.004687375390845569,
+            "relative_l2_p95": 0.006792605888808079,
+            "relative_l2_max": 0.011515823593947355,
+            "weighted_relative_l2_mean": 0.00203790374860136,
+            "weighted_relative_frobenius": 0.0053141135041913715,
+            "weighted_mean_cosine": 0.9999943497303216,
+            "max_relative_norm_change": 0.0029012066989757127
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.260974,
+            "warm_p50_ms": 0.1111875,
+            "warm_p95_ms": 0.1131673,
+            "warm_p99_ms": 0.11900635,
+            "samples_ms": [
+              0.114959,
+              0.111747,
+              0.11021,
+              0.11014,
+              0.110768,
+              0.113073,
+              0.112724,
+              0.112654,
+              0.110699,
+              0.110699,
+              0.111187,
+              0.110768,
+              0.112584,
+              0.110698,
+              0.110279,
+              0.121594,
+              0.113073,
+              0.111257,
+              0.111257,
+              0.111676,
+              0.110698,
+              0.111188,
+              0.111746,
+              0.111188,
+              0.111188,
+              0.110629,
+              0.111258,
+              0.110699,
+              0.110629,
+              0.110209,
+              0.111257,
+              0.110768,
+              0.111118,
+              0.111606,
+              0.110768,
+              0.110769,
+              0.111677,
+              0.111118,
+              0.111747,
+              0.11028
+            ],
+            "warm_rows_per_second": 4604834.176503654
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739410775865617,
+            "character_perplexity": 6.513917733471119,
+            "next_character_accuracy": 0.503373715687778,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -5.5623034793995104e-05,
+            "mean_prediction_kl_nats": 3.7121507843531695e-06,
+            "prediction_kl_p99_nats": 2.7568171146506205e-05,
+            "maximum_prediction_kl_nats": 0.0001025896388855517,
+            "top1_changed_fraction": 0.000843428921944487,
+            "accuracy_change": -0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.02931845188140869,
+            "maximum_per_target_cross_entropy_increase": 0.022075176239013672
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2379211,
+              "unique_rows": 29837,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 73,
+              "compressed_blocks": 176,
+              "zlib_blocks": 176,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29837
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "8172286fbc5317af5b5a2ba6b1ef2e8ddcb94131f7f3161c1742eed051584cae",
+            "table_sha256": "55b9bbcc7c879aec16b4c357810006a72979a7ccdd95a1549ac3022e6d07114f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2349366710986942,
+          "representatives_sha256": "66633aaa9fdad1581dcdb1202f2b849354bcb19e5a8d02743679b259add998bf",
+          "structurally_merged_rows": 13315,
+          "backend_artifact_bytes": 2380461,
+          "backend_with_key_registry_bytes": 3116568,
+          "backend_with_datrie_key_index_bytes": 2726621,
+          "full_model_serving_artifact_bytes": 3944566,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900799715264293,
+            "mean_cosine": 0.99970954983572,
+            "p05_cosine": 0.9986702491886431,
+            "relative_l2_mean": 0.015874600816270342,
+            "relative_l2_p95": 0.05179789153831649,
+            "relative_l2_max": 0.14050498208265808,
+            "weighted_relative_l2_mean": 0.0037786874534360363,
+            "weighted_relative_frobenius": 0.013529571057738162,
+            "weighted_mean_cosine": 0.9999551225814726,
+            "max_relative_norm_change": 0.011715558658246757
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9901108468632621,
+            "mean_cosine": 0.9997145714319482,
+            "p05_cosine": 0.9986559352308194,
+            "relative_l2_mean": 0.01264815975090175,
+            "relative_l2_p95": 0.052037815749830345,
+            "relative_l2_max": 0.14028726985128304,
+            "weighted_relative_l2_mean": 0.0020385130651573904,
+            "weighted_relative_frobenius": 0.01272182586954238,
+            "weighted_mean_cosine": 0.9999593816082257,
+            "max_relative_norm_change": 0.01009139470261335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.947096,
+            "warm_p50_ms": 0.107905,
+            "warm_p95_ms": 0.1122104,
+            "warm_p99_ms": 0.1185691,
+            "samples_ms": [
+              0.111606,
+              0.109371,
+              0.107416,
+              0.107416,
+              0.107835,
+              0.112165,
+              0.109791,
+              0.109232,
+              0.107904,
+              0.108394,
+              0.10979,
+              0.106857,
+              0.107416,
+              0.107416,
+              0.106857,
+              0.107416,
+              0.106997,
+              0.109302,
+              0.108813,
+              0.108813,
+              0.106438,
+              0.108813,
+              0.106438,
+              0.107835,
+              0.122083,
+              0.107416,
+              0.108324,
+              0.107905,
+              0.109791,
+              0.113073,
+              0.107835,
+              0.107416,
+              0.10595,
+              0.108813,
+              0.108813,
+              0.10553,
+              0.108323,
+              0.107905,
+              0.107416,
+              0.107905
+            ],
+            "warm_rows_per_second": 4744914.508132153
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8739633755917202,
+            "character_perplexity": 6.514062982461717,
+            "next_character_accuracy": 0.503373715687778,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.332602132978352e-05,
+            "mean_prediction_kl_nats": 1.0863494809786329e-05,
+            "prediction_kl_p99_nats": 0.00011752400598978473,
+            "maximum_prediction_kl_nats": 0.0061883755217517255,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.3648056983947754,
+            "maximum_per_target_cross_entropy_increase": 0.08214378356933594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 2.2298253760756368e-05,
+            "mean_prediction_kl_nats": 7.166679384055505e-06,
+            "prediction_kl_p99_nats": 0.00011104972881125107,
+            "maximum_prediction_kl_nats": 0.006195155670125636,
+            "top1_changed_fraction": 0.00030670142616163164,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.3624382019042969,
+            "maximum_per_target_cross_entropy_increase": 0.08258438110351562
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2377685,
+              "unique_rows": 29817,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 79,
+              "compressed_blocks": 170,
+              "zlib_blocks": 170,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29817
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "3832fe98629b0bc56baec9e64b59a9982557d483fe1a00beba892840105230fe",
+            "table_sha256": "4435869c4ab0d12beb1785a10160d0b8865ebf9f287588f8469a114e7626355f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24943161406554282,
+          "representatives_sha256": "fad753c23f1e896c85de1704a845834cf5cf67e4a24a73f12602edec0a7162ac",
+          "structurally_merged_rows": 13335,
+          "backend_artifact_bytes": 2378935,
+          "backend_with_key_registry_bytes": 3115042,
+          "backend_with_datrie_key_index_bytes": 2725095,
+          "full_model_serving_artifact_bytes": 3943040,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9801011924241253,
+            "mean_cosine": 0.999700031559149,
+            "p05_cosine": 0.9986624426021717,
+            "relative_l2_mean": 0.015977981942059245,
+            "relative_l2_p95": 0.051972065581319886,
+            "relative_l2_max": 0.1990890449393031,
+            "weighted_relative_l2_mean": 0.00380756158251928,
+            "weighted_relative_frobenius": 0.014230220306088556,
+            "weighted_mean_cosine": 0.999952645760921,
+            "max_relative_norm_change": 0.011715558658246757
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9802193115407607,
+            "mean_cosine": 0.9997050415370483,
+            "p05_cosine": 0.9986480055049344,
+            "relative_l2_mean": 0.012753878617498595,
+            "relative_l2_p95": 0.05220068912360454,
+            "relative_l2_max": 0.19849031765558645,
+            "weighted_relative_l2_mean": 0.0020682031704189092,
+            "weighted_relative_frobenius": 0.01346662504677801,
+            "weighted_mean_cosine": 0.9999568989546193,
+            "max_relative_norm_change": 0.01009139470261335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.821172,
+            "warm_p50_ms": 0.107905,
+            "warm_p95_ms": 0.1115395,
+            "warm_p99_ms": 0.13243932999999997,
+            "samples_ms": [
+              0.110698,
+              0.10979,
+              0.111536,
+              0.109371,
+              0.111188,
+              0.109232,
+              0.108393,
+              0.108813,
+              0.108813,
+              0.109232,
+              0.108813,
+              0.107347,
+              0.108813,
+              0.106857,
+              0.107905,
+              0.107416,
+              0.107416,
+              0.108813,
+              0.145759,
+              0.111606,
+              0.107416,
+              0.106928,
+              0.107416,
+              0.106927,
+              0.106927,
+              0.108813,
+              0.106997,
+              0.107416,
+              0.106927,
+              0.107416,
+              0.108813,
+              0.106857,
+              0.107905,
+              0.108254,
+              0.107904,
+              0.107835,
+              0.107905,
+              0.109791,
+              0.107416,
+              0.107416
+            ],
+            "warm_rows_per_second": 4744914.508132153
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.873958320818782,
+            "character_perplexity": 6.514030055435655,
+            "next_character_accuracy": 0.5034503910443183,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.838061303750926e-05,
+            "mean_prediction_kl_nats": 1.8468145160849747e-05,
+            "prediction_kl_p99_nats": 0.0001224622658852388,
+            "maximum_prediction_kl_nats": 0.023867958705451445,
+            "top1_changed_fraction": 0.0013034810611869344,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.3648056983947754,
+            "maximum_per_target_cross_entropy_increase": 0.36011672019958496
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.724338088566081e-05,
+            "mean_prediction_kl_nats": 1.449889472352411e-05,
+            "prediction_kl_p99_nats": 0.00012051635214573005,
+            "maximum_prediction_kl_nats": 0.02279089290362372,
+            "top1_changed_fraction": 0.00046005213924244745,
+            "accuracy_change": 7.667535654032331e-05,
+            "maximum_absolute_logit_change": 0.3624382019042969,
+            "maximum_per_target_cross_entropy_increase": 0.35428285598754883
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2377065,
+              "unique_rows": 29807,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 84,
+              "compressed_blocks": 165,
+              "zlib_blocks": 165,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29807
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "c47dc06f1ba35107cb854b2515844653fe49cdcd479cc9316b7e836a0aa6a124",
+            "table_sha256": "54bb8be7412ec039fda0c3fd9b57779e0d9384cae1666424f3994f5dd9edcb3f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.234727076953277,
+          "representatives_sha256": "4e9835811d47ac40dae8f84d884a1e10754685c150251171c683590f8842ba5e",
+          "structurally_merged_rows": 13345,
+          "backend_artifact_bytes": 2378315,
+          "backend_with_key_registry_bytes": 3114422,
+          "backend_with_datrie_key_index_bytes": 2724475,
+          "full_model_serving_artifact_bytes": 3942420,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.970227681619455,
+            "mean_cosine": 0.999693591204922,
+            "p05_cosine": 0.9986577694002984,
+            "relative_l2_mean": 0.016032968614897978,
+            "relative_l2_p95": 0.05205299820698988,
+            "relative_l2_max": 0.24421754617070648,
+            "weighted_relative_l2_mean": 0.003849294114434825,
+            "weighted_relative_frobenius": 0.015056704117102472,
+            "weighted_mean_cosine": 0.9999478707056814,
+            "max_relative_norm_change": 0.011715558658246757
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.970287941034826,
+            "mean_cosine": 0.9996985992315968,
+            "p05_cosine": 0.9986450501833666,
+            "relative_l2_mean": 0.012810108164801652,
+            "relative_l2_p95": 0.05227298614602889,
+            "relative_l2_max": 0.24405115715268316,
+            "weighted_relative_l2_mean": 0.0021109493811355957,
+            "weighted_relative_frobenius": 0.014339566466190019,
+            "weighted_mean_cosine": 0.9999521151639343,
+            "max_relative_norm_change": 0.01009139470261335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.606409,
+            "warm_p50_ms": 0.1088125,
+            "warm_p95_ms": 0.1121204,
+            "warm_p99_ms": 0.13622881999999997,
+            "samples_ms": [
+              0.112584,
+              0.111187,
+              0.109301,
+              0.108813,
+              0.108324,
+              0.109651,
+              0.109861,
+              0.109791,
+              0.10979,
+              0.108813,
+              0.108883,
+              0.109302,
+              0.109302,
+              0.107905,
+              0.108464,
+              0.108324,
+              0.108394,
+              0.151346,
+              0.112096,
+              0.108813,
+              0.107835,
+              0.109301,
+              0.108324,
+              0.108324,
+              0.106438,
+              0.106509,
+              0.108324,
+              0.111676,
+              0.106997,
+              0.106439,
+              0.106927,
+              0.108813,
+              0.108324,
+              0.107905,
+              0.108883,
+              0.107905,
+              0.108812,
+              0.109302,
+              0.107905,
+              0.107905
+            ],
+            "warm_rows_per_second": 4705341.757610568
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8738035119523269,
+            "character_perplexity": 6.513021703879613,
+            "next_character_accuracy": 0.5036037417573992,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.0001931715560190487,
+            "mean_prediction_kl_nats": 4.1061383926831704e-05,
+            "prediction_kl_p99_nats": 0.00017237435872760937,
+            "maximum_prediction_kl_nats": 0.033299796541104196,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": 7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.4103102684020996,
+            "maximum_per_target_cross_entropy_increase": 0.37328028678894043
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.00013755617251682363,
+            "mean_prediction_kl_nats": 3.6899726929217145e-05,
+            "prediction_kl_p99_nats": 0.00015571677171428625,
+            "maximum_prediction_kl_nats": 0.03323540901279816,
+            "top1_changed_fraction": 0.0006900782088636713,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 0.4097323417663574,
+            "maximum_per_target_cross_entropy_increase": 0.3750145435333252
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2375941,
+              "unique_rows": 29792,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 87,
+              "compressed_blocks": 162,
+              "zlib_blocks": 162,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29792
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "1f17036d03459d64386d4310cb76367eeab48cda2adfef72dc6f36ff130db487",
+            "table_sha256": "05fff4682d17a7232c2308550ce20bd485b1097e49e3abbeb413dc0612e783b1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24294607690535486,
+          "representatives_sha256": "7e5a661f1aaae7116344383645ae9fbe45d1cb4371687e75f4f87c38c48000e3",
+          "structurally_merged_rows": 13360,
+          "backend_artifact_bytes": 2377191,
+          "backend_with_key_registry_bytes": 3113298,
+          "backend_with_datrie_key_index_bytes": 2723351,
+          "full_model_serving_artifact_bytes": 3941296,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9511035339527236,
+            "mean_cosine": 0.9996762788379485,
+            "p05_cosine": 0.9986487496298613,
+            "relative_l2_mean": 0.016155183183444766,
+            "relative_l2_p95": 0.05214904276097739,
+            "relative_l2_max": 0.3121951526683212,
+            "weighted_relative_l2_mean": 0.0038894665587964877,
+            "weighted_relative_frobenius": 0.016348827232659544,
+            "weighted_mean_cosine": 0.999942341395052,
+            "max_relative_norm_change": 0.011715558658246757
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9509326857499247,
+            "mean_cosine": 0.9996812663485738,
+            "p05_cosine": 0.9986380028876795,
+            "relative_l2_mean": 0.012934271859448962,
+            "relative_l2_p95": 0.05237140004079371,
+            "relative_l2_max": 0.31281956387251403,
+            "weighted_relative_l2_mean": 0.002152151021738678,
+            "weighted_relative_frobenius": 0.015697274645901753,
+            "weighted_mean_cosine": 0.9999465589607925,
+            "max_relative_norm_change": 0.01009139470261335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.699578,
+            "warm_p50_ms": 0.108813,
+            "warm_p95_ms": 0.1122069,
+            "warm_p99_ms": 0.12118309999999999,
+            "samples_ms": [
+              0.111257,
+              0.112165,
+              0.111677,
+              0.108813,
+              0.108882,
+              0.126413,
+              0.109232,
+              0.108813,
+              0.107905,
+              0.110768,
+              0.109791,
+              0.109232,
+              0.10979,
+              0.108813,
+              0.108323,
+              0.113003,
+              0.109721,
+              0.107905,
+              0.109791,
+              0.108882,
+              0.107835,
+              0.108813,
+              0.108254,
+              0.107835,
+              0.108813,
+              0.108393,
+              0.108324,
+              0.108324,
+              0.109791,
+              0.108813,
+              0.108324,
+              0.108324,
+              0.108394,
+              0.109721,
+              0.108813,
+              0.108813,
+              0.106438,
+              0.108394,
+              0.109791,
+              0.108393
+            ],
+            "warm_rows_per_second": 4705320.136380764
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8736482352032853,
+            "character_perplexity": 6.5120104615562395,
+            "next_character_accuracy": 0.5035270664008588,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -0.000348406257527736,
+            "mean_prediction_kl_nats": 7.473230500685238e-05,
+            "prediction_kl_p99_nats": 0.00022106994320018864,
+            "maximum_prediction_kl_nats": 0.16099732540412104,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.6786346435546875,
+            "maximum_per_target_cross_entropy_increase": 0.7059441208839417
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -0.000292799509131025,
+            "mean_prediction_kl_nats": 7.028179700099118e-05,
+            "prediction_kl_p99_nats": 0.00021394409080735188,
+            "maximum_prediction_kl_nats": 0.1600478362486274,
+            "top1_changed_fraction": 0.0007667535654040791,
+            "accuracy_change": 0.00015335071308075765,
+            "maximum_absolute_logit_change": 0.6781201362609863,
+            "maximum_per_target_cross_entropy_increase": 0.7044176459312439
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2373751,
+              "unique_rows": 29760,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 248,
+              "max_block_bytes": 8192,
+              "raw_blocks": 80,
+              "compressed_blocks": 168,
+              "zlib_blocks": 168,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29760
+            },
+            "source_float32_sha256": "b86fa28c9c69888ff34b5f2bbec2e1f5ac90bb3b2115b094e67e2355c0cac2be",
+            "decoded_float32_sha256": "ba3b4a903e6ec9b7a676a4ed226e6f534613730d0e3f36a3486e3382f79b5198",
+            "table_sha256": "4badf2ac68819c3bd931f5d6618717b33d8ed7f9627ac05388755e7d48413d2f",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.23762730904854834,
+          "representatives_sha256": "9159b307f2f34639da3d0241266cb65d89d8e977e6831c6a368ac5d604e21d95",
+          "structurally_merged_rows": 13392,
+          "backend_artifact_bytes": 2375001,
+          "backend_with_key_registry_bytes": 3111108,
+          "backend_with_datrie_key_index_bytes": 2721161,
+          "full_model_serving_artifact_bytes": 3939106,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9001684363688671,
+            "mean_cosine": 0.999592323460612,
+            "p05_cosine": 0.9986353610108466,
+            "relative_l2_mean": 0.01657388790925372,
+            "relative_l2_p95": 0.05242172007517553,
+            "relative_l2_max": 0.4465258112640598,
+            "weighted_relative_l2_mean": 0.004170147652851006,
+            "weighted_relative_frobenius": 0.025142984167262527,
+            "weighted_mean_cosine": 0.9998870304493592,
+            "max_relative_norm_change": 0.011715558658246757
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9000432033719185,
+            "mean_cosine": 0.9995973008579918,
+            "p05_cosine": 0.99861973731563,
+            "relative_l2_mean": 0.013356567722426008,
+            "relative_l2_p95": 0.05272507146664552,
+            "relative_l2_max": 0.4471108671817365,
+            "weighted_relative_l2_mean": 0.00243593633909215,
+            "weighted_relative_frobenius": 0.02472316193697585,
+            "weighted_mean_cosine": 0.999891206520516,
+            "max_relative_norm_change": 0.01009139470261335
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.823127,
+            "warm_p50_ms": 0.108324,
+            "warm_p95_ms": 0.11325474999999999,
+            "warm_p99_ms": 0.12117177999999999,
+            "samples_ms": [
+              0.111118,
+              0.109232,
+              0.113143,
+              0.108324,
+              0.109721,
+              0.108813,
+              0.108813,
+              0.108813,
+              0.107905,
+              0.108324,
+              0.108883,
+              0.109232,
+              0.108393,
+              0.108324,
+              0.108813,
+              0.107835,
+              0.108324,
+              0.109302,
+              0.111117,
+              0.108324,
+              0.115378,
+              0.106927,
+              0.106927,
+              0.106997,
+              0.107905,
+              0.106997,
+              0.108743,
+              0.106927,
+              0.108394,
+              0.111118,
+              0.107835,
+              0.124876,
+              0.107904,
+              0.108324,
+              0.107905,
+              0.108324,
+              0.108324,
+              0.108324,
+              0.108324,
+              0.108813
+            ],
+            "warm_rows_per_second": 4726561.057568037
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8742551923215474,
+            "character_perplexity": 6.515964172405172,
+            "next_character_accuracy": 0.50375709247048,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0002585235646316773,
+            "mean_prediction_kl_nats": 0.0003787976314879992,
+            "prediction_kl_p99_nats": 0.0019297452549639146,
+            "maximum_prediction_kl_nats": 0.4056340534152349,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 0.00023002606962119199,
+            "maximum_absolute_logit_change": 1.7124749422073364,
+            "maximum_per_target_cross_entropy_increase": 1.2178491353988647
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0003141640741849018,
+            "mean_prediction_kl_nats": 0.0003752861419167501,
+            "prediction_kl_p99_nats": 0.001977486937159491,
+            "maximum_prediction_kl_nats": 0.406279360229042,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": 0.00038337678270194964,
+            "maximum_absolute_logit_change": 1.7008367776870728,
+            "maximum_per_target_cross_entropy_increase": 1.2212761640548706
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.873996702168374,
+          "character_perplexity": 6.514280077498528,
+          "next_character_accuracy": 0.5035270664008588,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7467822847944068,
+          "character_perplexity": 5.736115762235418,
+          "next_character_accuracy": 0.5234991949704823,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.95",
+          "backend_with_key_registry_bytes": 8192404,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7468335463514388,
+            "character_perplexity": 5.736409811997366,
+            "next_character_accuracy": 0.5232691865368397,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 5.126287092804774e-05,
+            "mean_prediction_kl_nats": 4.523398162602008e-05,
+            "prediction_kl_p99_nats": 0.0002614981201286399,
+            "maximum_prediction_kl_nats": 0.031281574788080815,
+            "top1_changed_fraction": 0.0018400674691405351,
+            "accuracy_change": -0.00023000843364251455,
+            "maximum_absolute_logit_change": 0.6498794555664062,
+            "maximum_per_target_cross_entropy_increase": 0.5136287212371826
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00014062225521751923,
+              0.0002640022597950617
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.95",
+          "backend_with_key_registry_bytes": 4609709,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.746831640034469,
+            "character_perplexity": 5.7363988765924185,
+            "next_character_accuracy": 0.5232691865368397,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 4.93564580521361e-05,
+            "mean_prediction_kl_nats": 4.522092181157221e-05,
+            "prediction_kl_p99_nats": 0.000260726444150113,
+            "maximum_prediction_kl_nats": 0.03128432153710157,
+            "top1_changed_fraction": 0.0018400674691405351,
+            "accuracy_change": -0.00023000843364251455,
+            "maximum_absolute_logit_change": 0.6495251655578613,
+            "maximum_per_target_cross_entropy_increase": 0.5136415958404541
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00014176603083662905,
+              0.00026122043476795856
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.95",
+          "backend_with_key_registry_bytes": 3113298,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7468335912146888,
+            "character_perplexity": 5.7364100693513596,
+            "next_character_accuracy": 0.5231925170589589,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 5.130773647893945e-05,
+            "mean_prediction_kl_nats": 4.9148167713019224e-05,
+            "prediction_kl_p99_nats": 0.00026751634360011476,
+            "maximum_prediction_kl_nats": 0.030909915141433902,
+            "top1_changed_fraction": 0.0026067622479490913,
+            "accuracy_change": -0.00030667791152338975,
+            "maximum_absolute_logit_change": 0.652705192565918,
+            "maximum_per_target_cross_entropy_increase": 0.5167644023895264
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.00014600205117785967,
+              0.0002798015539844717
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7467813805442989,
+            "character_perplexity": 5.736110575354466,
+            "next_character_accuracy": 0.5234991949704823,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -9.042496992371759e-07,
+            "mean_prediction_kl_nats": 3.983294762355042e-09,
+            "prediction_kl_p99_nats": 2.8867819098809675e-08,
+            "maximum_prediction_kl_nats": 7.317560600678412e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001468658447265625,
+            "maximum_per_target_cross_entropy_increase": 0.00078582763671875
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7467908037670918,
+            "character_perplexity": 5.736164628257058,
+            "next_character_accuracy": 0.5234225254926014,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 8.519008971568044e-06,
+            "mean_prediction_kl_nats": 3.491065829910206e-06,
+            "prediction_kl_p99_nats": 2.725155572071768e-05,
+            "maximum_prediction_kl_nats": 0.0001554347123477164,
+            "top1_changed_fraction": 0.0009967032124511231,
+            "accuracy_change": -7.666947788087519e-05,
+            "maximum_absolute_logit_change": 0.03646731376647949,
+            "maximum_per_target_cross_entropy_increase": 0.018882274627685547
+          }
+        }
+      },
+      "checkpoint_sha256": "464242bc5b4367053b82ea7fa20f47536b2311fd0a3f4c4aaf6c0d4ed4a9e0c7",
+      "registry_sha256": "abab407b9c927abc758d3d85a11cec2c2535254fe5af55b6cce10b650a992d4d"
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "rows": 43152,
+      "dim": 64,
+      "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+      "source_float32_bytes": 11046912,
+      "key_registry_bytes": 736107,
+      "unchanged_backbone_artifact_bytes": 827998,
+      "alternative_datrie_key_index_bytes": 346160,
+      "query_rows": 512,
+      "query_ids_sha256": "43ca78408803e060726877734dd5761b4e85ad9be7de5a6b6d8601f32db85068",
+      "frequency_trace_sha256": "7ba41132ac5296b1ee890e8c97c4f892398df8fb97e4bbb475dab44b5c5af0cc",
+      "variants": [
+        {
+          "name": "fp32-raw",
+          "encoding": "fp32",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 256,
+            "storage": {
+              "artifact_bytes": 11046912,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "table_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.0591190280392766,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 11047717,
+          "backend_with_key_registry_bytes": 11783824,
+          "backend_with_datrie_key_index_bytes": 11393877,
+          "full_model_serving_artifact_bytes": 12611822,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.239905,
+            "warm_p50_ms": 0.046934,
+            "warm_p95_ms": 0.05026475,
+            "warm_p99_ms": 0.07390759999999999,
+            "samples_ms": [
+              0.050146,
+              0.052521,
+              0.046933,
+              0.047283,
+              0.046864,
+              0.047283,
+              0.046863,
+              0.047771,
+              0.046863,
+              0.046934,
+              0.046864,
+              0.046374,
+              0.046933,
+              0.046934,
+              0.047353,
+              0.046933,
+              0.047352,
+              0.046444,
+              0.049168,
+              0.048679,
+              0.048261,
+              0.046864,
+              0.047283,
+              0.047282,
+              0.046374,
+              0.087581,
+              0.049657,
+              0.046305,
+              0.047352,
+              0.046375,
+              0.047283,
+              0.046863,
+              0.046863,
+              0.047771,
+              0.046305,
+              0.046864,
+              0.047353,
+              0.046863,
+              0.046793,
+              0.047352
+            ],
+            "warm_rows_per_second": 10908935.952614311
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746469158554788,
+            "character_perplexity": 6.518517128911684,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-identity",
+          "encoding": "fp32",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10650963,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "table_sha256": "a545b67631916f8cdacff843e36ed4eeeeafc4c690379bf1e67ffe8dd7e39ce7",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9225178682245314,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10652175,
+          "backend_with_key_registry_bytes": 11388282,
+          "backend_with_datrie_key_index_bytes": 10998335,
+          "full_model_serving_artifact_bytes": 12216280,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.246122,
+            "warm_p50_ms": 0.055314,
+            "warm_p95_ms": 0.05684735,
+            "warm_p99_ms": 0.05934325,
+            "samples_ms": [
+              0.058108,
+              0.055384,
+              0.055803,
+              0.055873,
+              0.055873,
+              0.055873,
+              0.055314,
+              0.055734,
+              0.055804,
+              0.055803,
+              0.056222,
+              0.053917,
+              0.060133,
+              0.055384,
+              0.055314,
+              0.055384,
+              0.055873,
+              0.054896,
+              0.054896,
+              0.053988,
+              0.055385,
+              0.054477,
+              0.054477,
+              0.053848,
+              0.053848,
+              0.053987,
+              0.054057,
+              0.054476,
+              0.053428,
+              0.055314,
+              0.056781,
+              0.056362,
+              0.056362,
+              0.055873,
+              0.053987,
+              0.053917,
+              0.053429,
+              0.054407,
+              0.053499,
+              0.053568
+            ],
+            "warm_rows_per_second": 9256246.158296272
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746469158554788,
+            "character_perplexity": 6.518517128911684,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-layout",
+          "encoding": "fp32",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10650963,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "table_sha256": "a545b67631916f8cdacff843e36ed4eeeeafc4c690379bf1e67ffe8dd7e39ce7",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 1.0841774109285325,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10652174,
+          "backend_with_key_registry_bytes": 11388281,
+          "backend_with_datrie_key_index_bytes": 10998334,
+          "full_model_serving_artifact_bytes": 12216279,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.219652,
+            "warm_p50_ms": 0.055245,
+            "warm_p95_ms": 0.05580745,
+            "warm_p99_ms": 0.05698076,
+            "samples_ms": [
+              0.057689,
+              0.055803,
+              0.055314,
+              0.055245,
+              0.055315,
+              0.055385,
+              0.055314,
+              0.053359,
+              0.055385,
+              0.055803,
+              0.054825,
+              0.054895,
+              0.053987,
+              0.054476,
+              0.054895,
+              0.055384,
+              0.055873,
+              0.053988,
+              0.055454,
+              0.053499,
+              0.054826,
+              0.053918,
+              0.055384,
+              0.055245,
+              0.055315,
+              0.055804,
+              0.055733,
+              0.055314,
+              0.055384,
+              0.055314,
+              0.054826,
+              0.054336,
+              0.054476,
+              0.053429,
+              0.054895,
+              0.055454,
+              0.053987,
+              0.053987,
+              0.053917,
+              0.054336
+            ],
+            "warm_rows_per_second": 9267807.041361209
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746469158554788,
+            "character_perplexity": 6.518517128911684,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-dedup",
+          "encoding": "fp32",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 10650963,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 1349,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 1349,
+              "zlib_blocks": 1349,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "table_sha256": "a545b67631916f8cdacff843e36ed4eeeeafc4c690379bf1e67ffe8dd7e39ce7",
+            "source_bytes_preserved": true,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.9682164608966559,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 10652174,
+          "backend_with_key_registry_bytes": 11388281,
+          "backend_with_datrie_key_index_bytes": 10998334,
+          "full_model_serving_artifact_bytes": 12216279,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 6.187035,
+            "warm_p50_ms": 0.0548255,
+            "warm_p95_ms": 0.0563409,
+            "warm_p99_ms": 0.06302108,
+            "samples_ms": [
+              0.05727,
+              0.056292,
+              0.054406,
+              0.055803,
+              0.055384,
+              0.054965,
+              0.054896,
+              0.054896,
+              0.056292,
+              0.055384,
+              0.055873,
+              0.066698,
+              0.055873,
+              0.054896,
+              0.055385,
+              0.054477,
+              0.054826,
+              0.055803,
+              0.055384,
+              0.054895,
+              0.054476,
+              0.054406,
+              0.054476,
+              0.054406,
+              0.054406,
+              0.054895,
+              0.053847,
+              0.054825,
+              0.054406,
+              0.054406,
+              0.054336,
+              0.054895,
+              0.053498,
+              0.054406,
+              0.054406,
+              0.054825,
+              0.054825,
+              0.054825,
+              0.054337,
+              0.053987
+            ],
+            "warm_rows_per_second": 9338720.121111527
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746469158554788,
+            "character_perplexity": 6.518517128911684,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp32-joint-0.99",
+          "encoding": "fp32",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7468265,
+              "unique_rows": 29808,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29808
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "c65447b4d409ccbfedd7c270e0e49fbbf695ab4a358cadd55e85d13246041d80",
+            "table_sha256": "d79fe9c030582a1ba7f7dfabb5207324fab6d87659bdb3230479ed8523553c9a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6926265370566398,
+          "representatives_sha256": "a838bcae111e98748e3dce6abedefe77b5bc3acf70e32f76d5b98e57f3752c6b",
+          "structurally_merged_rows": 13344,
+          "backend_artifact_bytes": 7469472,
+          "backend_with_key_registry_bytes": 8205579,
+          "backend_with_datrie_key_index_bytes": 7815632,
+          "full_model_serving_artifact_bytes": 9033577,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9902459060645252,
+            "mean_cosine": 0.9997189716982479,
+            "p05_cosine": 0.9986685109158533,
+            "relative_l2_mean": 0.012565436873781678,
+            "relative_l2_p95": 0.05185636339077146,
+            "relative_l2_max": 0.1400040347803519,
+            "weighted_relative_l2_mean": 0.0020033097036198408,
+            "weighted_relative_frobenius": 0.013052669069275194,
+            "weighted_mean_cosine": 0.999959890607113,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9902459060645252,
+            "mean_cosine": 0.9997189716982479,
+            "p05_cosine": 0.9986685109158533,
+            "relative_l2_mean": 0.012565436873781678,
+            "relative_l2_p95": 0.05185636339077146,
+            "relative_l2_max": 0.1400040347803519,
+            "weighted_relative_l2_mean": 0.0020033097036198408,
+            "weighted_relative_frobenius": 0.013052669069275194,
+            "weighted_mean_cosine": 0.999959890607113,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.532552,
+            "warm_p50_ms": 0.054337,
+            "warm_p95_ms": 0.05822685,
+            "warm_p99_ms": 0.06524767999999999,
+            "samples_ms": [
+              0.059155,
+              0.056711,
+              0.055803,
+              0.058178,
+              0.055314,
+              0.056781,
+              0.056292,
+              0.054337,
+              0.053988,
+              0.069143,
+              0.055873,
+              0.053987,
+              0.054895,
+              0.054336,
+              0.054895,
+              0.056292,
+              0.053358,
+              0.053987,
+              0.053987,
+              0.054057,
+              0.053988,
+              0.053918,
+              0.053918,
+              0.054337,
+              0.053987,
+              0.054057,
+              0.053987,
+              0.053917,
+              0.053917,
+              0.053917,
+              0.053918,
+              0.053499,
+              0.053918,
+              0.054476,
+              0.054895,
+              0.054337,
+              0.054337,
+              0.054337,
+              0.054407,
+              0.054896
+            ],
+            "warm_rows_per_second": 9422676.997257853
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874576445459657,
+            "character_perplexity": 6.518057782614786,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -7.046791284201621e-05,
+            "mean_prediction_kl_nats": 9.676395478281967e-06,
+            "prediction_kl_p99_nats": 0.00013294663297309573,
+            "maximum_prediction_kl_nats": 0.0047893837222148065,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.3017038106918335,
+            "maximum_per_target_cross_entropy_increase": 0.1393296718597412
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -7.046791284201621e-05,
+            "mean_prediction_kl_nats": 9.676395478281967e-06,
+            "prediction_kl_p99_nats": 0.00013294663297309573,
+            "maximum_prediction_kl_nats": 0.0047893837222148065,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.3017038106918335,
+            "maximum_per_target_cross_entropy_increase": 0.1393296718597412
+          }
+        },
+        {
+          "name": "fp32-joint-0.98",
+          "encoding": "fp32",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7466244,
+              "unique_rows": 29799,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 932,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 932,
+              "zlib_blocks": 932,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29799
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "b4d54e46e87aeb4711779bcdd2b7d067c8bdf1fa2f4a50188867c57189041436",
+            "table_sha256": "e3868b17869f77825297b2756b988244fbd79ac04d525fb90e8612fa6b5f4944",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6810663971118629,
+          "representatives_sha256": "46bc18844cb26a93245354eb5174585bd3eb9b80d4ba7afbbe5f1ce113b4053f",
+          "structurally_merged_rows": 13353,
+          "backend_artifact_bytes": 7467451,
+          "backend_with_key_registry_bytes": 8203558,
+          "backend_with_datrie_key_index_bytes": 7813611,
+          "full_model_serving_artifact_bytes": 9031556,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9812375062946396,
+            "mean_cosine": 0.9997153374071882,
+            "p05_cosine": 0.9986655857379028,
+            "relative_l2_mean": 0.01260639967491202,
+            "relative_l2_p95": 0.051916390301729676,
+            "relative_l2_max": 0.1932779931725137,
+            "weighted_relative_l2_mean": 0.0020400091222027047,
+            "weighted_relative_frobenius": 0.013916796380774301,
+            "weighted_mean_cosine": 0.9999569248762874,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9812375062946396,
+            "mean_cosine": 0.9997153374071882,
+            "p05_cosine": 0.9986655857379028,
+            "relative_l2_mean": 0.01260639967491202,
+            "relative_l2_p95": 0.051916390301729676,
+            "relative_l2_max": 0.1932779931725137,
+            "weighted_relative_l2_mean": 0.0020400091222027047,
+            "weighted_relative_frobenius": 0.013916796380774301,
+            "weighted_mean_cosine": 0.9999569248762874,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.538349,
+            "warm_p50_ms": 0.055385,
+            "warm_p95_ms": 0.05769245,
+            "warm_p99_ms": 0.0580142,
+            "samples_ms": [
+              0.058178,
+              0.057689,
+              0.057758,
+              0.05727,
+              0.055803,
+              0.056293,
+              0.055873,
+              0.054965,
+              0.054895,
+              0.055873,
+              0.055384,
+              0.055385,
+              0.055454,
+              0.055384,
+              0.055384,
+              0.054895,
+              0.056292,
+              0.055384,
+              0.055454,
+              0.055873,
+              0.055803,
+              0.055384,
+              0.054476,
+              0.054476,
+              0.054895,
+              0.055873,
+              0.055384,
+              0.055384,
+              0.054476,
+              0.053917,
+              0.055734,
+              0.055385,
+              0.055803,
+              0.055803,
+              0.053429,
+              0.056292,
+              0.054825,
+              0.055314,
+              0.054895,
+              0.055734
+            ],
+            "warm_rows_per_second": 9244380.247359393
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874600747195864,
+            "character_perplexity": 6.518216184660315,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.6167593858877154e-05,
+            "mean_prediction_kl_nats": 1.0040152880568824e-05,
+            "prediction_kl_p99_nats": 0.00013764166758583975,
+            "maximum_prediction_kl_nats": 0.0047893837222148065,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.4481656551361084,
+            "maximum_per_target_cross_entropy_increase": 0.25843191146850586
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.6167593858877154e-05,
+            "mean_prediction_kl_nats": 1.0040152880568824e-05,
+            "prediction_kl_p99_nats": 0.00013764166758583975,
+            "maximum_prediction_kl_nats": 0.0047893837222148065,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.4481656551361084,
+            "maximum_per_target_cross_entropy_increase": 0.25843191146850586
+          }
+        },
+        {
+          "name": "fp32-joint-0.97",
+          "encoding": "fp32",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7463655,
+              "unique_rows": 29788,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 931,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 931,
+              "zlib_blocks": 931,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29788
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "5776d13fa5d3348bc52ab527c768fac0cac741869b88dda7573cf47b782d1cd1",
+            "table_sha256": "e20eabc67f867ce0e0e2bde225055766d5b283149197712e6b8a4acc85e7a90e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6838157009333372,
+          "representatives_sha256": "8c586ce381d5e20d375f5b61a8eadc7698d7d40f09ad5e057d56c55e8c045ce5",
+          "structurally_merged_rows": 13364,
+          "backend_artifact_bytes": 7464862,
+          "backend_with_key_registry_bytes": 8200969,
+          "backend_with_datrie_key_index_bytes": 7811022,
+          "full_model_serving_artifact_bytes": 9028967,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9703576562286211,
+            "mean_cosine": 0.9997070682357191,
+            "p05_cosine": 0.9986618868574548,
+            "relative_l2_mean": 0.01267762616506722,
+            "relative_l2_p95": 0.05197669763443726,
+            "relative_l2_max": 0.2449152666071064,
+            "weighted_relative_l2_mean": 0.002082663876929235,
+            "weighted_relative_frobenius": 0.01511647551684654,
+            "weighted_mean_cosine": 0.9999520616546923,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9703576562286211,
+            "mean_cosine": 0.9997070682357191,
+            "p05_cosine": 0.9986618868574548,
+            "relative_l2_mean": 0.01267762616506722,
+            "relative_l2_p95": 0.05197669763443726,
+            "relative_l2_max": 0.2449152666071064,
+            "weighted_relative_l2_mean": 0.002082663876929235,
+            "weighted_relative_frobenius": 0.01511647551684654,
+            "weighted_mean_cosine": 0.9999520616546923,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.497213,
+            "warm_p50_ms": 0.054965,
+            "warm_p95_ms": 0.056292,
+            "warm_p99_ms": 0.05744185,
+            "samples_ms": [
+              0.058177,
+              0.055873,
+              0.055384,
+              0.055803,
+              0.055315,
+              0.055315,
+              0.055804,
+              0.056222,
+              0.055314,
+              0.056292,
+              0.055315,
+              0.055734,
+              0.054825,
+              0.055314,
+              0.054755,
+              0.053917,
+              0.055314,
+              0.054825,
+              0.053009,
+              0.054406,
+              0.054476,
+              0.054965,
+              0.053917,
+              0.054895,
+              0.056292,
+              0.054825,
+              0.054476,
+              0.053359,
+              0.054825,
+              0.053498,
+              0.054057,
+              0.055384,
+              0.055873,
+              0.054895,
+              0.054965,
+              0.055384,
+              0.054965,
+              0.054895,
+              0.054407,
+              0.054826
+            ],
+            "warm_rows_per_second": 9315018.648230692
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8745769143085478,
+            "character_perplexity": 6.518060838599665,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -6.999909687999551e-05,
+            "mean_prediction_kl_nats": 2.5804656921662418e-05,
+            "prediction_kl_p99_nats": 0.00016574862158967506,
+            "maximum_prediction_kl_nats": 0.02597693295804385,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.45133912563323975,
+            "maximum_per_target_cross_entropy_increase": 0.47270774841308594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -6.999909687999551e-05,
+            "mean_prediction_kl_nats": 2.5804656921662418e-05,
+            "prediction_kl_p99_nats": 0.00016574862158967506,
+            "maximum_prediction_kl_nats": 0.02597693295804385,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.45133912563323975,
+            "maximum_per_target_cross_entropy_increase": 0.47270774841308594
+          }
+        },
+        {
+          "name": "fp32-joint-0.95",
+          "encoding": "fp32",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7456459,
+              "unique_rows": 29759,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 930,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 930,
+              "zlib_blocks": 930,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29759
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "9cb75af0bd848f19ad7daafbb360313a37dbf95c8fb63ae038e7987ab7253c9c",
+            "table_sha256": "eda8529fa1e43701cd5e9eaed0248811c40c128008ffa16a21a0b1f1d098f885",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6939489128999412,
+          "representatives_sha256": "a9a02de62e856fddf6769221690688799c98284c2059352332170a432fb31fce",
+          "structurally_merged_rows": 13393,
+          "backend_artifact_bytes": 7457666,
+          "backend_with_key_registry_bytes": 8193773,
+          "backend_with_datrie_key_index_bytes": 7803826,
+          "full_model_serving_artifact_bytes": 9021771,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9500023397388492,
+            "mean_cosine": 0.9996656139836287,
+            "p05_cosine": 0.9986486740297048,
+            "relative_l2_mean": 0.012960582104716335,
+            "relative_l2_p95": 0.052241887765272006,
+            "relative_l2_max": 0.31645540845328646,
+            "weighted_relative_l2_mean": 0.002131533865437752,
+            "weighted_relative_frobenius": 0.016184835758130237,
+            "weighted_mean_cosine": 0.9999450578328678,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9500023397388492,
+            "mean_cosine": 0.9996656139836287,
+            "p05_cosine": 0.9986486740297048,
+            "relative_l2_mean": 0.012960582104716335,
+            "relative_l2_p95": 0.052241887765272006,
+            "relative_l2_max": 0.31645540845328646,
+            "weighted_relative_l2_mean": 0.002131533865437752,
+            "weighted_relative_frobenius": 0.016184835758130237,
+            "weighted_mean_cosine": 0.9999450578328678,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.667905,
+            "warm_p50_ms": 0.055384,
+            "warm_p95_ms": 0.056407399999999996,
+            "warm_p99_ms": 0.05752559,
+            "samples_ms": [
+              0.057689,
+              0.056292,
+              0.055384,
+              0.055733,
+              0.055314,
+              0.055314,
+              0.055733,
+              0.056223,
+              0.056292,
+              0.055384,
+              0.056292,
+              0.055873,
+              0.055385,
+              0.055873,
+              0.05727,
+              0.056292,
+              0.055873,
+              0.056362,
+              0.054825,
+              0.055314,
+              0.055314,
+              0.055803,
+              0.055314,
+              0.055314,
+              0.054896,
+              0.055315,
+              0.055384,
+              0.055873,
+              0.055733,
+              0.054825,
+              0.055314,
+              0.055734,
+              0.055804,
+              0.055314,
+              0.055314,
+              0.055244,
+              0.055314,
+              0.055314,
+              0.055245,
+              0.055315
+            ],
+            "warm_rows_per_second": 9244547.161635129
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746374539850317,
+            "character_perplexity": 6.518455451838894,
+            "next_character_accuracy": 0.49279251648520167,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -9.46182568385008e-06,
+            "mean_prediction_kl_nats": 4.180147943176077e-05,
+            "prediction_kl_p99_nats": 0.00018860474570523585,
+            "maximum_prediction_kl_nats": 0.03543225249138276,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": -0.00015335071308081316,
+            "maximum_absolute_logit_change": 1.071291446685791,
+            "maximum_per_target_cross_entropy_increase": 0.9157590866088867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -9.46182568385008e-06,
+            "mean_prediction_kl_nats": 4.180147943176077e-05,
+            "prediction_kl_p99_nats": 0.00018860474570523585,
+            "maximum_prediction_kl_nats": 0.03543225249138276,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": -0.00015335071308081316,
+            "maximum_absolute_logit_change": 1.071291446685791,
+            "maximum_per_target_cross_entropy_increase": 0.9157590866088867
+          }
+        },
+        {
+          "name": "fp32-joint-0.9",
+          "encoding": "fp32",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp32",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 256,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 11046912,
+              "artifact_bytes": 7448881,
+              "unique_rows": 29727,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 256,
+              "block_rows": 32,
+              "blocks": 929,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 929,
+              "zlib_blocks": 929,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29727
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "a35551fb6a4063ba410cb6107ef0242d15045847d7dae499f148ea97ee1f44e8",
+            "table_sha256": "db10121b72a08f8330d37d84a6fcb79373ebd4e2aead34b39941ecc4e8a6821d",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp32",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6733195239212364,
+          "representatives_sha256": "e7cd9c89499c63c4f9f30e50a1d393ff3d1fe880471b0e1f4594656192965952",
+          "structurally_merged_rows": 13425,
+          "backend_artifact_bytes": 7450088,
+          "backend_with_key_registry_bytes": 8186195,
+          "backend_with_datrie_key_index_bytes": 7796248,
+          "full_model_serving_artifact_bytes": 9014193,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9001956866909555,
+            "mean_cosine": 0.999587579106024,
+            "p05_cosine": 0.9986360287973155,
+            "relative_l2_mean": 0.013349663575628954,
+            "relative_l2_p95": 0.0524339650002821,
+            "relative_l2_max": 0.44829107892167214,
+            "weighted_relative_l2_mean": 0.0024165394792690195,
+            "weighted_relative_frobenius": 0.029884694087567335,
+            "weighted_mean_cosine": 0.9998840290166183,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9001956866909555,
+            "mean_cosine": 0.999587579106024,
+            "p05_cosine": 0.9986360287973155,
+            "relative_l2_mean": 0.013349663575628954,
+            "relative_l2_p95": 0.0524339650002821,
+            "relative_l2_max": 0.44829107892167214,
+            "weighted_relative_l2_mean": 0.0024165394792690195,
+            "weighted_relative_frobenius": 0.029884694087567335,
+            "weighted_mean_cosine": 0.9998840290166183,
+            "max_relative_norm_change": 0.010087672046877508
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.82407,
+            "warm_p50_ms": 0.05514,
+            "warm_p95_ms": 0.057737899999999995,
+            "warm_p99_ms": 0.06701729,
+            "samples_ms": [
+              0.058667,
+              0.072356,
+              0.057689,
+              0.055803,
+              0.056781,
+              0.055873,
+              0.054896,
+              0.055873,
+              0.054406,
+              0.055384,
+              0.054965,
+              0.054477,
+              0.055454,
+              0.054966,
+              0.054477,
+              0.053918,
+              0.055315,
+              0.055315,
+              0.055314,
+              0.055314,
+              0.054337,
+              0.056222,
+              0.054336,
+              0.054406,
+              0.055314,
+              0.055384,
+              0.053987,
+              0.055803,
+              0.056781,
+              0.053918,
+              0.054896,
+              0.055385,
+              0.054407,
+              0.054476,
+              0.054406,
+              0.053498,
+              0.054965,
+              0.055384,
+              0.054965,
+              0.054965
+            ],
+            "warm_rows_per_second": 9285455.204932898
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874662206129923,
+            "character_perplexity": 6.518616799589548,
+            "next_character_accuracy": 0.49263916577212086,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.529039134093668e-05,
+            "mean_prediction_kl_nats": 9.758053428754134e-05,
+            "prediction_kl_p99_nats": 0.00036003335280749833,
+            "maximum_prediction_kl_nats": 0.12535552186813684,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -0.0003067014261616263,
+            "maximum_absolute_logit_change": 1.5011210441589355,
+            "maximum_per_target_cross_entropy_increase": 0.9157590866088867
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.529039134093668e-05,
+            "mean_prediction_kl_nats": 9.758053428754134e-05,
+            "prediction_kl_p99_nats": 0.00036003335280749833,
+            "maximum_prediction_kl_nats": 0.12535552186813684,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -0.0003067014261616263,
+            "maximum_absolute_logit_change": 1.5011210441589355,
+            "maximum_per_target_cross_entropy_increase": 0.9157590866088867
+          }
+        },
+        {
+          "name": "fp16-raw",
+          "encoding": "fp16",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 128,
+            "storage": {
+              "artifact_bytes": 5523456,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "bdea909d0738ce1a9112cfdf55e058286ffdf48616c95623b85c5865be33ab4e",
+            "table_sha256": "0676720f8d94a19e6237b1d04171a8f31c1f922cb1452938976a65b4f39f5ef7",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.06894284300506115,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5524261,
+          "backend_with_key_registry_bytes": 6260368,
+          "backend_with_datrie_key_index_bytes": 5870421,
+          "full_model_serving_artifact_bytes": 7088366,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999513463311,
+            "mean_cosine": 0.9999999792195698,
+            "p05_cosine": 0.9999999716268251,
+            "relative_l2_mean": 0.00020639671283615942,
+            "relative_l2_p95": 0.00024186731774094268,
+            "relative_l2_max": 0.00031522546967662694,
+            "weighted_relative_l2_mean": 7.847420784280686e-05,
+            "weighted_relative_frobenius": 0.00020874166338934465,
+            "weighted_mean_cosine": 0.9999999921182615,
+            "max_relative_norm_change": 0.0001740708570888487
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.313657,
+            "warm_p50_ms": 0.139124,
+            "warm_p95_ms": 0.14103795,
+            "warm_p99_ms": 0.16517111999999998,
+            "samples_ms": [
+              0.141569,
+              0.139612,
+              0.139054,
+              0.138635,
+              0.138146,
+              0.138565,
+              0.139054,
+              0.138565,
+              0.138566,
+              0.139124,
+              0.139613,
+              0.140032,
+              0.180261,
+              0.14101,
+              0.139612,
+              0.138216,
+              0.140032,
+              0.138147,
+              0.139124,
+              0.138565,
+              0.138565,
+              0.138566,
+              0.140102,
+              0.139124,
+              0.139543,
+              0.139124,
+              0.140102,
+              0.138146,
+              0.139124,
+              0.138635,
+              0.139124,
+              0.139613,
+              0.139543,
+              0.139543,
+              0.139543,
+              0.138705,
+              0.140102,
+              0.139613,
+              0.138147,
+              0.139543
+            ],
+            "warm_rows_per_second": 3680170.207872114
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746435529593024,
+            "character_perplexity": 6.518495207852214,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.362890522061065e-06,
+            "mean_prediction_kl_nats": 4.166460967471791e-09,
+            "prediction_kl_p99_nats": 2.713723610475145e-08,
+            "maximum_prediction_kl_nats": 9.861947594446357e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0012116432189941406,
+            "maximum_per_target_cross_entropy_increase": 0.00064849853515625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-identity",
+          "encoding": "fp16",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5451718,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "bdea909d0738ce1a9112cfdf55e058286ffdf48616c95623b85c5865be33ab4e",
+            "table_sha256": "35e05ce93fa67f0c19d85448fa6f58f92850761c9ce2bb07cc778719d17ded8e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5560433219652623,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5452926,
+          "backend_with_key_registry_bytes": 6189033,
+          "backend_with_datrie_key_index_bytes": 5799086,
+          "full_model_serving_artifact_bytes": 7017031,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999513463311,
+            "mean_cosine": 0.9999999792195698,
+            "p05_cosine": 0.9999999716268251,
+            "relative_l2_mean": 0.00020639671283615942,
+            "relative_l2_p95": 0.00024186731774094268,
+            "relative_l2_max": 0.00031522546967662694,
+            "weighted_relative_l2_mean": 7.847420784280686e-05,
+            "weighted_relative_frobenius": 0.00020874166338934465,
+            "weighted_mean_cosine": 0.9999999921182615,
+            "max_relative_norm_change": 0.0001740708570888487
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.896426,
+            "warm_p50_ms": 0.1469115,
+            "warm_p95_ms": 0.15310974999999993,
+            "warm_p99_ms": 0.18639561999999998,
+            "samples_ms": [
+              0.193042,
+              0.151905,
+              0.147574,
+              0.147156,
+              0.147645,
+              0.147156,
+              0.148972,
+              0.146597,
+              0.147086,
+              0.147645,
+              0.148064,
+              0.146178,
+              0.147645,
+              0.14569,
+              0.147156,
+              0.146178,
+              0.146178,
+              0.147994,
+              0.146178,
+              0.146178,
+              0.146667,
+              0.14527,
+              0.146178,
+              0.146597,
+              0.146737,
+              0.146666,
+              0.176,
+              0.14953,
+              0.146248,
+              0.146737,
+              0.147155,
+              0.148134,
+              0.146667,
+              0.147155,
+              0.146178,
+              0.147156,
+              0.14527,
+              0.146666,
+              0.147156,
+              0.146736
+            ],
+            "warm_rows_per_second": 3485091.3645289848
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746435529593024,
+            "character_perplexity": 6.518495207852214,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.362890522061065e-06,
+            "mean_prediction_kl_nats": 4.166460967471791e-09,
+            "prediction_kl_p99_nats": 2.713723610475145e-08,
+            "maximum_prediction_kl_nats": 9.861947594446357e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0012116432189941406,
+            "maximum_per_target_cross_entropy_increase": 0.00064849853515625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-layout",
+          "encoding": "fp16",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5451718,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "bdea909d0738ce1a9112cfdf55e058286ffdf48616c95623b85c5865be33ab4e",
+            "table_sha256": "35e05ce93fa67f0c19d85448fa6f58f92850761c9ce2bb07cc778719d17ded8e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.6727040119003505,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5452925,
+          "backend_with_key_registry_bytes": 6189032,
+          "backend_with_datrie_key_index_bytes": 5799085,
+          "full_model_serving_artifact_bytes": 7017030,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999513463311,
+            "mean_cosine": 0.9999999792195698,
+            "p05_cosine": 0.9999999716268251,
+            "relative_l2_mean": 0.00020639671283615942,
+            "relative_l2_p95": 0.00024186731774094268,
+            "relative_l2_max": 0.00031522546967662694,
+            "weighted_relative_l2_mean": 7.847420784280686e-05,
+            "weighted_relative_frobenius": 0.00020874166338934465,
+            "weighted_mean_cosine": 0.9999999921182615,
+            "max_relative_norm_change": 0.0001740708570888487
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.984566,
+            "warm_p50_ms": 0.1474,
+            "warm_p95_ms": 0.1676687,
+            "warm_p99_ms": 0.17912646,
+            "samples_ms": [
+              0.149531,
+              0.148134,
+              0.148133,
+              0.147086,
+              0.148064,
+              0.147645,
+              0.146248,
+              0.146737,
+              0.147155,
+              0.147575,
+              0.145201,
+              0.169924,
+              0.148553,
+              0.16755,
+              0.147156,
+              0.147644,
+              0.146178,
+              0.146178,
+              0.146178,
+              0.147155,
+              0.147156,
+              0.147016,
+              0.146247,
+              0.146178,
+              0.147644,
+              0.146248,
+              0.145758,
+              0.147226,
+              0.147574,
+              0.146667,
+              0.145759,
+              0.147645,
+              0.147575,
+              0.147575,
+              0.146667,
+              0.147645,
+              0.148552,
+              0.16706,
+              0.18501,
+              0.155188
+            ],
+            "warm_rows_per_second": 3473541.383989145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746435529593024,
+            "character_perplexity": 6.518495207852214,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.362890522061065e-06,
+            "mean_prediction_kl_nats": 4.166460967471791e-09,
+            "prediction_kl_p99_nats": 2.713723610475145e-08,
+            "maximum_prediction_kl_nats": 9.861947594446357e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0012116432189941406,
+            "maximum_per_target_cross_entropy_increase": 0.00064849853515625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-dedup",
+          "encoding": "fp16",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 5451718,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 675,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 675,
+              "zlib_blocks": 675,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "bdea909d0738ce1a9112cfdf55e058286ffdf48616c95623b85c5865be33ab4e",
+            "table_sha256": "35e05ce93fa67f0c19d85448fa6f58f92850761c9ce2bb07cc778719d17ded8e",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5485050650313497,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 5452925,
+          "backend_with_key_registry_bytes": 6189032,
+          "backend_with_datrie_key_index_bytes": 5799085,
+          "full_model_serving_artifact_bytes": 7017030,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999513463311,
+            "mean_cosine": 0.9999999792195698,
+            "p05_cosine": 0.9999999716268251,
+            "relative_l2_mean": 0.00020639671283615942,
+            "relative_l2_p95": 0.00024186731774094268,
+            "relative_l2_max": 0.00031522546967662694,
+            "weighted_relative_l2_mean": 7.847420784280686e-05,
+            "weighted_relative_frobenius": 0.00020874166338934465,
+            "weighted_mean_cosine": 0.9999999921182615,
+            "max_relative_norm_change": 0.0001740708570888487
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.941404,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.15012095,
+            "warm_p99_ms": 0.15759589000000002,
+            "samples_ms": [
+              0.154699,
+              0.14988,
+              0.148972,
+              0.147086,
+              0.148553,
+              0.147644,
+              0.147575,
+              0.148553,
+              0.148483,
+              0.146247,
+              0.146737,
+              0.146248,
+              0.147156,
+              0.146666,
+              0.147645,
+              0.145689,
+              0.146667,
+              0.148063,
+              0.146597,
+              0.146597,
+              0.147155,
+              0.147645,
+              0.146248,
+              0.148064,
+              0.147156,
+              0.147574,
+              0.159448,
+              0.149042,
+              0.147575,
+              0.147155,
+              0.147645,
+              0.148553,
+              0.146177,
+              0.146667,
+              0.146178,
+              0.146527,
+              0.147156,
+              0.146247,
+              0.147156,
+              0.148064
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746435529593024,
+            "character_perplexity": 6.518495207852214,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -3.362890522061065e-06,
+            "mean_prediction_kl_nats": 4.166460967471791e-09,
+            "prediction_kl_p99_nats": 2.713723610475145e-08,
+            "maximum_prediction_kl_nats": 9.861947594446357e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0012116432189941406,
+            "maximum_per_target_cross_entropy_increase": 0.00064849853515625
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "fp16-joint-0.99",
+          "encoding": "fp16",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3878921,
+              "unique_rows": 29810,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29810
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "125ad803adef474db5d65aac757c7d4d595c2a90dcc5604c8c3e61f7accd1a1e",
+            "table_sha256": "332c03fd3b8aadc1f5dc436b256bf6089fed708c3e9e7889b7151dade6e19075",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3961187079548836,
+          "representatives_sha256": "d4955c317d6d856716a740f4120db129490651f55043fd12797b6d4edf8a4b52",
+          "structurally_merged_rows": 13342,
+          "backend_artifact_bytes": 3880127,
+          "backend_with_key_registry_bytes": 4616234,
+          "backend_with_datrie_key_index_bytes": 4226287,
+          "full_model_serving_artifact_bytes": 5444232,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9902543419830719,
+            "mean_cosine": 0.9997190776427124,
+            "p05_cosine": 0.9986690949302727,
+            "relative_l2_mean": 0.01270466779811439,
+            "relative_l2_p95": 0.0518538727095818,
+            "relative_l2_max": 0.13994770767903386,
+            "weighted_relative_l2_mean": 0.002069047250165433,
+            "weighted_relative_frobenius": 0.013052639637527957,
+            "weighted_mean_cosine": 0.9999599095257184,
+            "max_relative_norm_change": 0.010116184706844977
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9902580478946749,
+            "mean_cosine": 0.9997190850797039,
+            "p05_cosine": 0.998668959958706,
+            "relative_l2_mean": 0.012562250183851622,
+            "relative_l2_p95": 0.051859147381795756,
+            "relative_l2_max": 0.13992493091393668,
+            "weighted_relative_l2_mean": 0.0020023304476201316,
+            "weighted_relative_frobenius": 0.01305117528543782,
+            "weighted_mean_cosine": 0.9999599160050102,
+            "max_relative_norm_change": 0.010087895669284265
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 4.907193,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.15095829999999996,
+            "warm_p99_ms": 0.16749055999999998,
+            "samples_ms": [
+              0.150438,
+              0.148063,
+              0.147575,
+              0.147505,
+              0.160844,
+              0.149041,
+              0.148552,
+              0.148552,
+              0.147644,
+              0.148134,
+              0.147575,
+              0.146178,
+              0.146667,
+              0.14527,
+              0.147156,
+              0.147156,
+              0.146597,
+              0.146597,
+              0.145689,
+              0.147575,
+              0.146667,
+              0.146667,
+              0.146248,
+              0.146736,
+              0.148064,
+              0.147645,
+              0.147085,
+              0.145619,
+              0.1452,
+              0.146597,
+              0.17174,
+              0.149949,
+              0.147156,
+              0.147086,
+              0.147226,
+              0.147156,
+              0.147226,
+              0.146736,
+              0.145759,
+              0.147155
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874574246673585,
+            "character_perplexity": 6.518043450815874,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -7.266654155279356e-05,
+            "mean_prediction_kl_nats": 9.671910930345072e-06,
+            "prediction_kl_p99_nats": 0.00013471611525336594,
+            "maximum_prediction_kl_nats": 0.004780077474893736,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.30183470249176025,
+            "maximum_per_target_cross_entropy_increase": 0.1393224000930786
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -6.930388409210745e-05,
+            "mean_prediction_kl_nats": 9.668194206757754e-06,
+            "prediction_kl_p99_nats": 0.00013446976339783222,
+            "maximum_prediction_kl_nats": 0.004787369487992659,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.3018685579299927,
+            "maximum_per_target_cross_entropy_increase": 0.13929986953735352
+          }
+        },
+        {
+          "name": "fp16-joint-0.98",
+          "encoding": "fp16",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3877703,
+              "unique_rows": 29801,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29801
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "38f219bbaa111886abe433803c907c9f4c011988547dfa7b03c85fa6107fba5b",
+            "table_sha256": "110e332f9528f9210380f65ff9a010e579809aa4556b0b844b86a4179311e3eb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.5946081799920648,
+          "representatives_sha256": "d56552783e04aae85d9de6ff8093b0136dd12a38b578852754d4949075a9a3d3",
+          "structurally_merged_rows": 13351,
+          "backend_artifact_bytes": 3878909,
+          "backend_with_key_registry_bytes": 4615016,
+          "backend_with_datrie_key_index_bytes": 4225069,
+          "full_model_serving_artifact_bytes": 5443014,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9812282968421467,
+            "mean_cosine": 0.9997154431587459,
+            "p05_cosine": 0.998665514808482,
+            "relative_l2_mean": 0.012745591071179944,
+            "relative_l2_p95": 0.05191842837465708,
+            "relative_l2_max": 0.19332654279600592,
+            "weighted_relative_l2_mean": 0.002105698474020462,
+            "weighted_relative_frobenius": 0.013916586005065044,
+            "weighted_mean_cosine": 0.9999569443360461,
+            "max_relative_norm_change": 0.010116184706844977
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9812273533691351,
+            "mean_cosine": 0.9997154506283183,
+            "p05_cosine": 0.9986658133165788,
+            "relative_l2_mean": 0.012603213295592029,
+            "relative_l2_p95": 0.051907282774863284,
+            "relative_l2_max": 0.1933325230358195,
+            "weighted_relative_l2_mean": 0.0020390277848896113,
+            "weighted_relative_frobenius": 0.01391532039964873,
+            "weighted_mean_cosine": 0.999956950429156,
+            "max_relative_norm_change": 0.010087895669284265
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.083193,
+            "warm_p50_ms": 0.147086,
+            "warm_p95_ms": 0.14997695,
+            "warm_p99_ms": 0.16716588,
+            "samples_ms": [
+              0.150508,
+              0.149461,
+              0.149042,
+              0.147575,
+              0.148552,
+              0.148064,
+              0.147156,
+              0.146178,
+              0.147645,
+              0.147086,
+              0.146109,
+              0.1452,
+              0.145689,
+              0.147505,
+              0.147086,
+              0.145689,
+              0.1452,
+              0.145689,
+              0.177816,
+              0.149949,
+              0.147644,
+              0.147086,
+              0.147645,
+              0.147086,
+              0.147086,
+              0.147085,
+              0.147156,
+              0.146597,
+              0.147156,
+              0.145759,
+              0.147644,
+              0.146248,
+              0.145759,
+              0.14534,
+              0.14534,
+              0.14527,
+              0.145759,
+              0.1452,
+              0.146597,
+              0.146667
+            ],
+            "warm_rows_per_second": 3480956.719198292
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8745985378953693,
+            "character_perplexity": 6.5182017839779824,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -4.837678991483754e-05,
+            "mean_prediction_kl_nats": 1.0035555638620316e-05,
+            "prediction_kl_p99_nats": 0.0001374315140857644,
+            "maximum_prediction_kl_nats": 0.004780077474893736,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.4480018615722656,
+            "maximum_per_target_cross_entropy_increase": 0.25829124450683594
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.501405077010117e-05,
+            "mean_prediction_kl_nats": 1.0031980910063025e-05,
+            "prediction_kl_p99_nats": 0.00013765976797404305,
+            "maximum_prediction_kl_nats": 0.004787369487992659,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.44802331924438477,
+            "maximum_per_target_cross_entropy_increase": 0.2583656311035156
+          }
+        },
+        {
+          "name": "fp16-joint-0.97",
+          "encoding": "fp16",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3876367,
+              "unique_rows": 29790,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 466,
+              "zlib_blocks": 466,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29790
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "c9bceb8ddbb8626afafcac0cbfaa184b5b0ab2ac3dd6a6a9f17803dfd44b23db",
+            "table_sha256": "3795c24d94caca2a7c11c065db26125df7043fda442d1c4d6b155ddcf96b7f82",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.47510257293470204,
+          "representatives_sha256": "0442ab13267b0a1637ef197a94cc19d4fad9d4368204426ed4180dd6e9c0dcf4",
+          "structurally_merged_rows": 13362,
+          "backend_artifact_bytes": 3877573,
+          "backend_with_key_registry_bytes": 4613680,
+          "backend_with_datrie_key_index_bytes": 4223733,
+          "full_model_serving_artifact_bytes": 5441678,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9703580930035629,
+            "mean_cosine": 0.9997071747644565,
+            "p05_cosine": 0.9986617977957264,
+            "relative_l2_mean": 0.01281676131336959,
+            "relative_l2_p95": 0.05197299549482736,
+            "relative_l2_max": 0.24491417991277825,
+            "weighted_relative_l2_mean": 0.002148307878191639,
+            "weighted_relative_frobenius": 0.015115978536123264,
+            "weighted_mean_cosine": 0.9999520822397424,
+            "max_relative_norm_change": 0.010116184706844977
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9703560166990202,
+            "mean_cosine": 0.9997071825853483,
+            "p05_cosine": 0.998661316509401,
+            "relative_l2_mean": 0.012674435105461485,
+            "relative_l2_p95": 0.05196615509578719,
+            "relative_l2_max": 0.2449187343259896,
+            "weighted_relative_l2_mean": 0.0020816757058458495,
+            "weighted_relative_frobenius": 0.01511475371180603,
+            "weighted_mean_cosine": 0.9999520885920036,
+            "max_relative_norm_change": 0.010087895669284265
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.373174,
+            "warm_p50_ms": 0.147156,
+            "warm_p95_ms": 0.17379024999999998,
+            "warm_p99_ms": 0.17988394,
+            "samples_ms": [
+              0.149042,
+              0.148064,
+              0.147645,
+              0.146177,
+              0.146248,
+              0.182635,
+              0.173696,
+              0.14995,
+              0.147575,
+              0.148063,
+              0.146597,
+              0.147156,
+              0.147645,
+              0.146737,
+              0.148552,
+              0.146178,
+              0.146247,
+              0.146667,
+              0.146178,
+              0.147086,
+              0.147086,
+              0.148552,
+              0.147575,
+              0.147645,
+              0.147645,
+              0.147156,
+              0.147645,
+              0.147155,
+              0.146737,
+              0.145828,
+              0.147645,
+              0.175581,
+              0.151835,
+              0.147156,
+              0.147156,
+              0.146597,
+              0.147086,
+              0.146736,
+              0.147226,
+              0.146736
+            ],
+            "warm_rows_per_second": 3479300.877979831
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874574723909101,
+            "character_perplexity": 6.518046561458446,
+            "next_character_accuracy": 0.49271584112866124,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -7.218934060193374e-05,
+            "mean_prediction_kl_nats": 2.579058573039068e-05,
+            "prediction_kl_p99_nats": 0.0001654147878750057,
+            "maximum_prediction_kl_nats": 0.02596963456959056,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.4513537883758545,
+            "maximum_per_target_cross_entropy_increase": 0.4725003242492676
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -6.882668153646766e-05,
+            "mean_prediction_kl_nats": 2.579188971355897e-05,
+            "prediction_kl_p99_nats": 0.00016557841705998745,
+            "maximum_prediction_kl_nats": 0.025976165433402816,
+            "top1_changed_fraction": 0.0011501303481061187,
+            "accuracy_change": -0.0002300260696212475,
+            "maximum_absolute_logit_change": 0.4514756202697754,
+            "maximum_per_target_cross_entropy_increase": 0.47253847122192383
+          }
+        },
+        {
+          "name": "fp16-joint-0.95",
+          "encoding": "fp16",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3873085,
+              "unique_rows": 29761,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 466,
+              "max_block_bytes": 8192,
+              "raw_blocks": 1,
+              "compressed_blocks": 465,
+              "zlib_blocks": 465,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29761
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "8c3e008b6398ecab23f6d1ea0550e6451038531f84bbc9c43f87616bd38ddd08",
+            "table_sha256": "54139fd1a85fcaf991b1b9b6e136649f8f72af9954d8448bc5c18327703a6744",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.49241547496058047,
+          "representatives_sha256": "981bcaf7dfaf2fd938d900cf558ed6aa9e8064d37250c908052ada39bec8c7e4",
+          "structurally_merged_rows": 13391,
+          "backend_artifact_bytes": 3874291,
+          "backend_with_key_registry_bytes": 4610398,
+          "backend_with_datrie_key_index_bytes": 4220451,
+          "full_model_serving_artifact_bytes": 5438396,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9500031851017586,
+            "mean_cosine": 0.9996657232299763,
+            "p05_cosine": 0.9986488635607634,
+            "relative_l2_mean": 0.013099563214621524,
+            "relative_l2_p95": 0.05224116177040271,
+            "relative_l2_max": 0.31642273328501797,
+            "weighted_relative_l2_mean": 0.0021971459755752215,
+            "weighted_relative_frobenius": 0.01618432619570471,
+            "weighted_mean_cosine": 0.9999450786415176,
+            "max_relative_norm_change": 0.010116184706844977
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9500094261912371,
+            "mean_cosine": 0.9996657303396614,
+            "p05_cosine": 0.9986487273419825,
+            "relative_l2_mean": 0.012957383484852904,
+            "relative_l2_p95": 0.052251951384778984,
+            "relative_l2_max": 0.31644699684229655,
+            "weighted_relative_l2_mean": 0.0021305421334455736,
+            "weighted_relative_frobenius": 0.01618312405999657,
+            "weighted_mean_cosine": 0.9999450856022387,
+            "max_relative_norm_change": 0.010087895669284265
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.21659,
+            "warm_p50_ms": 0.1462125,
+            "warm_p95_ms": 0.14910364999999998,
+            "warm_p99_ms": 0.16986126,
+            "samples_ms": [
+              0.148482,
+              0.147645,
+              0.147994,
+              0.146109,
+              0.147156,
+              0.147575,
+              0.146248,
+              0.145759,
+              0.146667,
+              0.146248,
+              0.146178,
+              0.160915,
+              0.146666,
+              0.145759,
+              0.146247,
+              0.145759,
+              0.146667,
+              0.146178,
+              0.146737,
+              0.145829,
+              0.147645,
+              0.14527,
+              0.146248,
+              0.146247,
+              0.14534,
+              0.146178,
+              0.1452,
+              0.1452,
+              0.146597,
+              0.145689,
+              0.145689,
+              0.145619,
+              0.145689,
+              0.14562,
+              0.145689,
+              0.146667,
+              0.146178,
+              0.145689,
+              0.175581,
+              0.146248
+            ],
+            "warm_rows_per_second": 3501752.586133197
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746352945099112,
+            "character_perplexity": 6.5184413754117205,
+            "next_character_accuracy": 0.49279251648520167,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": -1.162127804015254e-05,
+            "mean_prediction_kl_nats": 4.178353212325416e-05,
+            "prediction_kl_p99_nats": 0.00018900797759844118,
+            "maximum_prediction_kl_nats": 0.035442818935089986,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": -0.00015335071308081316,
+            "maximum_absolute_logit_change": 1.071639060974121,
+            "maximum_per_target_cross_entropy_increase": 0.915989875793457
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -8.258415290237982e-06,
+            "mean_prediction_kl_nats": 4.178929646424802e-05,
+            "prediction_kl_p99_nats": 0.00018906349936431463,
+            "maximum_prediction_kl_nats": 0.035441682833820196,
+            "top1_changed_fraction": 0.0015335071308081583,
+            "accuracy_change": -0.00015335071308081316,
+            "maximum_absolute_logit_change": 1.071523666381836,
+            "maximum_per_target_cross_entropy_increase": 0.9160799980163574
+          }
+        },
+        {
+          "name": "fp16-joint-0.9",
+          "encoding": "fp16",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "fp16",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 128,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 5523456,
+              "artifact_bytes": 3869182,
+              "unique_rows": 29729,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 128,
+              "block_rows": 64,
+              "blocks": 465,
+              "max_block_bytes": 8192,
+              "raw_blocks": 0,
+              "compressed_blocks": 465,
+              "zlib_blocks": 465,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29729
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "cad838d877ad94f85d1fa2c1318b41d0abb0dc96b9c459156207a621e6d8e16b",
+            "table_sha256": "f80003ec63e3a75bc7dea0b14f1547a0a54d9ac47f2d642014af67fcadde072a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 0,
+            "rounding": "fp16",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.3968648931477219,
+          "representatives_sha256": "ffc008e3152f0a165b2e393c95f5fdcd9c8a18a2c4ea01894a088bfa6295f872",
+          "structurally_merged_rows": 13423,
+          "backend_artifact_bytes": 3870388,
+          "backend_with_key_registry_bytes": 4606495,
+          "backend_with_datrie_key_index_bytes": 4216548,
+          "full_model_serving_artifact_bytes": 5434493,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9002018188155697,
+            "mean_cosine": 0.9995876893226137,
+            "p05_cosine": 0.998635669954663,
+            "relative_l2_mean": 0.013488494525890795,
+            "relative_l2_p95": 0.05243002897845533,
+            "relative_l2_max": 0.448270940806544,
+            "weighted_relative_l2_mean": 0.0024820834648912075,
+            "weighted_relative_frobenius": 0.029883640139702614,
+            "weighted_mean_cosine": 0.9998840531650607,
+            "max_relative_norm_change": 0.010116184706844977
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9001934321830203,
+            "mean_cosine": 0.9995876933680093,
+            "p05_cosine": 0.9986359124618528,
+            "relative_l2_mean": 0.013346473807101505,
+            "relative_l2_p95": 0.05244098744596039,
+            "relative_l2_max": 0.44828597129981507,
+            "weighted_relative_l2_mean": 0.0024155443655948516,
+            "weighted_relative_frobenius": 0.02988267517300625,
+            "weighted_mean_cosine": 0.999884059693872,
+            "max_relative_norm_change": 0.010087895669284265
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 5.44141,
+            "warm_p50_ms": 0.147575,
+            "warm_p95_ms": 0.15954564999999998,
+            "warm_p99_ms": 0.16362526,
+            "samples_ms": [
+              0.150368,
+              0.14946,
+              0.147575,
+              0.162731,
+              0.150369,
+              0.147645,
+              0.148064,
+              0.148622,
+              0.148063,
+              0.147575,
+              0.148064,
+              0.147574,
+              0.147645,
+              0.146667,
+              0.147644,
+              0.147645,
+              0.146667,
+              0.147644,
+              0.147086,
+              0.147226,
+              0.14534,
+              0.14527,
+              0.146737,
+              0.146248,
+              0.146248,
+              0.147156,
+              0.146667,
+              0.147575,
+              0.146178,
+              0.164197,
+              0.159378,
+              0.147645,
+              0.146667,
+              0.146178,
+              0.146597,
+              0.147156,
+              0.14569,
+              0.147575,
+              0.147156,
+              0.147644
+            ],
+            "warm_rows_per_second": 3469422.327630018
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746600056504465,
+            "character_perplexity": 6.518602455522848,
+            "next_character_accuracy": 0.49263916577212086,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 1.3089880639377128e-05,
+            "mean_prediction_kl_nats": 9.756990594690155e-05,
+            "prediction_kl_p99_nats": 0.00036106261136570783,
+            "maximum_prediction_kl_nats": 0.12539222471158687,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -0.0003067014261616263,
+            "maximum_absolute_logit_change": 1.5011892318725586,
+            "maximum_per_target_cross_entropy_increase": 0.915989875793457
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.6452826490492457e-05,
+            "mean_prediction_kl_nats": 9.757705936839794e-05,
+            "prediction_kl_p99_nats": 0.0003615714725105157,
+            "maximum_prediction_kl_nats": 0.12539424050629688,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -0.0003067014261616263,
+            "maximum_absolute_logit_change": 1.501293659210205,
+            "maximum_per_target_cross_entropy_increase": 0.9160799980163574
+          }
+        },
+        {
+          "name": "int8-raw",
+          "encoding": "int8",
+          "policy": "raw",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "raw_mmap",
+            "table_file": "table.rows",
+            "row_bytes": 68,
+            "storage": {
+              "artifact_bytes": 2934336,
+              "unique_rows": 43152,
+              "row_map_bytes": 0,
+              "deduplicate": false
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "126915e8d6c63c5a39ba052c391baeecb89382e4804054d3eecec1f79d5ff7a1",
+            "table_sha256": "f84441c1beaa17ea1a7fb7964f5ef9138678520636b2201e52c2ff5a42fa6216",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.07151377317495644,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 2935184,
+          "backend_with_key_registry_bytes": 3671291,
+          "backend_with_datrie_key_index_bytes": 3281344,
+          "full_model_serving_artifact_bytes": 4499289,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999330222579732,
+            "mean_cosine": 0.9999885624214073,
+            "p05_cosine": 0.9999775423662155,
+            "relative_l2_mean": 0.004676661233739485,
+            "relative_l2_p95": 0.006748828249821454,
+            "relative_l2_max": 0.011753130328384171,
+            "weighted_relative_l2_mean": 0.00202791963996097,
+            "weighted_relative_frobenius": 0.005295016649703832,
+            "weighted_mean_cosine": 0.9999944235324602,
+            "max_relative_norm_change": 0.003025896302998395
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 0.276781,
+            "warm_p50_ms": 0.095543,
+            "warm_p95_ms": 0.1018009,
+            "warm_p99_ms": 0.10668704999999999,
+            "samples_ms": [
+              0.097499,
+              0.09701,
+              0.098895,
+              0.097359,
+              0.095543,
+              0.095962,
+              0.095543,
+              0.095543,
+              0.095613,
+              0.095193,
+              0.095124,
+              0.095962,
+              0.095543,
+              0.095543,
+              0.095613,
+              0.095194,
+              0.095613,
+              0.095124,
+              0.095054,
+              0.094076,
+              0.094565,
+              0.109302,
+              0.095473,
+              0.102597,
+              0.09652,
+              0.096102,
+              0.094705,
+              0.095124,
+              0.094146,
+              0.095543,
+              0.093727,
+              0.095683,
+              0.095124,
+              0.094635,
+              0.095124,
+              0.095613,
+              0.095683,
+              0.095683,
+              0.095124,
+              0.101759
+            ],
+            "warm_rows_per_second": 5358843.662016056
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874735750473572,
+            "character_perplexity": 6.5190962246128565,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.883856400462751e-05,
+            "mean_prediction_kl_nats": 3.7871945751883092e-06,
+            "prediction_kl_p99_nats": 2.8762457161950016e-05,
+            "maximum_prediction_kl_nats": 0.00014814864790065312,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.035512447357177734,
+            "maximum_per_target_cross_entropy_increase": 0.02411508560180664
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-identity",
+          "encoding": "int8",
+          "policy": "identity",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3289029,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 201,
+              "compressed_blocks": 159,
+              "zlib_blocks": 159,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "126915e8d6c63c5a39ba052c391baeecb89382e4804054d3eecec1f79d5ff7a1",
+            "table_sha256": "4c8101acae791d2cee4243e5df028d24488afb64d8213676581d77214f367fe1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.29085787292569876,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290282,
+          "backend_with_key_registry_bytes": 4026389,
+          "backend_with_datrie_key_index_bytes": 3636442,
+          "full_model_serving_artifact_bytes": 4854387,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999330222579732,
+            "mean_cosine": 0.9999885624214073,
+            "p05_cosine": 0.9999775423662155,
+            "relative_l2_mean": 0.004676661233739485,
+            "relative_l2_p95": 0.006748828249821454,
+            "relative_l2_max": 0.011753130328384171,
+            "weighted_relative_l2_mean": 0.00202791963996097,
+            "weighted_relative_frobenius": 0.005295016649703832,
+            "weighted_mean_cosine": 0.9999944235324602,
+            "max_relative_norm_change": 0.003025896302998395
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.178212,
+            "warm_p50_ms": 0.112165,
+            "warm_p95_ms": 0.11696625,
+            "warm_p99_ms": 0.13743771999999999,
+            "samples_ms": [
+              0.116844,
+              0.119289,
+              0.112095,
+              0.111606,
+              0.113003,
+              0.112165,
+              0.112654,
+              0.112096,
+              0.112165,
+              0.112165,
+              0.113562,
+              0.111746,
+              0.112584,
+              0.112165,
+              0.112096,
+              0.112096,
+              0.113073,
+              0.112584,
+              0.113981,
+              0.113493,
+              0.111606,
+              0.114051,
+              0.111537,
+              0.110698,
+              0.110768,
+              0.114959,
+              0.11028,
+              0.114959,
+              0.113562,
+              0.111257,
+              0.112095,
+              0.112095,
+              0.111606,
+              0.112584,
+              0.149041,
+              0.113004,
+              0.110699,
+              0.112096,
+              0.109861,
+              0.111676
+            ],
+            "warm_rows_per_second": 4564703.784603041
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874735750473572,
+            "character_perplexity": 6.5190962246128565,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.883856400462751e-05,
+            "mean_prediction_kl_nats": 3.7871945751883092e-06,
+            "prediction_kl_p99_nats": 2.8762457161950016e-05,
+            "maximum_prediction_kl_nats": 0.00014814864790065312,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.035512447357177734,
+            "maximum_per_target_cross_entropy_increase": 0.02411508560180664
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-layout",
+          "encoding": "int8",
+          "policy": "layout",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3289029,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 201,
+              "compressed_blocks": 159,
+              "zlib_blocks": 159,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "126915e8d6c63c5a39ba052c391baeecb89382e4804054d3eecec1f79d5ff7a1",
+            "table_sha256": "4c8101acae791d2cee4243e5df028d24488afb64d8213676581d77214f367fe1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.4411535288672894,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290281,
+          "backend_with_key_registry_bytes": 4026388,
+          "backend_with_datrie_key_index_bytes": 3636441,
+          "full_model_serving_artifact_bytes": 4854386,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999330222579732,
+            "mean_cosine": 0.9999885624214073,
+            "p05_cosine": 0.9999775423662155,
+            "relative_l2_mean": 0.004676661233739485,
+            "relative_l2_p95": 0.006748828249821454,
+            "relative_l2_max": 0.011753130328384171,
+            "weighted_relative_l2_mean": 0.00202791963996097,
+            "weighted_relative_frobenius": 0.005295016649703832,
+            "weighted_mean_cosine": 0.9999944235324602,
+            "max_relative_norm_change": 0.003025896302998395
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.243095,
+            "warm_p50_ms": 0.111676,
+            "warm_p95_ms": 0.1140754,
+            "warm_p99_ms": 0.13328490999999998,
+            "samples_ms": [
+              0.114051,
+              0.113981,
+              0.112585,
+              0.112095,
+              0.113562,
+              0.113074,
+              0.112096,
+              0.113492,
+              0.112025,
+              0.112096,
+              0.112585,
+              0.112515,
+              0.111257,
+              0.14527,
+              0.113143,
+              0.111187,
+              0.111187,
+              0.111118,
+              0.112096,
+              0.114539,
+              0.112514,
+              0.110768,
+              0.111187,
+              0.111187,
+              0.111187,
+              0.110209,
+              0.110209,
+              0.111676,
+              0.111188,
+              0.112096,
+              0.111606,
+              0.112165,
+              0.111187,
+              0.110209,
+              0.111676,
+              0.111606,
+              0.110209,
+              0.111117,
+              0.110349,
+              0.109791
+            ],
+            "warm_rows_per_second": 4584691.428776102
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874735750473572,
+            "character_perplexity": 6.5190962246128565,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.883856400462751e-05,
+            "mean_prediction_kl_nats": 3.7871945751883092e-06,
+            "prediction_kl_p99_nats": 2.8762457161950016e-05,
+            "maximum_prediction_kl_nats": 0.00014814864790065312,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.035512447357177734,
+            "maximum_per_target_cross_entropy_increase": 0.02411508560180664
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-dedup",
+          "encoding": "int8",
+          "policy": "dedup",
+          "minimum_cosine": null,
+          "minimum_norm_ratio": null,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 3289029,
+              "unique_rows": 43152,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 360,
+              "max_block_bytes": 8192,
+              "raw_blocks": 201,
+              "compressed_blocks": 159,
+              "zlib_blocks": 159,
+              "xor_blocks": 0,
+              "deduplicate": true,
+              "predictor": "xor",
+              "reordered": false,
+              "external_representatives": false,
+              "marked_rows": 43152
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "126915e8d6c63c5a39ba052c391baeecb89382e4804054d3eecec1f79d5ff7a1",
+            "table_sha256": "4c8101acae791d2cee4243e5df028d24488afb64d8213676581d77214f367fe1",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.2992117360699922,
+          "representatives_sha256": "f48fb38b644244dc0fdf4b7babaea40f0028c483dc013ba186ad13dc9606139b",
+          "structurally_merged_rows": 0,
+          "backend_artifact_bytes": 3290281,
+          "backend_with_key_registry_bytes": 4026388,
+          "backend_with_datrie_key_index_bytes": 3636441,
+          "full_model_serving_artifact_bytes": 4854386,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999330222579732,
+            "mean_cosine": 0.9999885624214073,
+            "p05_cosine": 0.9999775423662155,
+            "relative_l2_mean": 0.004676661233739485,
+            "relative_l2_p95": 0.006748828249821454,
+            "relative_l2_max": 0.011753130328384171,
+            "weighted_relative_l2_mean": 0.00202791963996097,
+            "weighted_relative_frobenius": 0.005295016649703832,
+            "weighted_mean_cosine": 0.9999944235324602,
+            "max_relative_norm_change": 0.003025896302998395
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9999999999999998,
+            "mean_cosine": 1.0,
+            "p05_cosine": 0.9999999999999998,
+            "relative_l2_mean": 0.0,
+            "relative_l2_p95": 0.0,
+            "relative_l2_max": 0.0,
+            "weighted_relative_l2_mean": 0.0,
+            "weighted_relative_frobenius": 0.0,
+            "weighted_mean_cosine": 1.0,
+            "max_relative_norm_change": 0.0
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.186244,
+            "warm_p50_ms": 0.112096,
+            "warm_p95_ms": 0.11689035,
+            "warm_p99_ms": 0.12299251,
+            "samples_ms": [
+              0.116845,
+              0.114889,
+              0.114051,
+              0.112165,
+              0.112095,
+              0.112096,
+              0.113422,
+              0.113073,
+              0.126343,
+              0.113562,
+              0.112026,
+              0.112096,
+              0.112026,
+              0.112096,
+              0.111676,
+              0.113073,
+              0.11447,
+              0.111607,
+              0.111188,
+              0.111677,
+              0.110699,
+              0.110629,
+              0.112096,
+              0.113981,
+              0.117752,
+              0.111677,
+              0.111257,
+              0.111257,
+              0.111677,
+              0.111607,
+              0.112096,
+              0.111607,
+              0.112584,
+              0.111676,
+              0.113562,
+              0.112165,
+              0.112654,
+              0.112235,
+              0.111118,
+              0.11021
+            ],
+            "warm_rows_per_second": 4567513.55980588
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.874735750473572,
+            "character_perplexity": 6.5190962246128565,
+            "next_character_accuracy": 0.4929458671982825,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 8.883856400462751e-05,
+            "mean_prediction_kl_nats": 3.7871945751883092e-06,
+            "prediction_kl_p99_nats": 2.8762457161950016e-05,
+            "maximum_prediction_kl_nats": 0.00014814864790065312,
+            "top1_changed_fraction": 0.00038337678270203957,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.035512447357177734,
+            "maximum_per_target_cross_entropy_increase": 0.02411508560180664
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 0.0,
+            "mean_prediction_kl_nats": 0.0,
+            "prediction_kl_p99_nats": 0.0,
+            "maximum_prediction_kl_nats": 0.0,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.0,
+            "maximum_per_target_cross_entropy_increase": 0.0
+          }
+        },
+        {
+          "name": "int8-joint-0.99",
+          "encoding": "int8",
+          "policy": "joint-0.99",
+          "minimum_cosine": 0.99,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2379853,
+              "unique_rows": 29846,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 72,
+              "compressed_blocks": 177,
+              "zlib_blocks": 177,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29846
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "de7eaa6d2a5be1f706c23e4f930aaf1e0e9d4a29ccbc573380e2eb0974d75a71",
+            "table_sha256": "949503f9997f9cb539b3a3a543c888998333f8fbcb7ae4dd3264d1b0dcd90b5a",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24713083100505173,
+          "representatives_sha256": "c080d9c9e31eecbbf986a597348e8008148ab5134dfba58849528f43e1f093e3",
+          "structurally_merged_rows": 13306,
+          "backend_artifact_bytes": 2381103,
+          "backend_with_key_registry_bytes": 3117210,
+          "backend_with_datrie_key_index_bytes": 2727263,
+          "full_model_serving_artifact_bytes": 3945208,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900045008372362,
+            "mean_cosine": 0.9997080968464004,
+            "p05_cosine": 0.9986578003297385,
+            "relative_l2_mean": 0.015918658014219725,
+            "relative_l2_p95": 0.05205936305802378,
+            "relative_l2_max": 0.1410713069702977,
+            "weighted_relative_l2_mean": 0.0037717178974230347,
+            "weighted_relative_frobenius": 0.014090331843047801,
+            "weighted_mean_cosine": 0.9999544167140528,
+            "max_relative_norm_change": 0.011492262128833867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9900075876747326,
+            "mean_cosine": 0.9997131100119235,
+            "p05_cosine": 0.9986422640608953,
+            "relative_l2_mean": 0.012692939117199618,
+            "relative_l2_p95": 0.05229383057532564,
+            "relative_l2_max": 0.14107486043401196,
+            "weighted_relative_l2_mean": 0.0020412890536581946,
+            "weighted_relative_frobenius": 0.013331484320787465,
+            "weighted_mean_cosine": 0.9999585629111997,
+            "max_relative_norm_change": 0.010096391613368234
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.952263,
+            "warm_p50_ms": 0.109546,
+            "warm_p95_ms": 0.11169695,
+            "warm_p99_ms": 0.12223441999999998,
+            "samples_ms": [
+              0.112095,
+              0.11021,
+              0.109721,
+              0.109721,
+              0.10972,
+              0.111676,
+              0.109791,
+              0.107346,
+              0.109791,
+              0.110629,
+              0.109372,
+              0.128717,
+              0.11014,
+              0.109861,
+              0.10979,
+              0.109232,
+              0.109791,
+              0.110209,
+              0.108882,
+              0.110629,
+              0.108324,
+              0.110628,
+              0.109232,
+              0.109302,
+              0.107905,
+              0.108882,
+              0.109791,
+              0.108813,
+              0.107905,
+              0.108394,
+              0.109791,
+              0.108883,
+              0.107835,
+              0.109302,
+              0.108254,
+              0.108324,
+              0.11021,
+              0.108324,
+              0.108324,
+              0.107346
+            ],
+            "warm_rows_per_second": 4673835.648951125
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746908137499918,
+            "character_perplexity": 6.518803284369755,
+            "next_character_accuracy": 0.49286919184174205,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 4.389885803966729e-05,
+            "mean_prediction_kl_nats": 1.3655938868588348e-05,
+            "prediction_kl_p99_nats": 0.00014786152414243808,
+            "maximum_prediction_kl_nats": 0.004587678278745104,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.3009474277496338,
+            "maximum_per_target_cross_entropy_increase": 0.13836276531219482
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.493571394066121e-05,
+            "mean_prediction_kl_nats": 9.852603724910931e-06,
+            "prediction_kl_p99_nats": 0.00014666116345027564,
+            "maximum_prediction_kl_nats": 0.0047143691122537665,
+            "top1_changed_fraction": 0.0013034810611869344,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.30302488803863525,
+            "maximum_per_target_cross_entropy_increase": 0.14164996147155762
+          }
+        },
+        {
+          "name": "int8-joint-0.98",
+          "encoding": "int8",
+          "policy": "joint-0.98",
+          "minimum_cosine": 0.98,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2379385,
+              "unique_rows": 29839,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 81,
+              "compressed_blocks": 168,
+              "zlib_blocks": 168,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29839
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "0580c7d3bf518fa0aca5cc3195b31e950e0bf8e54ba66c43e01683cd0702d4dd",
+            "table_sha256": "b4e55e897271198a89e1c24459913e6592921aa13018d6f55162faf28943cdeb",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.24981343699619174,
+          "representatives_sha256": "eeed1d7f988a6a71aa0885d278dcc6a8e00f7dee19de702ddfbc3ac989bc0426",
+          "structurally_merged_rows": 13313,
+          "backend_artifact_bytes": 2380635,
+          "backend_with_key_registry_bytes": 3116742,
+          "backend_with_datrie_key_index_bytes": 2726795,
+          "full_model_serving_artifact_bytes": 3944740,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.981201790935401,
+            "mean_cosine": 0.9997044925472083,
+            "p05_cosine": 0.9986558993875337,
+            "relative_l2_mean": 0.015957505284212074,
+            "relative_l2_p95": 0.05211572202221419,
+            "relative_l2_max": 0.1934387575369315,
+            "weighted_relative_l2_mean": 0.00380829590926195,
+            "weighted_relative_frobenius": 0.014932757752551326,
+            "weighted_mean_cosine": 0.9999513883877973,
+            "max_relative_norm_change": 0.011492262128833867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9812446464931801,
+            "mean_cosine": 0.9997094996992814,
+            "p05_cosine": 0.9986393816828784,
+            "relative_l2_mean": 0.01273253761773353,
+            "relative_l2_p95": 0.052356677148328194,
+            "relative_l2_max": 0.1932106405627494,
+            "weighted_relative_l2_mean": 0.0020788796147398767,
+            "weighted_relative_frobenius": 0.014224178888892137,
+            "weighted_mean_cosine": 0.9999555206537855,
+            "max_relative_norm_change": 0.010096391613368234
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.915877,
+            "warm_p50_ms": 0.107835,
+            "warm_p95_ms": 0.11030079999999999,
+            "warm_p99_ms": 0.11845905999999999,
+            "samples_ms": [
+              0.112026,
+              0.11021,
+              0.109302,
+              0.107835,
+              0.107346,
+              0.109721,
+              0.107835,
+              0.109301,
+              0.107905,
+              0.107905,
+              0.107905,
+              0.107346,
+              0.10986,
+              0.108813,
+              0.109791,
+              0.107835,
+              0.107835,
+              0.107346,
+              0.106438,
+              0.106858,
+              0.107416,
+              0.108743,
+              0.107835,
+              0.107835,
+              0.106508,
+              0.107905,
+              0.107905,
+              0.109721,
+              0.106508,
+              0.107835,
+              0.122572,
+              0.108813,
+              0.108743,
+              0.107346,
+              0.106927,
+              0.107835,
+              0.107905,
+              0.10553,
+              0.105391,
+              0.10595
+            ],
+            "warm_rows_per_second": 4747994.621412343
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8747143007178286,
+            "character_perplexity": 6.5189563930908525,
+            "next_character_accuracy": 0.49286919184174205,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 6.738713276056816e-05,
+            "mean_prediction_kl_nats": 1.4004362616397858e-05,
+            "prediction_kl_p99_nats": 0.00015551443616178517,
+            "maximum_prediction_kl_nats": 0.004587678278745104,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.44987034797668457,
+            "maximum_per_target_cross_entropy_increase": 0.24598169326782227
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -2.1449525698997674e-05,
+            "mean_prediction_kl_nats": 1.0217633862415313e-05,
+            "prediction_kl_p99_nats": 0.0001517913261544031,
+            "maximum_prediction_kl_nats": 0.0047143691122537665,
+            "top1_changed_fraction": 0.0013034810611869344,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.44704198837280273,
+            "maximum_per_target_cross_entropy_increase": 0.2515549659729004
+          }
+        },
+        {
+          "name": "int8-joint-0.97",
+          "encoding": "int8",
+          "policy": "joint-0.97",
+          "minimum_cosine": 0.97,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2378706,
+              "unique_rows": 29829,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 81,
+              "compressed_blocks": 168,
+              "zlib_blocks": 168,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29829
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "1e96b6053daa54587ab5ea83b49d3588199e5feda611a7ae86ed5b1eb9754722",
+            "table_sha256": "fd07970de04a13707396af5641daf99a845a5db43183794a0002ffc5509be158",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25833526882342994,
+          "representatives_sha256": "6acf75d3e2ba801464e220ea404b08e05e3fc42548c067684b11cc074397c082",
+          "structurally_merged_rows": 13323,
+          "backend_artifact_bytes": 2379956,
+          "backend_with_key_registry_bytes": 3116063,
+          "backend_with_datrie_key_index_bytes": 2726116,
+          "full_model_serving_artifact_bytes": 3944061,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.97040245654302,
+            "mean_cosine": 0.9996967602717127,
+            "p05_cosine": 0.9986501049778329,
+            "relative_l2_mean": 0.016022564144458906,
+            "relative_l2_p95": 0.05215003659856219,
+            "relative_l2_max": 0.24480937559793678,
+            "weighted_relative_l2_mean": 0.003849943713934918,
+            "weighted_relative_frobenius": 0.016057651017675024,
+            "weighted_mean_cosine": 0.9999465217457014,
+            "max_relative_norm_change": 0.011492262128833867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9702562647044194,
+            "mean_cosine": 0.999701746958545,
+            "p05_cosine": 0.9986360562965715,
+            "relative_l2_mean": 0.012798844304167282,
+            "relative_l2_p95": 0.0524129035256841,
+            "relative_l2_max": 0.24442440666938092,
+            "weighted_relative_l2_mean": 0.0021216697628386925,
+            "weighted_relative_frobenius": 0.0154071093387881,
+            "weighted_mean_cosine": 0.9999506274423351,
+            "max_relative_norm_change": 0.010096391613368234
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 3.1386,
+            "warm_p50_ms": 0.1088125,
+            "warm_p95_ms": 0.11180254999999999,
+            "warm_p99_ms": 0.13681981,
+            "samples_ms": [
+              0.110768,
+              0.111607,
+              0.109721,
+              0.108813,
+              0.108324,
+              0.110279,
+              0.108394,
+              0.109791,
+              0.11028,
+              0.107836,
+              0.108813,
+              0.107904,
+              0.108813,
+              0.108812,
+              0.108813,
+              0.107974,
+              0.115518,
+              0.109301,
+              0.107416,
+              0.107836,
+              0.108394,
+              0.108254,
+              0.107416,
+              0.10972,
+              0.107346,
+              0.150439,
+              0.11028,
+              0.107835,
+              0.108883,
+              0.108254,
+              0.108883,
+              0.108324,
+              0.106438,
+              0.107346,
+              0.108813,
+              0.106927,
+              0.107905,
+              0.108813,
+              0.108464,
+              0.108813
+            ],
+            "warm_rows_per_second": 4705341.757610568
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8746904356031506,
+            "character_perplexity": 6.518800819305351,
+            "next_character_accuracy": 0.49286919184174205,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 4.352069466971398e-05,
+            "mean_prediction_kl_nats": 2.979705460222902e-05,
+            "prediction_kl_p99_nats": 0.00017673648535457696,
+            "maximum_prediction_kl_nats": 0.025972837018001935,
+            "top1_changed_fraction": 0.001686857843888974,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.45468056201934814,
+            "maximum_per_target_cross_entropy_increase": 0.4720644950866699
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": -4.5313843718108086e-05,
+            "mean_prediction_kl_nats": 2.6014357149968005e-05,
+            "prediction_kl_p99_nats": 0.00016585546912271107,
+            "maximum_prediction_kl_nats": 0.02601218763702007,
+            "top1_changed_fraction": 0.0013034810611869344,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 0.4569981098175049,
+            "maximum_per_target_cross_entropy_increase": 0.47402477264404297
+          }
+        },
+        {
+          "name": "int8-joint-0.95",
+          "encoding": "int8",
+          "policy": "joint-0.95",
+          "minimum_cosine": 0.95,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2376894,
+              "unique_rows": 29803,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 83,
+              "compressed_blocks": 166,
+              "zlib_blocks": 166,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29803
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "95b6ba72d207d2380587f8a30590e0fb2ad1961be90b01c11eb12dab3b61921c",
+            "table_sha256": "ee72798e78e294518eb409acad29fc4680c5689b3a67d4326d1ee3a6739d5483",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25348946708254516,
+          "representatives_sha256": "af5093f8bd42c3455666516db33046941def1ac1cb4630fe53dd09be3454ef09",
+          "structurally_merged_rows": 13349,
+          "backend_artifact_bytes": 2378144,
+          "backend_with_key_registry_bytes": 3114251,
+          "backend_with_datrie_key_index_bytes": 2724304,
+          "full_model_serving_artifact_bytes": 3942249,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9500310490484243,
+            "mean_cosine": 0.9996589611534579,
+            "p05_cosine": 0.9986374972004458,
+            "relative_l2_mean": 0.01627759091524889,
+            "relative_l2_p95": 0.0523743928211285,
+            "relative_l2_max": 0.3169463056015357,
+            "weighted_relative_l2_mean": 0.003892891244357256,
+            "weighted_relative_frobenius": 0.017019670055103134,
+            "weighted_mean_cosine": 0.9999402561558993,
+            "max_relative_norm_change": 0.011492262128833867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9501599222200492,
+            "mean_cosine": 0.9996639282393538,
+            "p05_cosine": 0.9986254662412041,
+            "relative_l2_mean": 0.013056697783505997,
+            "relative_l2_p95": 0.05263862802663197,
+            "relative_l2_max": 0.31691284212741533,
+            "weighted_relative_l2_mean": 0.0021653347140213747,
+            "weighted_relative_frobenius": 0.01640990629562992,
+            "weighted_mean_cosine": 0.9999443442918322,
+            "max_relative_norm_change": 0.010096391613368234
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.946118,
+            "warm_p50_ms": 0.10982600000000001,
+            "warm_p95_ms": 0.11733729999999999,
+            "warm_p99_ms": 0.13381163999999998,
+            "samples_ms": [
+              0.110768,
+              0.112235,
+              0.109791,
+              0.114959,
+              0.108813,
+              0.111607,
+              0.109372,
+              0.10979,
+              0.11873,
+              0.112165,
+              0.112165,
+              0.109231,
+              0.108813,
+              0.108813,
+              0.108882,
+              0.109302,
+              0.11021,
+              0.110279,
+              0.10979,
+              0.11014,
+              0.112166,
+              0.110699,
+              0.111677,
+              0.109721,
+              0.110699,
+              0.10979,
+              0.108254,
+              0.109791,
+              0.109651,
+              0.108813,
+              0.108813,
+              0.143454,
+              0.114051,
+              0.111188,
+              0.108813,
+              0.109232,
+              0.111257,
+              0.117264,
+              0.109861,
+              0.109791
+            ],
+            "warm_rows_per_second": 4661919.763990312
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8747468378917542,
+            "character_perplexity": 6.51916850495957,
+            "next_character_accuracy": 0.49302254255482286,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 9.992702864821589e-05,
+            "mean_prediction_kl_nats": 4.551468955017082e-05,
+            "prediction_kl_p99_nats": 0.00020112406909674518,
+            "maximum_prediction_kl_nats": 0.0364496174654843,
+            "top1_changed_fraction": 0.001993559270050606,
+            "accuracy_change": 7.667535654037883e-05,
+            "maximum_absolute_logit_change": 1.067946434020996,
+            "maximum_per_target_cross_entropy_increase": 0.9218840599060059
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 1.1087479647818034e-05,
+            "mean_prediction_kl_nats": 4.1565697000894676e-05,
+            "prediction_kl_p99_nats": 0.00018631396767026089,
+            "maximum_prediction_kl_nats": 0.03575100198331784,
+            "top1_changed_fraction": 0.0016101824873485662,
+            "accuracy_change": 7.667535654037883e-05,
+            "maximum_absolute_logit_change": 1.0640273094177246,
+            "maximum_per_target_cross_entropy_increase": 0.9170961380004883
+          }
+        },
+        {
+          "name": "int8-joint-0.9",
+          "encoding": "int8",
+          "policy": "joint-0.9",
+          "minimum_cosine": 0.9,
+          "minimum_norm_ratio": 0.99,
+          "metadata": {
+            "schema_version": 1,
+            "shape": [
+              43152,
+              64
+            ],
+            "encoding": "int8",
+            "byteorder": "little",
+            "backend": "native",
+            "table_file": "table.men",
+            "row_bytes": 68,
+            "storage": {
+              "format": "MEFTNAT1",
+              "format_version": 2,
+              "input_bytes": 2934336,
+              "artifact_bytes": 2374644,
+              "unique_rows": 29770,
+              "row_map_bytes": 345216,
+              "n_rows": 43152,
+              "row_bytes": 68,
+              "block_rows": 120,
+              "blocks": 249,
+              "max_block_bytes": 8192,
+              "raw_blocks": 81,
+              "compressed_blocks": 168,
+              "zlib_blocks": 168,
+              "xor_blocks": 0,
+              "deduplicate": false,
+              "predictor": "xor",
+              "reordered": true,
+              "external_representatives": true,
+              "marked_rows": 29770
+            },
+            "source_float32_sha256": "8b300423d3217435173b444876d6a4b31be10e2baf79c32d3766439aebd52b75",
+            "decoded_float32_sha256": "d0e4d71cb12e446a9b61ad1cc09eca808fe045b0c6c503b2f75e691c4d6ac502",
+            "table_sha256": "ee3ff9282668949db928a8682861d85d27e2e3715872e58448a8660fdc2c5855",
+            "source_bytes_preserved": false,
+            "int8_scale_bytes_per_physical_row": 4,
+            "rounding": "nearest-even; symmetric [-127,127] per-row scale",
+            "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows"
+          },
+          "export_seconds": 0.25261233001947403,
+          "representatives_sha256": "9e964f3458307b77a92f7c4e6d55fb96d66dbe9a75ab57c4663e6881e11279c8",
+          "structurally_merged_rows": 13382,
+          "backend_artifact_bytes": 2375894,
+          "backend_with_key_registry_bytes": 3112001,
+          "backend_with_datrie_key_index_bytes": 2722054,
+          "full_model_serving_artifact_bytes": 3939999,
+          "fidelity_vs_float32": {
+            "rows": 43152,
+            "minimum_cosine": 0.9002505497681637,
+            "mean_cosine": 0.9995771039885059,
+            "p05_cosine": 0.9986266003056047,
+            "relative_l2_mean": 0.01668135380304124,
+            "relative_l2_p95": 0.05261329348892294,
+            "relative_l2_max": 0.4476735226377543,
+            "weighted_relative_l2_mean": 0.004175748016733891,
+            "weighted_relative_frobenius": 0.030339692323942288,
+            "weighted_mean_cosine": 0.9998793091128563,
+            "max_relative_norm_change": 0.011492262128833867
+          },
+          "added_fidelity_vs_quantization_only": {
+            "rows": 43152,
+            "minimum_cosine": 0.9001671583065514,
+            "mean_cosine": 0.9995820648045777,
+            "p05_cosine": 0.9986114016095644,
+            "relative_l2_mean": 0.013464057944793923,
+            "relative_l2_p95": 0.052907295257222174,
+            "relative_l2_max": 0.4478462401559686,
+            "weighted_relative_l2_mean": 0.002449430186867565,
+            "weighted_relative_frobenius": 0.029967218368968207,
+            "weighted_mean_cosine": 0.9998835445533141,
+            "max_relative_norm_change": 0.010096391613368234
+          },
+          "all_encoded_rows_and_original_ids_verified": true,
+          "queries": {
+            "first_empty_application_cache_ms": 2.929007,
+            "warm_p50_ms": 0.109302,
+            "warm_p95_ms": 0.11542689999999999,
+            "warm_p99_ms": 0.13654944,
+            "samples_ms": [
+              0.113073,
+              0.10986,
+              0.109302,
+              0.107486,
+              0.108813,
+              0.113492,
+              0.109721,
+              0.11447,
+              0.111257,
+              0.111187,
+              0.109302,
+              0.108883,
+              0.14946,
+              0.113562,
+              0.116356,
+              0.108813,
+              0.108324,
+              0.110699,
+              0.110629,
+              0.111676,
+              0.108812,
+              0.115378,
+              0.108813,
+              0.108324,
+              0.107905,
+              0.108324,
+              0.108743,
+              0.108813,
+              0.109232,
+              0.10979,
+              0.11021,
+              0.11028,
+              0.108394,
+              0.108323,
+              0.111746,
+              0.108813,
+              0.108813,
+              0.110698,
+              0.108743,
+              0.109301
+            ],
+            "warm_rows_per_second": 4684269.27229145
+          },
+          "validation": {
+            "targets": 13042,
+            "cross_entropy_nats": 1.8747692168674108,
+            "character_perplexity": 6.519314398905316,
+            "next_character_accuracy": 0.49286919184174205,
+            "unknown_targets": 0
+          },
+          "validation_delta": {
+            "perplexity_relative_change": 0.0001223084910055302,
+            "mean_prediction_kl_nats": 0.00010083192637675476,
+            "prediction_kl_p99_nats": 0.00035157782737860616,
+            "maximum_prediction_kl_nats": 0.1234834254535015,
+            "top1_changed_fraction": 0.0022235853396718294,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.488051414489746,
+            "maximum_per_target_cross_entropy_increase": 0.9218840599060059
+          },
+          "added_validation_delta_vs_quantization_only": {
+            "perplexity_relative_change": 3.346695384478151e-05,
+            "mean_prediction_kl_nats": 9.71627967356333e-05,
+            "prediction_kl_p99_nats": 0.00034940811032745464,
+            "maximum_prediction_kl_nats": 0.12394890936422365,
+            "top1_changed_fraction": 0.0018402085569697898,
+            "accuracy_change": -7.667535654043434e-05,
+            "maximum_absolute_logit_change": 1.493788242340088,
+            "maximum_per_target_cross_entropy_increase": 0.9170961380004883
+          }
+        }
+      ],
+      "baseline_quality": {
+        "validation": {
+          "targets": 13042,
+          "cross_entropy_nats": 1.8746469158554788,
+          "character_perplexity": 6.518517128911684,
+          "next_character_accuracy": 0.4929458671982825,
+          "unknown_targets": 0
+        },
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7494370523487461,
+          "character_perplexity": 5.751364047620025,
+          "next_character_accuracy": 0.5255692708732653,
+          "unknown_targets": 0
+        }
+      },
+      "selection": {
+        "fp32": {
+          "feasible": true,
+          "name": "fp32-joint-0.9",
+          "backend_with_key_registry_bytes": 8186195,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7491682414699585,
+            "character_perplexity": 5.749818226172276,
+            "next_character_accuracy": 0.5252625929617419,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -0.0002687747523804419,
+            "mean_prediction_kl_nats": 0.0001433063275818475,
+            "prediction_kl_p99_nats": 0.00047574067175172846,
+            "maximum_prediction_kl_nats": 0.14949254966897688,
+            "top1_changed_fraction": 0.0013800506018554013,
+            "accuracy_change": -0.00030667791152338975,
+            "maximum_absolute_logit_change": 1.5382030010223389,
+            "maximum_per_target_cross_entropy_increase": 0.7367382049560547
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0005444561415285015,
+              1.527656112117525e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "fp16": {
+          "feasible": true,
+          "name": "fp16-joint-0.9",
+          "backend_with_key_registry_bytes": 4606495,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7491683695294322,
+            "character_perplexity": 5.749818962491019,
+            "next_character_accuracy": 0.5252625929617419,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": -0.0002686467273177534,
+            "mean_prediction_kl_nats": 0.00014329286792632542,
+            "prediction_kl_p99_nats": 0.0004777807634440265,
+            "maximum_prediction_kl_nats": 0.1495226025186514,
+            "top1_changed_fraction": 0.0013800506018554013,
+            "accuracy_change": -0.00030667791152338975,
+            "maximum_absolute_logit_change": 1.538262128829956,
+            "maximum_per_target_cross_entropy_increase": 0.7369163036346436
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              -0.0005467265885629537,
+              1.8822879602251045e-05
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": false
+        },
+        "int8": {
+          "feasible": true,
+          "name": "int8-joint-0.95",
+          "backend_with_key_registry_bytes": 3114251,
+          "test": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7496451964622277,
+            "character_perplexity": 5.752561284785639,
+            "next_character_accuracy": 0.5254159319175037,
+            "unknown_targets": 0
+          },
+          "test_delta": {
+            "perplexity_relative_change": 0.00020816577697060302,
+            "mean_prediction_kl_nats": 6.48036425053271e-05,
+            "prediction_kl_p99_nats": 0.00021414928574367274,
+            "maximum_prediction_kl_nats": 0.15112539268236266,
+            "top1_changed_fraction": 0.0026067622479490913,
+            "accuracy_change": -0.00015333895576163936,
+            "maximum_absolute_logit_change": 1.0701985359191895,
+            "maximum_per_target_cross_entropy_increase": 0.7534070014953613
+          },
+          "test_paired_block_interval": {
+            "perplexity_relative_change_95_percent_interval": [
+              1.1390863152666506e-05,
+              0.0004288786464272205
+            ],
+            "block_characters": 256,
+            "observed_blocks": 52,
+            "repeats": 1000,
+            "seed": 42,
+            "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+          },
+          "test_all_budgets_passed": true
+        }
+      },
+      "fixed_quantization_test_controls": {
+        "fp16": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.7494358820052505,
+            "character_perplexity": 5.751357316552459,
+            "next_character_accuracy": 0.5255692708732653,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": -1.1703428108266528e-06,
+            "mean_prediction_kl_nats": 3.8673117189102365e-09,
+            "prediction_kl_p99_nats": 2.5890530409318675e-08,
+            "maximum_prediction_kl_nats": 7.611372185147914e-08,
+            "top1_changed_fraction": 0.0,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.001432180404663086,
+            "maximum_per_target_cross_entropy_increase": 0.0007014274597167969
+          }
+        },
+        "int8": {
+          "metrics": {
+            "targets": 13043,
+            "cross_entropy_nats": 1.749516485595348,
+            "character_perplexity": 5.751820915283718,
+            "next_character_accuracy": 0.5255692708732653,
+            "unknown_targets": 0
+          },
+          "delta": {
+            "perplexity_relative_change": 7.943640150563587e-05,
+            "mean_prediction_kl_nats": 3.5398041673480987e-06,
+            "prediction_kl_p99_nats": 2.894596014564925e-05,
+            "maximum_prediction_kl_nats": 0.00010490708635250501,
+            "top1_changed_fraction": 0.0013033811239745456,
+            "accuracy_change": 0.0,
+            "maximum_absolute_logit_change": 0.03159666061401367,
+            "maximum_per_target_cross_entropy_increase": 0.022692203521728516
+          }
+        }
+      },
+      "checkpoint_sha256": "d2b8acfabccdc0f727220d8529bbe5b60c75d87bdefe10184232ad1310d868aa",
+      "registry_sha256": "abab407b9c927abc758d3d85a11cec2c2535254fe5af55b6cce10b650a992d4d"
+    }
+  ],
+  "failures": []
+}
diff --git a/docs/quantized_structural_evidence_20261031/resources-launch-failure.txt b/docs/quantized_structural_evidence_20261031/resources-launch-failure.txt
new file mode 100644
index 0000000..09726bf
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/resources-launch-failure.txt
@@ -0,0 +1 @@
+/llm-align/duyimin/ngram-quantized-20261031/run.sh: 行 5: /usr/bin/time: 没有那个文件或目录
diff --git a/docs/quantized_structural_evidence_20261031/resources.txt b/docs/quantized_structural_evidence_20261031/resources.txt
new file mode 100644
index 0000000..e69de29
diff --git a/docs/quantized_structural_evidence_20261031/run.log b/docs/quantized_structural_evidence_20261031/run.log
new file mode 100644
index 0000000..0cdc0e3
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/run.log
@@ -0,0 +1,58 @@
+{"category": "sgns", "order": 4, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 4, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 4, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 4, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 4, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 4, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 4, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 4, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 4, "seed": 11, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 8, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 8, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 8, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 8, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 8, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 8, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 8, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 8, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 8, "seed": 11, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 12, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 12, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 12, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 12, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 12, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 12, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "sgns", "order": 12, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "sgns", "order": 12, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "sgns", "order": 12, "seed": 11, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 4, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 4, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 4, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 4, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 4, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 4, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 4, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 4, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 4, "seed": 11, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 8, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 8, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 8, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 8, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 8, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 8, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 8, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 8, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 8, "seed": 11, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 12, "seed": 3, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 12, "seed": 3, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 12, "seed": 3, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 12, "seed": 7, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 12, "seed": 7, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 12, "seed": 7, "encoding": "int8", "completed_variants": 27}
+{"category": "gru", "order": 12, "seed": 11, "encoding": "fp32", "completed_variants": 9}
+{"category": "gru", "order": 12, "seed": 11, "encoding": "fp16", "completed_variants": 18}
+{"category": "gru", "order": 12, "seed": 11, "encoding": "int8", "completed_variants": 27}
+
+real	8m48.349s
+user	8m7.516s
+sys	0m27.774s
diff --git a/docs/quantized_structural_evidence_20261031/run.sh b/docs/quantized_structural_evidence_20261031/run.sh
new file mode 100644
index 0000000..a819348
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/run.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -uo pipefail
+cd /llm-align/duyimin/ngram-quantized-20261031/source
+export CUDA_VISIBLE_DEVICES="" OMP_NUM_THREADS=1 MKL_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1
+time nice -n 19 /llm-align/duyimin/meft-cuda-20261030/compat/bin/python -m tools.benchmark_quantized_structural \
+ --sgns-dir artifacts/native-ngram-20261018/trained-reference \
+ --gru-dir artifacts/causal-lm-compression-20261024 \
+ --corpus artifacts/native-ngram-20261018/corpus/tinyshakespeare.txt \
+ --native-library build/libmeft_rows.so --structural-library build/libmeft_structural.so \
+ --planner native --output-dir /llm-align/duyimin/ngram-quantized-20261031/results \
+ --orders 4,8,12 --seeds 3,7,11 --thresholds .99,.98,.97,.95,.90 \
+ --norm-ratio .99 --repeat 40 2> /llm-align/duyimin/ngram-quantized-20261031/resources.txt
+result=$?
+printf '%s\n' "$result" > /llm-align/duyimin/ngram-quantized-20261031/exit.txt
+exit "$result"
diff --git a/docs/quantized_structural_evidence_20261031/storage-controls.png b/docs/quantized_structural_evidence_20261031/storage-controls.png
new file mode 100644
index 0000000000000000000000000000000000000000..85b46032dc638e5b84358083a0068789d7fc047f
GIT binary patch
literal 151715
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%0D;jA!@_fjC
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%0Ddgqh`~ChrXpgD%N2t6F!6-Gruj=i9Ll=OWYiY#%
z(`|sU7f;*Z6`tN_`9?sW2$DLMr4;2-hIkJ`gcXc52+00ZNNcxFKDFH@ly&NITy>ve
zDyq$rX*~rv(pdZkp(AQG5CHi$7J*>G_-vYZ4;DXJp->)&Y<`<!X-wKD(7#6<<sn;W
z`GM+-;jzax(T&)#2xItxFzvW7M~4*b8p54{R6|G@=C%bI@|jtmJc?A}wQ63hFGgyo
z*%j0=9Rm)(OW!;@{T$p&zTrTWzHHZqaKscGT|&4M(v)sUiE^$yiTYHud*oqy1pvzu
zW;i$`@^Ts-LO|0HAiefR=((Pm)r&!Q>Fx}Otbv>Mh2Y^~E*F@wwW5XIHLZyJOhpB}
zR5sFtD6^lUu)$G|DKzEQi28>!XU%Fu0XI;<AI@AF=uUpUQ}gYdgp{^5@MRiJN8f4a
zqdV*xB;}fosf+{2OB;Y+3=VCjD7_B3KHJDE*6Ajh<nx@OV@L%eNLE7>ho>@L!>|W9
zf33iBY;?2$Wf{%s@o~E#VJK{#LTGyjDsXoVUgmiPA9}cw<JjjQV*mg!5a4_6o`jjo
zs0RX|8r!=Nd@nK$o1S{0UJmHOi54<pIMmVi{1zalrk`KPqQutc2sY-;A*}isUElqY
z=NL(e(!PWxPB0^%e85_g2czT&T&xT*r=R({rAwSIx)X`eo{pGI1{oH^ovl-NYP`TH
z%HT6ro=ix+#mR*lh(;DET?gpA(BS!0nx42g^u3^f@Y(!krSXUy#Q~TYoj@_f3vFT(
zv(^a#wmxspoIO4<C6ER{AHxG$r7Z5$c9cy=#l4r}t<~667sggjh!r#fE+TY|YVqG3
z7f<@?=(k}jFGF*ZLz+X7>T<vSs=we7{|LU!h4_b`4FsSAi@K;g>kEwq;=#69Ucnnb
z4f?A80TnL>o$nKg`=Wo1q_e~C4`uaTeICH`8R{V*_$5V6D|USU?gRMCJpS;oCSd@}
zfMXRwH435!ws+J5NkU8$>&le^u;`P`yva;Ppn`d=vp^pC=YP$PCbA!ceHuuUtGpi~
z0`Akt(O{^si<`?J5hZV%79-l#9_Eq~FT>$v2B(tyn5_OF-*hArdzA<z|0i*Hg<HV+
zhRn1y9k`9%$&bYJ9FH2xiXu<cPy6C9b#Sokk&-Z}=m0_Ea0NIx^Gi4lwVL8X)dNaP
z?V$IU4|5qh1qHJ1i+r4sx(`PWuG?$({T3^)T;BT;e1zVX^n^|tze4)GF;tCgQ9x+k
z&>^bP^ban$i-o{X<H@L{4?9gD^c1fzM<Qq1);(PdhZkXD(DPJ)p8e7X+yE}tiIslc
zyA;jJb#93uCe)|?7#Z`r_fG(RNbi=(SfYZ3k2HVaTL1mIr9R?3C#N3OWE+Ce32F}z
zsal4x5eh&N!+B<N6t60t8ATzcBN@ZF5pd;M)WT$HwMi{5pvA79(-z%49mvk+4_|5x
zz>95_i3qg0!#JH-hJf>(!3u=KQOA_hl>>@fkOJkXJwXouP;tg=N82)7ST39MCHHBJ
zO7a=eNz_N)SK#oxW5~uENTdy#v=FQf7cgEaot?lovE6<)N8^h%y@xbvJ<Z>sS`Tm~
z>qWwJ0r+BY<2E+o-(FH^pag+44>Wr){{Y3_1|SoDc*9`Vj(4{Y(vu=qg4$Djajtw|
zBC2Et(xZgJo%0B_s7igK9FytcF^WB14JS1AM6yi)E%JwyB3Sm4cEK17o#7;bsZhcq
z%i^{7K7U5=h{Fjy%e&zIf(j<7+(u0YDnoPt<U^3GGxUY6U1+w8ZO@;Nu9>C!coNs=
z#vkce1aA-g1+|xpqk>vY%cE|9NrAH@iS|JkNRX@29zz6NB4udG#%<2%kJ;0t@qn}6
zE?r@;zT{j{K3}yqA{%WTUuQaw=2QMC1y7VwIHbUyX@}t(fJ&NK5>#}K+{2;_>_Wp{
z0HK2XgCrz}D5pC@BHb8$5QH3g?!x7I@tTmZ@Qvc|^!D!i^vvcNS^AnO#qKFZKR^_Q
z!f-TA0Fm(n(9~xx<94J6&xD%HuuPZiy<hw!RYcMVu9XJCz=Z7Z8-<);M@kL<FiL)5
zbo@KIqrcOzsai%X1ST~mEfn*5%UqNykwO(XH`UkvAQX$VI-btm>)F+?B!AC^U~bm9
zL|Jq2F@j5QtV{7<81Xoc^Ow7JXJf758d}P+QY?PeXb5TGaWBN%x=RU$Rxfelx|`g8
z5~!PpKXVF5BjnA!(=8<)zsKe3xLp6fv3JAU@bo`a`KQ@`>CO5(S*D;A3hMHB5@i#<
ziNrE8jSshs`Kg`6lVl{`*pDE%eAAQ-$7NQUiCHVeM9OnT*uWWf?5YCfy2w5wxf%ZJ
zKIQYLfb|4*k=&<zBmP{E7g#%z#TT=x5oO_J%a}toY<rFsyBJTzq#gTZHnriHvpN=)
zd`1i&L13N{D)^#qKw3LF&mokW#vk<)U{Clpx=G?o415R?m<$=enAtRd@DOe#rlK_!
zC3j2dQ{pSFJ-?#HH{7-l(RxD?^MUmacFw<4357Nb<l(?s4?BS&wI|1{s3)rEu$s@(
z8hUz{)JSJKQ9BseOaR0vvW56WLY$aE_2bZ365B<CVEN4-qsebaNH<#$beheJVOkZo
zBQ|q#R$}HlEiVsA_zVD>r~xUEp#M&p?v=rZ3ct-i8FS)|%9x2eZ7`1;XjtElRAZ~W
zKeEP!2PwPt48`PIrAmEL&;?q_ARYXorFhoE$@?F2eFZ|vM3bo`G#S9g#()0%!!!48
zKvN^csx=Ep@f;<mTdM>KSN<;uR2l(N0dUrOGLpiM4m6oeX`qoQ2lw{9qP@R{UnNod
z)e~ZYIjauMALghTNP~^3cZ)hZ7;zvSdl92bgWyiKziu6@jG=P+XZ3E2T+3Qe=42m0
zs8|iEnh5#8vR|`+Nefr*kiqFiuPsuz$h-)F3ma`4+cd5~X0>y+dk(DY4Xtt@L}2RU
z@hBp}TDMCsx`<DQ5RhW?0U9>s8wThpfZcirQJpGc9(ecHNkX~wd+zSRwy3xFVo{gz
zL3VfSNplXw%*1grDTjUH1D*4yu;ljmJl04Ihrz716DA|&RVxv><k?k$(lY0bz>tFh
zI2SKkV5}5n{6LgwJ<=ZMC{9o^>bW<n5M0bhbe-4HZbV%23*IsM5wmzF$vKq;>q2I>
zbGrL9xY71>pglJWTrwbLzOt8q55Q><i40n#K=|Rqw24GVj)bHP^BkFlOxBPh4WeSP
zE!2$b>-~Xh=5xp3Pu(6F9Ag?UI?QBlWpzV$T}|apuz!#lt}%bUhORDE8HbjglE?cn
z@_udjE9@IN$if!>iq5IEW_77w1|<CiPl+IQDrDYZ7AVbvZ?E@Ao(p|M9}@7v`CQ&^
zW$W<x9%W)y;CraJ6~Di#uJ7)OHmQApXBZ}qhdG3_mM@|D#f`m2b3m%V#fD~E_L=_t
z`th|^SZg-!iVU{Wo=&_e2Z;z!nfpLxrtV@+>d}0<+AgmPOjs^&r}v85<tl@80ho9W
zYcj8l^-IJ5VD!Ifn9JNVOHj&*l4HrfQR|iTFTa0eM*bHgOm`18R3wBeB6R9|N+VGA
zq25MeR4GHBX+%d)VWsOg-u3^Y?Y`|Wr?1dDuO2jBF`{gJAFq%Rr=l0$PXjc-isbUD
zJ{t|wrc=)%U=HxX#DKoGC{A(p_t-I2L9)Rn#ovE@+NejlMXC5IMb3Vba{Rtd`VZCx
z|5x1h?0@FeW!NhL4elKo20k9rz^#Vjj|XY6f9GMmpSsuM-Q|_t0%!)gSJRV>leZ2#
zZJ<!>B9<W$M>M>Jg~hLD9Cpr=WePk)z)^Yglc=z7BO<<i{S|+sCk@?{%Y#}!bOucx
z^oz5ogSPqyG{h4Y1<>urwT}qxYqN1@U19n}pRd-q3PZd@{djrqnEomX^Nhq|gSR{9
zR!(ffe~){EOhr@lq?+F6oS1Te>c!^QC^VQ=;IXL?+6@2xuuA@4-I%Q}dqJB>um%^m
zmt32TH+gV_<~`j;h{|AA7M$B&_Wph4+Z7hJ2&k{H>`qwI2&15OdWA#+^%P5AqSc^o
zj7D#u+98Ub@_t>GlfN}xYsy}D*x+O#1#<dmrk?sJl=*E?Br?Z|9p27%T@7h~I&mMQ
z2?AE+1<`O|AI(=sB07k`@MJiPhOph3LQSHS-=Sr1Ma==KbS<*>E#S*?;70<;M%GO;
zRMJJG&|g>>ZIllxg`;|U_v+GZkHUq@%&ba_@Xh8WY!jCE_IIP;;{`rIoq(@i7Chhy
zZf>7SX}EZlDk%FbHN04+^@UX|<T{3$(J1Cf&ZMv~9j&qBx0pv~AR&*+03rzsVNx^D
zgcmh0m{E$7o<=H-gt(SeZ}{bcS{nDt+rT%{qKCG>eGD@0TlgYD-(pZl6e0{qV39C;
zo=amf89GF~^H|{>?~s=>YG!#sA`M^>yNi7ih4I#W`QV+!d9=^=X>}gT=Ge_E>yxMQ
z-Csbpur3Ufm(Qh*5D?pdbq!#W(uzz`$(AB9;;~winC@^0Vy<$;IEqxW_^P;5Y$+!R
z*%)zsaYDCq>d`VfSA|EN<Wmsv%<CXr!^}&{c5^f_6dA&x`^bN0@YhW7$m`jzg58Zd
zjasPkwP+D^PQj5h$fSOW>SJoL81`@Ou?whp*x=cQqufnYpqnO+!m9W$W_gqsp6lQ&
zbTrMO|3O*_Tyx9ElT>MrgVYLEqXTE3KM)l|0I_onmsGULPko&=&s%(K#8dTKV%Vti
zbBW9@Ak0M*I>SYc)mhhundtNI>kh|O%QfN`zZ3f0u*7CM=z!+eSt(L{hbCr5IsDjh
zUj8B5M+Ylx0UsD~A6aqP5JuQqChV^AJXc1Pmt9U@)Bni4{}9HZJNKd#d~|N9>)2wY
z{P2I4S6J^s3ULsd%RAk<A}>7q^6K-=H>Hp$h6kVTn<&7|K)F(?#jg-l(Y6gXChc=F
zovI{!pZ4EgxMcCb4P6$eSEo3S^B7)|^^rZ0Z}QXC-8Xg0Rr<iIE?(Bw`}>OO9iHr1
zx`0(T*Mxmf*lBkuyH{`Tz-Hry)CTTVoc%vFmR%lOtm`4gKHbYZ^@Eo#V5HoB+2xBu
z^Kh-F@^;`iS0-@nSC`+Jo;Rkru+W5k8sDX;oo^qyu?3v1Vg^caVkTdDi=e%!-yzoZ
z{G^X%39F>e=EhfDZF?P_IL}L9uj4h9kJ)zq*s<0n4te2WZyKNXHYE*kWvXRgt}3+e
z(^w~I4SVJP^Y?FZuH+oz|ErKmi{X6E@^SOJRLn`QBaW4XRUH%ubB$-toXLYNfBfw|
z^qL}70KaZlksNldW&1v+^F;F+tXAw!S!)+4;2){BA`fn_LiKDPXTywx56Fyf48lM!
z8(p+fzzMf&#Zk`2VX-RMHB6s&k8|>U`95mWe!{vsU>SJOSU5(E<0FmZ0jV$lciCeo
zPcL2ys%4naTc!?@&YVC#c%xGj`+g5n)xMC*Cz@5?*FZa}MrQc0>mM=Q0g9@aqAg}r
z>7#D23tGJZmPvpJ<cJUn^nCz>qX90*fys5pSJ4%E){)%^!oqgHF)lHiTV&FNy0R6{
zBzAeBv*s?`Dyxo{t&O+oKTm^N&1L9o-XoP#drlV6&qsbBJu|I0(N)q2GowGR)bM#t
zb5}uJG@t{LD;`eQ_Kl?`8ez!std^R;n60sOx2e-?9zi_Dt5xsu7)KZDY)-93f)>X6
zY!8iC9}6*K90&-2cYFF_(eu9^`^$Qp13AE+3@wcgfhN911OfK?ThC#}RG7=W1i$~R
z5`n4XFV`HQnYdqqD!?9?!b%Ua1-!?cDah@9F&U%Qhp}D_n$Y%%MU1#bFm0^r<A6G5
zG&jnOVIRi;(RQ{`l9a(8S_T^y2SZ6P-yv_i!2div<bMIv|EsF`|L@e2|MkJMFFN4~
z4HL|5TK#lCodz_Ddrk-pxsw52W_z^vFFF8$j)$cA1e)$!Ep<tYMu>Uk;1c_xDGwM)
z8z^Z%bm)Oq-zb4V7-JcaJbarbSJ2v>LHp6}@(kLmGWb=ND9nT=Xd9dL6vV0RNu)+0
zIdtu7cQ(Sf`yX90{7@B($3p6FYv%iq&JT4vKaDB$D_|f;LHwU9{5(8)t+AM}-Hf)C
zM$p+B;bQFIbl#&0X_$cGQ?Qa>E$OTdFHj!R=RjK$WbNlR0!#hilzB547L8~6k>*-4
z@*q0HOdZ6EANXmjShic}&I7Ajk&C{Vxq?Y0wcX(7)TM!!MjTph>}th!WwCdHJgmqC
z`Or{IHqLhx(AppN8A9qP>k=ScalByqhZ5%<6sNin^yU+GsuwB_Cyzak1pnF%y9!S!
zC<^o?JDASYfY;YU1ltE?45Kd!kRCZ9lOY`q3GOk&ITpLT6hK~eSN4CIwg-~G0xsbN
zr@E@_##Zd-Jh#KFE}-0R-`59TfRzhL1B^}irH2fY0sl(stXj1mnrjx^{i-wl&2J2S
z7O>Q!Pi3A+Le^!B`3+A#o5Q&C6iW=YGC#4gkhjV~yu*v6nkmk5CH_fy&I+eC1!|ko
zbCR3NrepWqeu=&gEhm8)N|g7`p<o;bHH`d%v(2y(o3v(djJZDN<Fq;OOz)+81NY(w
z_u0ir`+?nQ6`yGe?5o{6m`}~tN4=#KC7UcRkI3?Yp}wVm3&~ZKE*M)OL~25S(MAA7
z!O~Hk{OZ8<*@yV~Y}R$6TjWKjn5j7S884H?YC9acN-y#1$<L0*r3}`e-V39q2^@$(
zg@O4J-jC&1%}A`aDd6L`UI4~{!v)yZa<~i>Dm<Q3t9k!i`JQA_f@7+<TXz9K1y(6p
zo2FYVW4SDp{UIk3#d?sdNnH(&Y-IC=6ZN&LxhzZBCS-2yIGzHhr!<%G<k|D)IXUh2
zaOb=F;z1KYq7%`_)|L2iW{tK7M`@?3)q`$1C}#6Dx9j#k;C>3&E@vgLIFEd}X83bM
zcQk7hj{DnBp+EbR-<R~}fMMR;AREziwY8-|qF#5KS?chJ6j+_}JeCdM98m|S-JYMZ
zAU7dQZS~{+{EsVe5<wOD+{z|^l72v51EnL!9QSKhumAE<+#_2}%;-3Ds)2j$g%*@D
zywahH9(7GrbddfY=YAz+xjJWl=ladsw`TNyOjYLO|MtlfeW5S%oAQ%zx5@-vUF<#s
z4jrPtPdq%l2q$3(Wx~x+1ai^xzjYUg+5WYOb!Xv)+iQ*HJWjsnRXu+N%V5&8-V~Nz
z(zH9yQVU|}TS<LUS|0<Sx&V$C`5yj>s#u@|R8#W}&seY_svqf`B_BAtu}_>vVuF{!
z*8_JfjC>UNhi$iI^>mc9UV4=T7o+WI;V3A}ZU2fFakD*J5>g`{aZCB=$O}IQxUbRa
z7z?WOSNEIK%&nCaP~)hw0JRC0jB<Cyo_TZU22Iul)+tplkWbnkTvqZ~zGr+c-^dqL
z67Coc-uGK`+Q>vj+Aa90#@|M&H?ucgdt>5fF%&u<mO;8Eo4I&QQQ~i{!ga1mVAqo%
z6A5VXf+X5rt&fs*un{@2w>}fDqkzidkAHp^R63uf!{x;0S6@~o_$60ITzF!hsRr)>
zK`%pw*M|$HFACLD5<kk`dHQ1JD7q-Vgv(cs$K(KYHmZ3R35rs(tYgj=nex?}GN&b>
z7I%F9W-05GNu*}}w;^qr)E@{4y^XuV*?tVpbUt`5Wu9AJ{oiu6#W7@SAwOjDm_yoK
z^vj%-^ze-MW4I47j#*IW8}+m#$t}0ZQO^1raaGOv>#G%eFK`V3tPQ@oJiXBnfJp@6
z;dibc>6I1VcJhpA7}X9x9Z!S)NXbxFAhhB`ESJj@_?Lbu{vxOE`UJZ6^E!_~xWBX<
zCqXTcT*JSD`1D`QSM(J{KRWcyVa6e);i5XYI*e)zPn1uW#zO6Re7|2V>F`PGkzE4O
zP3F%}n(Zb}7$2t_VK~vqC#e8^fd7%8)JFcFy|Rt`w%eZ81LQ6qkLcMD-y1kKX5^Q1
zDavhFXEO$h1fIW>oxXWTaYyH+SHyG>emT7a#rjD&@)sO!YpXJbl#Qm>@_BOjv@y70
zX2n02wm;<t`J|uP5$6}lV2y`TO$N!osA^@#*YT*FoSY2_QLeS=7RNb<ax;ERXANET
z8k^R*aqfGfVfE^-P#$(yTJjkV4a>SnRa8r-C_EL8_~>wWnkMoL^+V5vIldMAbk91<
z{_EX?D<7WkSODw?-O#qGK4`Q9q4}Dy{c?Ru!AR#usa?bUv}Kd4E#N)!{9Qq|c1)SH
zf>_GEDnMmh7nHwnvH%O2wL@cfHA7eq(!njj29lu-)C7Ka0i|sF5P23v<%B_Q+VWF&
zEd)UZM?vj?Csaws&8|VFK4(U_nd2nQi*>K#y9o1#<k1YksLybSM#U#YbxmyW;tR`!
zQTirx?Y3C^F?_o@mBEf&7+Ef!?trwz@I7qo%BuvxQ6xk2IiTSPEtlr%1Zfm&7l59>
zU>DM=ZU-;knIwmx3P)(^OtpP8t1^bCs~Q~LPN`~N7|ENs+gP2kKDs(_*$flGmp7}A
zZ~fyqe0$>D^z;8dG(%eY*fEcdc27C~{Bzd&rK_Snj=NVc*!K3TdB*ghS-5Szb$dmi
zQ%A|x#&Pld743J^ki~kFPL8Sx?>e`u&f;LoImO_ePe!WaGkU&pk7H6tU~I)3VJ+)o
z(Km_u^*^hs4ZI~jN$fmVvbsKgzPm)hRKEIm^x0PpZtjVCT5ngoXBB^@lE~jE@yZ=k
zJ;-n<G-rj^g_Qc_4`}!fV0C-7aAuc?bqU^3z1nm=t1~J%-Lm?OuR@)AH%3dZPER&Y
z-&p<lp|@muA6AG_=9TFD%)VC(q=We~-|E=c+xDD;V~c^b)Weah*e)6U=Rd!Q8NXO@
z{0KXZ*$-DEuhx~q+v;(x>S?>rM*O=tMkGK<G&q@eNO^tcN7JD>0@6lc^7g7N)tj!r
zHh%o1y<|Q}aovx6i*&1_#k@`~{<QP$jNrj{8@vTqJNLa5`g^IU+V^w4+2dw&q@FP5
zj7Zmzf$su<8^TadOJ1b|Qwt4TM_#X~`^y$!x7q34-=Ds&d-><<PWznkP|b~p>aFs*
z?EgfxPcUBa!!n<%Bcy5h^PI_U^U!ra8>gqLB$6xDG}G4RT#qcI-r~=xi4LigEaD=D
zvp0_o_v$W(1yry}@P*_+r|YBq0{LkjVO{MvZm<vjb0}zg$?k_+0bsrY2cUBv2%*#U
zCaIRq0<)Z|=WmWX#=CF-iSkX4LQX74-4m=i-jk8wWa_7?_VM%~kBhA`5`DR|;4(dS
z-Y*=w!D6#)5&NoB=R#j;m^@K+=m@p1GvE(%c;IxsmHW6o#pROz*VQB9{dsI=;%2E|
z=K5>B(GZ7%e7G9zNe?VH{`9+=w_r%B@k=>?g#)Nw7XX+Rln>bYlJ{M|wP`r;&-3pD
z@=!Z!xo1hK0W{lW1M=PiO23RmRL|%7w>`P)r_I@2XUI9u{#R7aM4Rwcr=GM&TlI1o
z_J4oS*m!923-Ax25IC6k#C;u1aGiW#Tv@KTx0wA*UsjETFTaxAwBaPXZ9YzdP)$W)
z7qV#OP|8wg@zz@h=fk?v&fxO&+}+#z%uAL(ct%Ro(GL?YJ`9l-J6KhxyZ8*c^X4xC
zHh)lUoyWZ6TU)%@E!Rw(|MT%_*TpMDBA&JfnHX=0+nQ%5^Qtf37>XGCZL`1Aq2$lE
z>gRd9I=t#aMAFl+dyJfDHjAF8Yi}tGBN%hK-t3pVccpL=t0hB@V{_%~iB%iaE4ci%
z?E*7;p`41g>fLr_WOS8z<`;KuXYYqM&n&dA&Vs$&%Gis!#ES<2@BRXp%6}HlZxMW^
zpb=>2x63L<{EU2bh3Cqnd#{V*pknsX>&=|mcu22M{%Sbj+7{rMDkRm?%s<EDZP1B6
ztmQi-(FC2R-OEE2*8+0B%op%!_=AIO2cJVGV6&6jrZdjsL1Uqsg)C2irF5*u9QKmg
zt7CV&$P_xjlYc%NzoLzIsCCI6Tp7cYMoqUAVP>kY*L6DMa|@5<!|JyIu&Q~wKK%H^
z%$@v&3jldtSCHfB4@-n|Ua*<wRWDu{4@a2sYJb=|f2OBe=*BD2;?=%?zT7IzA~I&7
zb0*#@tPWem%Wlb_ru1^ZnkB>4221RFA+SE)w$1$%&*o=~m0ucnII~Ao3NK$W5fsw7
zd)Fb$O4XC>lXVZC5k*-N^+oVp>~cv&3;$J{ORk>aixvEi2K~p0FSrwSU3$ygL)iDd
zsfm7IHWFFmz4WXhD#HDU43`n2<^t#4I2F<$%@g$haCDVnQFU7wkZ$Q1dgum)LAs<Q
z1{fri4k-aql<w}Kq+4L58<B1#1OWk&j!&c%>AHLFZ^Z}C*=Mh{-dbN7{eZT#2kho!
z29Z8cI*|YD)BY6SC)?}S^g#RwFz6MpTLDf?_e?`Y(QyBgcEQ*rzXC|qalknv1(!_c
zD$r$oH=Y%r13r!dkWW%AS#>h^Z*6DJ7d`HkcXLw>0=3+M&lAzEbhDRj!*!cj@d!H;
z$I`TCHMO8J;PO|uS~m^-3P!IdIqMkIjJoUrw<P0|dml*;sDk^KFVHj6tV`B&uLaIl
z5FHi@@Dpj+Zh7$%vtwfPC!6;DW+EVBS)IU{&;NHC3cPErodIz}AF^LEJjsDgop?FO
zWIuHNP=`|c%AXQY4scgOBe2)ZDe;@bd*+-1|N44M&zDWJMm;*x`&5;6gACCft`CjU
z!o`2sXS>p%ul}A-zpEK9An|GBCq#QdH|h;F2Gt_BYY%W@!g3KLG1`6Jf59^(oilTj
zbvW|_=kj1l9w>BT0!{~8S%Bm+^kptO9s5}A%0`v!4BWF53+3lnM-K8J2XrFO1V|c=
zKui(h-*IgBiPs9cR%9l4DpM_T|0ZL6*;?4(C;=*hq?d=yz(uayQPC^Qx6Qy2H4pBy
zSkbWZy7lW@@Tw52l!VHd0dTSRV?ZuIRt?5lOHk(#%w}E-cF#rV%6@?&MFUv5@=@!c
z`?235zf<l#+Hd?8qhl;(tVI@yH@E@*qeRU9|E5;K7m50N4n9YQy}BXh9&{&zb+J|#
z0%l-bV6`Wz{<Mp-1d|cNN7L?}RS;77I@|iWJD7hziE^_p03XAni(D-t3%@_%SJ`*l
z*>1a=XZMGV!Rmvnye7D9q^NbgF96JcZ#LJFf)s?G{<`kU_;5*dAa@VQp!&6^yEk0R
zfuXhpgb}~yLX^p5ADjb3AQbWR`K(mX*ar}UY9r#l+Pw;Lf!_E+hi?UB=b2%u8lPAz
z*1^wL{DpaOCLnT3fil|t2>cytS3Sm$^4Du*Js_d_XBV(#vY@pc;I|*k1>5AYfd$`5
zkM=XD9YXIh7rBrBfM&NH<G!=u^IYn~)(ui{F!|)c#Y@WkZZ)_-i1kQCkMMz!(v09<
zJ{9**@EUpmN&ZpBUL*QkiMJpVTxC-q&`C0(pgoY8w+tm&>WuOa``G}x0&LKk!L1SW
z#=!5>;9YwR0$;nHddH~{Q;6|&{s%z7qp!+j)I)?UOd4g-tK*!eInytk*k&FP6GUiA
zlD-Fw@FAaqE(R9vHR^6hc6qc1zQL4}DR>uQ%bT1F+G$)+7T)A0Qb+%UVnz|_t7&3d
z^WqXXUN)E=O1A%3MUnnp(ouU;8vXJ10=eEnUaU;lAK>MrvP%E};w~ci?qlgwYX$;&
zpR#kCCh);YXF^y8?Z0VDzDWdoPMdTd;YCAyZZ8gpocI0FTgAW+L`;IYeD`1leDcO~
zD}C>#BtaGTp2-pg5{|crAllEAhr3bCYI)&Vnv7Gxe=UO@Hsk!<!x8aJ(#^HIsE?mk
z)X3_1Dn!{-e(f-eUCxzF3f<m-o8_smPzRkiL^?vsryCQGYVP^lpL~<Q0gjk<8(;ML
z>r)Wf^#L*HG(i1SU<t^aX7jY%Oqo}}F@Hv;05!-kvCrh&hYNx3itn&A-TVTClK6P&
zq-FySlzI+~K<jOx%@XX=u{46O#3mYR`6a;!;3=p@_YqtoR3H(eq5f{7l)#j%8r%xu
zBogzi^*2TpX4&XFL6!Fh7<@BM&Is57f={{T^k;<jQi+6G3l;@IhIo#zU&qND|MhYH
zoxqaU57&bg;FIQ++X0t^S53>A&w4cX>yKL4zu9*@11no~U~6Gc$Zw4*&(I&L#Zec?
zLV6kZPRPdoD<S38?D7uyfaZ+1!aNtavR&3s1x=08Qv$CySi-@}nT(%(^+j-}WKC7>
zbjee<MK0~fpu+l%Zs4T>{4YApO!)Vq8H1<=t}Ee}5p=@<+lUj7`MnDE-;G{gsXQV)
ziZxXfCiSeOSasOw=T#Ht4e;u}uV&~=qVrV3=u-38C+8y`^E=D5ov#~o#W81=Q{<(h
zF5o)aShv@Z=f(O0PDI8PJzi>Uuol@{$db!8ne4wLPu8zm0(<W3wY|QOfb%s56oWz+
z&o<dv%Z#Onrvg;r^X2YGZe}@E3FQa{Aw|NFqtdW|CV;&>D+JU2fRtU&4I1a@GYAdc
z0GIIgDFsEk=1+(BH?d*#q-7FD;0E%HexMZfw-@p+_YHQj&ZA!?y`n>qjZ=fuc6YMJ
zAwqL^*=<^{cvr4|hpt3YW=DUITC5oW11@g@^%b`c0zwW`m!e!%Iq6~Ea_K%!ls%pA
z1+@LovwvQa>eK&$gyyS@N53mKTzHdNZkNBTHFAh<08aw%GoN3j)hiY8cS7xZ`sV;b
zdtmsmdmCPn>oxyA=c2l8JF6E|5ktG@r8^&n6FFIbf_KAdp=<K{aU30d9-PovOhqKY
zf1!L~Jo3=XA4`40UjY}`3*@HHWV!%M{AtnosN-lJoS2=EVLx4@)4BhJRDeF#ZP5dQ
zJ0p=E{{ai{QQk5tU_d_z7&K+t1{Ft;tF;3>&Vwt^vXqT_;>)ZXaQ@N3yv_1JU&p?_
z3w9aQngl!d{AQqbkk?-oU&fuw=8%B&oj=Ii>cL(xhwL6$fj(C2cA3ThUvhRCl(D9^
zmvErX2aF6E*KZ%<ZcpU?p8Mc`x=^-x7(cn0tj6r&aE>rCDW${vydJ}^dE2fMK($KS
zMwW()7eGWuF?`0~ZDJ^(a5pAC3AL|Vm+4-hjc^&M?bF>9cd3j?9gU5bSRDT8S$_zQ
zQT+O`d(Z||lysa(K>C0t1qQBuD??Acnd*2?Fw?~5DW!Qi`NX|r&#I<5RC>h|YdmVR
zqV1fw%ignMZSkPlHk7U`s{^}EoDlIwYY~{7P7@%Y_Gbs$AM{c76nt=xR3l`_UoTok
zGR5%GdEMW1u%J|$i6_xK=@{=AV)m^Bjtg{}Ltvd4cbwa?aR^5=Vy*8tQ2wSFBZ}&Z
zE|)`&-Y$8lO-XQSB#4U5)|7{R0vF7jtPX2zjg?sxpZlpbg`CQ-TrX&}IarM#WSoz;
zU0@MCtg3Vd#A_CUnZ~Juj**{m&LrLb_D6H){Wsx#Yka?!T~zrPwe5b&73>%**j!%E
zytp`II{0ooSd`%7(HgN@1!{>pN$G+8wUo>3*_i5fNzLO>vY;V!pXEfbGA{?kIzQzO
z-WHkH&<x=pH<ksl6BBQvWtA|)YyPSHLB?~S2(19pyTe@O9<M+Xye>i}bEL4=akl(%
zpv-ki<SmR*#G>~UcOz=u&Af|q#I5ra7H#0Y`PTCQmGK@)4Sk82FIMU@TQbRb$oG2g
zM?-{+XJA}3eB~%8I;%AExL2>_HJF~ZedO2g(_9_b04>eqTT(bZI0u<M^H6n{Yyna|
z3Eldeo9GqLH1O##arsk$aubj?fT@<pLt@MIvSD0eAe>PR%asgBCk<X#P77fwM`|w)
zS_1sAW;+Z6MRr}so`OiF`9jL|!Yb*ft0M8Xsd@Ah$hIxF0gjrN*s;M3GwDy*Ofy&j
zx9*n(fQXL}yZt_qTo5~2eTKe#_d>2=u7HmEy$M&{XX6QmifD=(MQf$8r*&>aPeAq*
zdVG5JieW?_Mx-|!Whxm?UK(7Yaw<wyL`-@It<1EQj@F0%J%4ordtH>{Rr$U1IFgV8
z&Y*tEX?1@n#AD9Hq0QFZ)F)G!j9$KriS}tKr5ixOg+yE?tpcgG-Y$wJ#Qo6Zui8Ag
z0^0yyb+AlwkEGHN89rRc7H%>0wt2JY59S1+VOxz3K%otv1nA0Llo&WW0}*9|s??!Y
zTgd}U4l%B|h_I_ifQGTw7Zz*ueg~e<^8x}+hB=e%Osp%VRI+UsARNn09HaPI{(zIm
z&RL`rBfy>zuJLMMUcP*O-c#@E{Zh<8?&z!e^kF|U*4Tz13lYVyE6B(Dy=n{*9;H#^
zPxC2CBS$R`gf*Xc%k-T+dG$<RfNexqEf$h0mH>w5vrfaP*hS^P?JMT=ceKtHKtM%d
zL*OAY*Po$>F9)!IXG(Q5^O}7tx2G*mg7dX!(PT%SdjT^x$3eZcf;n)3t))L;wO_`6
z-(vI&F}l?IL!Jh>kw6~a_F~$WQwTJp9_OfB|A4L)*ZaJ4!?HHwRp>UE38-|3%p1cM
zZCHN{d5Q!ie`s<d!9qgq<_96OMAS*8Vr@C@Zf0<XVd8D(Z@xb>hWmSBikoJ{Hj1{B
zJSOMK_nPv|Zx?B)4Jp!s`><?6i)VEe8k&UNaMH+&4qO=aNQee0yXy(bLT+j16=eG+
z`BvV1fBqZ`W5r;B4hK_BYgm7>bz0#lnh)}WNP8i+Ks4Bgm2H%4FD1?gj3n)c9tSFl
zHBVAp;uv+|3}s9dN9BCy)IXtFnwRajQv2#Y>wYg|yqixo0-A5TO@dY_s0*M4_g^1<
zm)p)IFA7*Jpkguk0j~zlNZSy;r3sna9y79dPYN1jcE#<ITkaKr%{s28S!)5F!wYd6
z*W6aU27;@P@T2-(`eXTx73f;N=i}7;c&PPpGR5lCFa6WXArb`QV+0frc*bf)i}V2S
z^pda7jrt)bj!^0`o$xkYm56^@HHf<tYgy0W2_%wOR}R2paAt{i?ktKnexw&<p`w(A
zqw^q6#}iuni#>&MVw9aSZFx-wFOpo5>LW&>rdW;?Re)f2GwRHF2uNa{Z!<;`=b&Ic
zznG}y3@tIfy&c_jbKf*^Q~i>s5+P4Gn0u>_B<3fhQx0H{A8DUT(VV3}nQT>U>u2F7
zeoh(<M<R;qlT7v!sqwr|xlYoki*6@OP#7=nLXUwT6{QRJWt(8_q8MFVVr`$C#19zY
z9Qxz?7gZIt>zd;pqzk4y#De=I@FUQ-(Jq5`H-OF0H|R~`#j7aNpmjr|F9*ft8Ga`B
zUihD0V_W|jAmxyM4P?V&=;igsR6~vchsS?2rGj6QT}3!m4Vb>48p>uA+2lpH-3v#n
zp=4hB=X%Ok6UbqfQu7OdY_;*J6YX(Ky7dSW=|65dzK8r$e2rq4K8L~;r4Cv*a<ZZ?
zM2iWNYc;f`!dK@2US$4HK823<`vh6i8wW@+@}bIp;iqL`mvtwA-5V4kw8}0s;;i`e
zz2H;YX4p8VziFvd^ni<l`f3{FictBQ#lV9s`mGgxA#c$zlBRQnRkDaidTsH{rPkV4
z1Cdg{_Y_z*s!fs<GjKEjC7Woj2KGZLr41$7H4X#<(T?49V{c?14)tI_GfKk+b!K;i
z)t3gPB{m7HEcfbLr9QzU4Z}`>v0mDQm!w|S5Wu?%`MO;gI)S$KXYwS6$P-p1HpV7o
z!<6Xxs}asO|3(;D=K5YoGI_b%1j|x#d&U~1?Xdsek>3CB#|s<Phh62;NmZq@;a$3~
zZm)*qZwsx;9lm~w?oO%L%Cteae%ob<BM9b}cZ?_@Zd#!z3Q$gy91v^lwe&Al=M|zK
zI@Pi5zOm*+YF6QVSeejGrMb4H>Z_fw4%L58^PMmXiZOU^rBV31&eyz6V&>w3jHVlk
zEeGK56T)y5q}0CA;!`;x^K)oaFD@977hVD(6Pmr{4y!3#!6Q^Bd+QFGy~daDpg>+c
zdN$G&Kwt<i0qtg+d8}WBAif8Eye0LT;dd3O7yBN3T&iM*Wo$NCPj937BpLa!PCSgm
zVTzh8sB-n*+B$Xv6KDenyMM}i4hG*Do~ug$dU-CaZ69qbJ;LJ+=#&Sw_#rkY7Bz*B
zq~{TbrOKc`GyapLVOu-}A(UqFPD?=@4+%(&HL?OpQaZ~?HFL_s{E(Ru_R|y*^*lvj
z_=h6PUp0b(m>jAS@(xgfZKh+ZmJI>ZV_UHDfORR@fuB0h0Q@`PEorYaz6mjr-WUR%
z`_Pcj=qD$^oOQk&;G5mg3sqi<+_XA1$f-8$EyT8;zGY`vEJ91$a}S-0f(GADIpp4!
zH0w^UuZIu`xs$RXgW$%LO?ZsBBh#SS8$!@nYi(}<VBrm7MZ!p(pg8?Ih`Dk2Uf$y3
zXem@@!DfbzH=a`$4Linlz+&W|YXH_y8X{)2s<lX$KTJJ)63R*uR7B>>3<zVRoIbeg
zW0Gx2K6rp$=3$-ef|lz~3CF<X9AkJ2w%^2=gpr5q<DQcK3t8M-X{s`H@><m9@9K7)
zzEq4eVrn+Of;k_4;d330m_KG*NOc>VBLLJp5^G{a&&*#^VNE}_1%Wu@OmRDqKrmg=
zP^P!OW7%Wqe0mi&-Q5-^HQ@7@eZb=G^7~Q@TaM&W{-p*TkBz(e>J@OEq=Bk*8HaVP
zC8|!nR#HcxGZ>g>-Y4*2xDycjK<0crCjQgYSSCrcNNmX`|F2KZCpCyiSjj!g928X9
z1>jGJ`fIfWNT&1WDl%9{&qnu)Eh#!U-4u*rzVYHmcjhgK|AvMB1~c~9NjoFaHWkTJ
zoNuu_ZV24qC*m#uxIeTGi5r)OY<ZyQ*%=}ARV_7vZw{8E-ma63(iy=uA69U_*#qq3
z!H#zdt_mW_?y<Fmj1jh<IdHy?wZv|ggLb;SoUc#r#R7`U-~_B){e4OVf9$?|j>&6K
zI&u%O{5gTu7BVj)<M2hW<#ie>da0_jb7&uRdjtjv-Xd7E!tX4L3n7FRSA`6gENHlV
zA=K#qoF3Bxt95wima|;>3#ws#Wy+3s#aHF#w_pgTo^Xfl;`7aaHnj?;UV1hXJ5pHm
zb<m&NvHNX$3J<pv9-q<}K_JuSinp(MmL{WvGS(y%zYic6OOpiZv5Sb{digrHFju|P
z6q(wUqesiJMv;}CLADR%55az$2+b%lC8TwYc?W7Q1^ewWmCd<aR*8g8j(FWe-k4rI
z%^%!+r`}AraICcREhh&2=ZkFfI)9Q6YX(`eQVs9pu9RN9P>;|$PO*MlA1NlmHJ+Hy
zFiU-{?CrM|?`jU8SIU1AnAlI2{@p?fcrdM-0>JPSJK7*|s2)Yxv;oS%8x)OIHg0<(
z7fybh76{CU(TLe*bOj0nzH?`SGuYDTNXW4_mFjhf?wqvge;1uoV8gOXpEBlcDHX9<
z_Nu@E<e7*2_P8aGy*K(M-Xn#vo=Ullb~YwFr*npRtIA;GNI~XhZI1tKUH78!HEN^G
z^i`4fT_z0gdhZ9TprY`Ux4Z9=2`r0a9WlDpD*nMxZ_df5&cX4)1N(l(y_VtHoKB<(
z4;c9m>|8^Rpi43rn<;h2LeCWW>iZt4sb*EF#+iYnRzg6z#a5m_2_+855wLO~#Z=gK
zUOuB#vW<K=wJqNB%=G=L9tWc=*>+<wmVAZM8!!cz+kabi*VcSOjq|iHUi@2^Tc@(j
zWM0H^_uOyjkPD!)QSsEYgwpIk*>)4jg1zNgGh1SCvsui<pRrjVlWq~8$W=)hx@4uw
z5j>bre27q86&OE{OnK>7mW#A@!VNquFI$jdUsdjoCVZ&%ZuDDq$fmbxuL|$nUh|Ka
z2RG^}luD^;S@YZC%^cAi^C9O7$GB_+mw)9xOC$i|Ky>;8n}VZ;Cp$wb^<JgrhMg~$
zL!?X<S=D^p?ko)dRxO^I&``fe1GhZ@Ouj<P;)YXxfv=W>WIXRte*=pESiP1zz*N|_
zY+!g|0v1=y{8Ss<2Lp7~pA}f=gLQRyRl4i)6qfM}u@>Q$^%zK+Si9zGme@wzd;(MM
zvjX|*;RY@~>msW{j5~e&U=s1vm*CqsecHXQ(z{yJD@F>TP517P&~+c=BUbrL*&WAm
zz@*5VBTpy$Z+~OQc61B#g2_B%rX4@i@V9fU0lr3{9Zgwcnw>4j*?3`C3|aT8=t7M?
z&Zg@!TPEtB^|+;WeGm>Zb1Tey$mgTCq4*A8;7;5um}9s3Scypkpbq4z!fDS$2sy8-
zU)^crPto<TIm|MRHGO_{=rIur5KQ?~sY?3cNA<V{BuWpXx8I(kEa!|D-7||x)JU9#
zd>!)si0>#Ol}Ir)U38Ek1h4NO72$o3!b5OtE!sbWS(p&r<CA_7Xs`2G-|CnYfs@RF
zbqK}qB&%2#;+8l}{c0$__jx=smd}?ZWs&>-2SW`OM@?U)s4ScMDJVog`8gv`w+PE~
z{S$dU7O#ZT;q3^<mwK<B5jMs*S<0QZ<9Jp)YNqi$U#t(&4jYfzwLt!iL9qnLEaz{+
z1}Cn)*_ZR}dmg7Q%yU=GvZW2>bZF8iwRo!)Sj-To*bcpo&#!tm|Cysgb2E}g%qUf1
z^{3mE3*qxpr|dEB<bKE^2;8hNeuOUf{UIP`NN+>olW0{-dtqMu2sItB>I>dp<#<l;
z+9yQB!}+wm<MQIYYXcfh#CT1XW@8_%KrCg7P-0__%0cxrUB{sJ6I}3>;Hnh6|EuPe
z%`s`HX@95yRmTee-%l1bgh3yCF+K66V}KbMJ%2Nc{Au+2Uc9m*K0MEoQo{{?-1cGO
zUQU@~k3C;9!UIA=%50&C={u7{*!kQE4J97@k)dYU1|SK#5^&08c#QrqtE~$WqZ%P!
z`T@XwxxaK92vnF}_FL$^*y|+Q@pqQ(saMZjjuQ&PbG-hzFK<;o4)4Tar(-12L8nj7
zn%nI2x%Z~;im$qtRYl~F0klb5G@`;1AnhH{mQ<P;$Bv(_FP(4VBaY=T{ku$mn0Dv+
z>{iU?$-n+j?~Kmk*iw-G?r%m{iQLoM-D}UFQw4amP`a%TC?2W*-oBFa1_P+pX<j_e
z9J>|_6`S5Jaad%iGf?w204u+7ML#xuWT_npI1%j#D)PT{8s()}Z+Mr*-56g?)f#h=
zYf+;)I}wmVdFBs9eOiC>03U^K1h$K<0+x|@88l`6JJkSz;sg`|B^nfT|Eh?G1GEFg
zI#OFyNT;Pq^cwQBCeXt5fClW@)<Y0u_~B|1bRW;Uen)X6;5W}(6P-x|FLUPk5@^Ha
z&d1#XQjYIFc)S9w0WOfJkuU@J%X0kT_sY|AG^W~#<}*02a=G*UUVR1Hj{;y9;`E&y
z><9AJgU$m$NFf4l0SSVG?%G5^?8Is$O90Qvq4hEloCyC1SY3@}H^&WtrM)^U1DJGA
z5azuQfOg2C_ci+N0eI=H#diQ+TefYbfBgFiz)k}10J;{6hU{$f(YApe&WvXiIUu2f
z(^r?RU-${w1m-V$`CswJ@tv&NwFt&XW?n!E-2+eriv0Gy`Y*U>Zv7z@GjNTP0#>2Y
zvN&FX5V*Z5J_Ak_u{Q~9hcfdZCJ?pMfMyta03{Owc=)p(pWjs(7Xj6+>oJPJwiOC+
zK+#sfhEnE#fr*;4=K|y#8<0OfK#(A8$jHAc_ZQMBhFcos{T65)@qmABntZnRwtpEv
zKNbYj_N{`)OWFxUbjT&M!RsvNY63tz`HWZK*B*n!MMiXU)B|oT8qmXXw1SPOKW!=z
zIRpj3dV(+?ItMv3Lh}INU83)#a^JSs`E&Ku%(V&mxr}_B_5*NkZi~xhf~VF5ZP@}J
z+8c`nvTxfG0T2K1=Ntm<BU2-2!qG%v2ykMw=7Zg4lV}<y_O?mnTmg;!uLj*C9eyJX
z*q*~dbgQkpq6GQ-)FD#5Ut97g7244gul4*~0nnz?tAP3X*eo3DvLiP!2A9)YS3y%k
zM}Q<r-!ocYK|k>j;23=Ij{V)Q(u}3cp-00$FhGZ|0(I+~#Dz!HCvWAz{so6`p11te
zz*+I?H`;3P&`3)>Z9;^6p-}T)TYm}4`Lf@Hh0FpOo>y)=Kjr&gZv9`}Ups|q1?IG~
z65(9+NKtm@2~<Jre~!_6oU=3v`8)y309fO*xdgqg)UN;(F|b`{IOhZrYc8LGHt)Nh
z9eRf<PtLpb=<50qO>3X#t>p72!k3rCv452;*h=z&6z%=F%okG0Xi2^wdgHZ~M!(t8
zTimLKC%}{X`B_Qg$AOf;HZUDO^CNX7Npjw<L+?d7NfvlIr^ffun8-vjIbR!WJqI8Y
ziaGO}hGmOLM#ZM&?Zsr^r%DgoZM{R-@5%;3z@Us?`#O@Ta^g{pmg?cWAa<WDM;-Y#
z+gzdd86W&Xr=Q)#HPLDqhI%MgyZ}N3AsKLdsuOLP^<YK9GWB=fS3f1TQObPbnbK&=
z^J7-oD?ts4`ABiBjV2&|NV{o}@On=MqH-#vb-6tN#Y(%+6go%y<7K<6hurkb;893w
zyvnaaCj8^!%dc5bao?2OzF^VyI=~&y@TS*B6bjhYD0d{q@L%&NMU4i@0)>aJt$vcV
z@Cknt2sPU<HJ_#^2ZaGKQDE`{%;&x<pKF{e3z}7_JDMui7SWt6j1Dl^b`R4uub0%f
zkB@=7=2L^Rx!&~V$v+6~FZW3_Q`mAhwM}sHa4%bC_qkEeem<wlueB!%jN5==;P~Tm
z3T`;6o!p9v^`{&{mNBZ&=8GGZ$+v=Ub`t}yZT<ulFU>SK=t|1r{-#Q-0&L++fm&_2
zlQcNUOOw$Y_kD}CQ%$3zDtWqBf;MmWYBQ<kiw-*kp~H)-=XG+~Yq83%Mh?6Y4@spV
zZ(lv`@4M*_YFcIg4$9X)@!XMpoWZ2+L&uNqy#(A;py6tF+6dbqHTezpUijh0IYHJP
zC(Z{+DWZV~F)@b))@cFAjwgqqjihI0vh!bv@E+$B+5dwoCiVJAa%4vy{}`lMFeDbd
zdRuYn9Ag3G8|f*z^>s>O$^I`Ua-@=5qOK0PG0!tb1YgzNC1G%el}o$-BhPUlU59A*
zl9pDs2W{a05S6LXXjI~otNE7D9UJ8U=*<Ij6E}k#DeU{jK2t~@2MIn!0Sd;x-y+U1
z34LY<7TF>1eK1W`7HVQ-=k+(0Us#bI2%x1Q2NyY%Di_@WY$L<lIHccTl_%twc62iD
z+^M-)B+753b2bH?@B)%zg+7(n4l+1X9f~?Qo2II8j%~O!<xQ@|zM0uGt_IYxNgsy_
zQ}3dB2+tMtwie_VmsGcpIk58PNVvg0vpXdD(UJ>alG7^n(~2o(FQ6OXUv@xp9Dq9R
zwBJxE5+N=p!SA&Tt`jrY96-~UzXJhYo(tWdN#!fmBb2zXF5$<a*l_}wsv#5q{w)KL
z;!XP(d{xcH^u|AIyfEIjDL;p?NMNd^F*31B;~UUEg~_WCny2E<Nu3gD5pGz^+CGnS
z`qF>v1&H~_6Fs$LsZyCc0zwSJgh!GX<%Fl)t@)V@;Zm&S&zf#M3>DV}tf$&mLx>20
z&Z6k*0ubnF7oJOiu?`0j)YaH`YFaykT9dEa&%924edC@|VE>U!_#MnZ9p|Q`BL7|#
zW~K2NG4gk@3z4KU|3}YL2A6@#ulhAu-kbet_`*GTYkblps7%odmMy9C2;NC-vyE+|
zgwY#v4EWAye-cu;ygp<7(#bQ!#LEsz-;>>~fCLV`n|UWP*(aHJR`=3YEz{-t{=uNJ
zOUOKR7n?m33t%~UPW(6xHCao}P9Jg<fCFuQp`V7EmXNM6%B&TX$x1M50JEs$5X3|l
zXwC6$f!Zs*#as1lD(SrccDts1X$3k<iBy!jr)Q-w+uD(^*$S!yEPD=B340sH)aar2
zX5fmC9>$Cnzdd6W0P*O*|MIR+4#fNAUrFr}nVdeFAjf6{kw7<3HaPwsgE@?9(t4X`
zfGfVw$KjRehxy8Rp~_$**#v)^UDeNB<xEgx8}3Eeg>U-Gl@#H`uYZXhU|3kn8_0Y)
zUu&gGjRbO$lJ`-{!j5bz7gkk`%mZGcY8xVU?5Bnl{!dg>Ryoqvfm%bDMz+quUR!M7
zwD7Jq2DUzHqbs$Q$`?-g%uzFTFW8XUrhU;|T_GRa>RJN)i?*V?q^jR4k0h1!4EmL2
zx+#2G7VH_zyp+3H?&^4-19_>$2~CkxkEfJ))Zd``MN;WKy@A{QyeBcj^O*_#D_~_s
z+X?B_@XYb~B2dqtLFQE8(ns30_H_Z_{skuMlI7nLKn5IdZfzj^pW_v!9PN)U_5GY-
zdO=-z%0cf5#)By%GnqtEu=a-ok05bekOm;Dc@^<8HBMU54(|CPG>C2YO8|$r&1|2c
zoE=G=)zY*Q+g?<6cm23b&9km3JgI;KeoWP_TpahLRZ-%S2lGkZLbGf|GD#h7CS{fW
z%|cvu-zcBehstH9V)OJKM=G~#410W~dKk(ogXwK{Pbw%$Z_sLLv%82-y?C>dPPjg`
zFIfIIe(j5|2L>osw0jh$M4~(8wF}@y{yc;IMK1m{W;X&1>(ckyN?!W^jCwRr>dNV%
zfTAAs-hWD{7e9GsV)vJzKZUs4m~!)P;d*!K2cU$3lOUqIF~?<9k%2&9JIjpTQgp~%
zHmj6HCA9HjwD+%K?J||<1ZYyZiyfVx>95Yauut5V`Mzj#{<S)62d(^zyTj9xKUW)@
zv#oT00Roqg2THh+_VutAK$WyTaoib(QpBM-4EG0Jx^TI<DMpOvr*Zj`xD5(fDQ>aI
zs_wzgh!jfg`<gM3rchZDgfPF7&Hg}{{eU?1pFL(E=44qpZ>4~<rU6>My;Vlt85k$Z
z@!ywa`qP$zmp!s&dR!zSebC~^2=3Tv%ipYu<}MSUH(a{$1zG=fHEe~^JD`o~9iV+7
zNR69jn%B1xBRr$?GuD4(Vl8eGP^r(SiSGvAW^yVn6J{2f4%N?@${Ydp9crMAIvx|}
z{I?Wr*L^-yX3DWFcbf|q`MpGd)eQSd9w#w^t(m++*FInj<2hJP0Pjr9gV|neyyncN
z-XO3+Q=__m!o>X0evzc2K`d_%#xD;X@`p*Oub_P@2=c5cPheO5&`CzUj{RVkvCQx5
z%djxw?Q8`8Vh*c~Jn5W<+0Hs?*4U5A%+VqzyYRqC*e1s}n(8GLuf(e_-yb}|mC+ep
zVP*l@BN0kbV#?E$$MGFVf22YQ;u}=Tvm95Hkt+Kkp=T{>mqWhu-i+yFQl%CVBUWea
z7oqmn{NnjET>VR#GcdA7`Q<d_4tdnZPAk~qddZJIw1O!Y<RnoIi#*9y*Kpek-*h(o
zLu|lj?HYH_#JWM=+n)-C*?@vXqmm%@t`soeh7}0lj}a3~JlV$6j#))foZs?6$aZvM
zO2068<#R8Q*u1A2SkO654n7QPW3sn%_n<4qSo~aVi8oLu35gFP&Q8kztRz`Do1yY*
zx3Yq@1I|ZjgZs(l7{+#8JS6k)p}0d8Q}40tO|?`ef}z4i3Y?>OJw6jwUd(7gA7g&J
z<T6Y`L^mXLg^y#mQn6s3nT+;Rw5^^(_W}0x9hDU_$^(p9R2zhG8BI)UGD+ADZ?~rb
zTgP$%JGA@5Rgn_)fNHe{@2hT1khLKhRsA0ROZs6~`--R%pB0*Yo@gD?ZhH)VkxZsI
z`g#qxsz{P3ur&KL?SMoRQG+?&g?Ac*AB9g|VCp23zA9B0VE0t!TmvFz6uksokhpaP
zW<Jt=1=h<^21eS=gg0~ptD`9lsCFsI3fG^?-CcXq2B|sGEEvp?_eLsFJokJ5)KRw3
zqsYu&>aUO0d)*H)6tspkQ^tY3A9rnCi4*VF>i&@#WYZ90c=9QmuubIi94cD0Ae_7j
zZwKRwF1irjqhfk<{#A!ZaNfD&VViq1R~3u8QS2UTi~1Kq&l2P{$aMVA384!Rqk{G>
z!{QGkpE;%`J&X5@<)edCFp^2ODHPu>VkDPqbE>uOvZFFYcIr}e9*yj0nArYE-Y*$Q
z>N;B=E~X$IAW0@|=JFz*{WqTm`d{xRxeTixxTQqfD*C!FCTO`*7~XVlco_J`67j{p
zfW7rxdEsewCRVK)uJPkT6V!Ien;BsUw;9NsFkA@(v~-yNgdbd^xLn>ui?ZNNX;qm=
zu+6E70TcVe1H!qG2h<91CZylOH$5So!EMlud~7~7?dI3|Tgcf~*hr3}(JiAhT|7+c
zN!UdzK|)BdR$!U)v-cuC=0HG|K1Yp?@h)fBWD}raZ_+lX+M{37G43UTf%=m-xm;}c
z<lFgT?2xuIv<_nLN}t%q;SWz2L%>r5b-32b-fAMWf`C&=`n$>R&{nAsrYvj}Tqg02
zIH4bB`jb+^faD0QYwD12Dm+M}@0Z~<rSvJX|I~t0EwV~jvQaq7y%f?gp(h97;L*w#
zzxR#Ic}+1#6bB_F74gtRSkB(A5&DbmCei3VDv#Rj@X_e4?XC{Izn2&~juzMnpO*A`
z44o~V!R`@OSc~Vl=$Pe0glyeZWuPMWXIhq>Z^Jzqew{%>-%ItuxS7}mC^HH3!1URc
zpZxp+Oi;9To5qo<<B&=o))Ef@GqmjtB90?I-hh|C%4ag7UZqdaZ3A6V;iSN4s}HSG
zv}U-<scORx{f2c=nJtqsit&*q5o@SoK`>w)L&qd1ROYmO<wmDIK}r!3<*U|YNHNbb
z7ZJ6a2o+$P&uPB(HU1jgVWi>y>nkZqb{`h;t?G$YPKmTH147Dh^XQq2?u5HxU=ox(
ztwfOsBG0PvP@Dj1-}iwtMAGXP$QfGuiA)#5hhm^vjkjYopLKT$wEw0qv@~Ybk21R$
z8Hlotq%vo-OJk?HzqY<B`zgKn-aS84OCyHPXg~4WoN%jxNummt8J@-}jnWLnMQx8_
z!n1jMorsg}7v8_VbLwQnwINXup}OveRwaDIsTh~nWYxEg?6#Tfha2dtJHL?vJ2uW_
z_GaB#Df8o-j(1nOx+3^+CZ0kK-@C3`>}6<pMw~i%y=)LQ_ZXli0&+?>TVFO8`aJ~J
z__g^h^AS-Ym;IsQ-^i#)SO}-_742`D7#9s=#&D>-c)){W4N9$Aukra#?7MM^QaYVY
z8z9H_I!o|S51}Kw-Dxzc9b<DoixZ2vI|gWQopD^cs);c^C_!{_v?$j~{i!%pNbady
z4vB{Ts{odSk{ERq#M@0MCs>`UPUL-ESk7M%h5O}S;HQ6LXj$T&@zS^2ye5y#3M*cZ
zdgQNPI)`Sc(#kR-op(e!F)vyjj7V%q^|8YLjr|Ke_~P<7K3GF!{j2DOmk=qN99=^k
z5uRZP`}Pyb9oCx!s5cb}!TtX?W^K_mbZv3e`WADCRFN+z{`EfjO)$>Zk1Tp;fi)19
z7*CDI*2FtP7I<eLH;4#eK;v6e$+@p<F4}9m2uKsK^M<in>a6!ltl3q@*?80~N9K%)
z8n0v@XnP3}hIH;F%1Dl2DzfwX@3_R565>VXcNk5~W+{rq)&Yn9(>eyPSKoGIc}*rt
z`lSr?{wU8vcBmG~7L4tZFWtu6X*kFem1hp<sTmEYDPNaW;m8*g!n7xH{i(0Y0pc~#
zU<E*nj~#=Caq7fJ`@FYu|Ha1eMV6CF;0NyTu$+(3=6s`5PI<VMlQ)w=rS@o2%ehox
zUHEu5WQ<FET(yALv4i^0>i6OGqkcsvUpTns@*MW<-q++1I1X46i2K<+r&5|BHoQ-8
zc`-eOop}unG}wyj<70;hkJii8PS|ukL%Uy|I5rFWdZc#_7xAHO5$%E4o+%3KOBB3E
zlLLyJZ5O5Vl&8v6l6Bcn>eAO+O2XC$Nl)>1X*ykl^U+yy)jljM^%s^!eDQ595=Qfh
z=Nm`a3s<5ReLEzEiSOc86kpZKmnGkE*XbO8e6&Ql=WjqG#v+d+1g)E&G%3@2n-I$P
zGF$RP3H@6dwdC|254oP|rsJp!T||dP!zS?o3xSZMs@hnOfCq<j#*nHtt`q!2Snq(8
za1J)73KikecQ#-u<TncR^jL*z4Ph~3D^_OlY3e-Uql*@2CkVN2#yqFJxkaKz8N~%=
zhJ^=R-_a@A536V_hxuYJeuyFVh8Pl^PjKBSF{gDg-6tauwa@u`wp?S;)e8_u<1MM-
zlD{y_KA!T??ruV9Rl&m0Ae+?6_kr;H6KrC<_d4oqOuDvJz<zUwrh+PZDcGkJVs5d7
zhJRu9LJe~f-z^4>W>=@k8|49NMj_tmk!71E@Q@SPsBr&yG-u6Av@99>JEjGI@HH8>
z|6>!ertXAc0{lk!j84N@BPne7*jP7(G#i=()aM@-<utl83o@csz9aWkfnql0gsXhA
zW4jIeD&<s7zGtedRtvF}PKttWr`pIvletijVAZHR1u=qH*zL6~v0=jAGxe=P#lPi;
zB@GG$D2Tdj%sYIM1zC=0S_H-2XEh>eA{b|rMmOAfRLO82su&_68*x*@w`q)MV`0JX
z-|oABe1A;dq`b}OYl6HvJPYHpOs0Bm*=Zsc^c*^oWJ!q_;0YVX^$P29xW8A>^~k|}
zy9DRpo1b%lsx1=9b?7}v?_j85zqRhCv7U>?IkhUSMJQlunW4Gg=&SyNF;A<=kb-Ji
zWg)+^13T%>scu9Ve!D}?%2Dxor{F>UzVo?SF&)gkAXfI=m)A3@E>_>N5sUGzH&2sL
zBG$q*a`DERG@0k{&i@K=2HoXSgs1*IgQ^#;xmY4rE2A5K^qo@AS`ojX{<88;|9Zfb
z1ZkU#J?fgy!(fz3aA)p(xMwluD3?fX0uSmMJ2$z3xdL<DHWz=wY`O9W`c_-Bv?BIt
zh~hu2p|7eh4G>I!Sm`6`G0$is%SIOZrJ~9ubU2*v^mEXztQ=2;B&(q_jaNeP^u$jg
zbDbPBq!b?1`kip<gPKfiJUSxSWo8W*d_on$u9#Tjls`!L8?uWR&>dpg&S|E?Ih}Oj
zI{N~oGN}6ndS-E*gq@}ksk_9aj8M;Bd3j7x!bV3%m;0EhX3e3*2|1P10de=!j4Fp9
zG#il5N>T6T6aAzq8Iz>cAF8FgD%Xx|`ynCHhtAC|rbihoiIl;k*wp|Zx6nWk1p9x?
z8v3K`jO4*5KZYO~z8QuXD|-t`*n#=qi*)B6ga*3G_GLt_$~<sNMB>(jFtU}Cad08y
z!%~ERA9Lj!lAXR<l{U_9(U!mSP4NUSffh!&SGJhfFuMm>pWr(Ct;`=_lMRL+MJ<wd
zp1Sj12<+iuRiMbu$RsMq6<a&h>AJXI8^;Uow*6xp{4>!eRNaCiXKyD<J&l$qyUF`0
zXMb11DQsUAg+1|MUShrrdKnfg-(M3zJ8`)eZ|G61<S1y@t5-OFqigV>N2jjaD2tHS
z!GBMO&<><`ZXrdcuL<L+ZzDiaTOLk-b{(%~wcp&@;%!;|_tBt?W)b9$EcojK&Y?lV
zo;Q0@Ja1M2Il%q*VPp7~hpB%lr&3l`>elUs^iZd!el$(jWm=Vj_{-d4j8SVZ59d-v
z>BY*bI(n^%=&`LvC4IIcFsVOr58^(CM1%1>RF0d5JnmKV{jXadw$b%QDxkxmCa#d;
z`nBcoJ^9J~mI{inl0!QRSfgw4hr{@CDLPJU7D0l(L)y>p{;aPnt^<@`hxlj*USnA)
z2%tz8&JARYdYr`wqbkduhJcu(h<p!D_`Q^oMAT+KYqKx&!@Fr8CCYa?zc~d7qY+Qi
zEv@Lg_DtZBu8`Hz0|LRYa;eH1YzL3jiv%2b9=fOTFJg2%k9i1Fo!%`2mypSpCI3~!
zDKgM&&9<~kF?AzI<#C?!toED{pT2fE)1H-~=E6d3K&hP3FRJhSb6D4ovW$HNtu#$;
z>yXdDO^_OP|DK|MHupSpXRgjeN_n+X9^P)<ZjNy)r=9yVv_T5;3Gz5drvyZ8=1p|U
zL%z&7?A6b*g~`4&N~wuxQ!Y+js~`R<7vla8Z)ATi)Ywc=;|p0(l3&(Lf_lI5bmoeD
zE>Xp4x&Ihel4Eo+8c&5DG_mKqMJTX!>Iiii51776E?`8s*kaz6<n6=Bmp0#&*Ig96
zjwMW{vM=u8)<(uue7PhL`fw2YD1(KAa8j6A7bKuF&!#^36U^N-Kt4kLY$tCWugO26
z=u2&Ubd{UjOQcf6IpU9Nu^gw06u1-mYs<YrAd;rMfxKA`MvX?Dnq4iDDycMNr6y|g
z2Hz$5M%}HX+&sSM(Qrs)Y1os$i9|LtIh8PYpN>(<fH&l#9Quw)$30IgByyMxkC-%!
z>x;cfIo*3W9s%@aZ;yRWoyksm;A+o{^*6TZv9IwbEI>zBEnFciY&)SFy64XP!!F}F
zivGzM@5d)v&Tm)G!X6J`zM=9Ye5|n+W3fiA9`OP=VL$$K@R9W(%QQHZ)tRfE5$}l9
zQ2#PbnN>oxjJNOtQA+?fEhn{m-n7XpwEfcXBLgaABeigv?>zV<q(n7Oi-O~nDghTu
z&=IA-p3#8e>^Lu_c@*s%!?A>Q3@~5ard^ki44FaWvi;;aP0r8XV_e8Z6qINN*s@uc
z-fm~f2h11CMC3A5Cl$)0IwY!)f+!~3og{aD4mi``JrjQ-^6Y6G>cU%@HS=|sjov>r
zI*l#jex^;5Nwz(nzj9*?1GA{A&#6sK+$C(t{#X$UjxalXlrmXp>D8Ib`WHr;&jhB*
zdls~cq+NoPn0ztNIKZ4e@=AnC&G^|lQeOwCLN&AI4WPNmnHW@zdSo3w_kOk*=kMwY
z-qkMzH5uoQm9y6RjEpNaqvl%D`pGO*MMoNDYd98;MB#UwD9)$G6WK+|2DOSK?EIg*
zI?8HTIgxkEf2>S<=xL*Ms4`V6u8{Bk3;mQ=6>5U&s2CnHw@XNlv+6vkMCr%VpK_gM
zxd$UzK62D$wFVE6_2Pt4)vI!Lt5|t(UZa#!DRIuV&^FbWSUy@JX-XKM)=p8Z5Q;`b
z1@{;|S#{omPjO^(SR^v#@T(nMGiBdp&r+a{&H5;ee*&DRT{^zJu@TKT35T{#+7EM7
z>2cEVKI7Flj|xqYMq;KAH*~q>{DeF~l2XJGZG?Jwp8b4FE9o#8Gxk^DNCx8NrH-hD
z(QjjT4qgsq^#Jq^g_Zm;My^CA@#GuiBlM;5D?{TsK2i$8>q^hxq5R%0|75W*3=Zfg
z?z5yoB<TMGqNO4G`m8Yb3LhmRFq?&m=rEe;wv~$w1`yySRW#SiPG8C&Lnvy;5^NL4
zdjY+w-zeoj^bH96ANmovcWL-+1cdvtW^J-e7`V`d{Jr-5`R03-QL<HHodma4mEpT;
zVT2H}XG9!mgx2#0R538$#I=^hFuh%xl1(fSwv;ptfq<Z-4zZtJ$Sr)!_el6W0S`*4
zmvuthKx1{?Z^%Cum4pS^l&JxT_Q6VJq~Ylg(+H)fG;f4*R!<q^E7JG`lE=Nsq}AFE
zCDP|(U_-9sn=(5sL+=2vuenTViVu(mh@4h-zI}~Ii^e&bjf0=OWz=DW+;qBn!hXtt
zysd^QP28G(vcV%G%lkqRg~nrkd1!O6lZw$ll`gj~F-UvLPV$os++fYTSZ$7aW$SQW
zWsgFL7W<o}>)P~ZhQAsj#qP?NS{m2{EpNOs9SL(zTe@>ptH2%S_68Y0X1^1s-Q$p2
zR9SQ2?13*t_;L?2@m)Zp<NT?=hPQmhL+#n}x()8jh?GPDBehq!XLZ0Ud$4k@cq2hK
zMtv&HtQ9N#-XhHyn~+Q?l?VrDr!tMw!|j3<pe9Hzp=^F!fypjFLgY+^eQw10FzwS6
zYWERsS{zu3r;HhYPUQ1Q<0b|iw7PznDcF2AmCP_<I{<684Qjmi6_?RvH4o%C%oFG9
zSvJ16nXO0sT1!7+?Xj9F@f@qom2fq+)<s~A#+BM}dH!Mc=BsAl=Q4A~g{P|!{wC0#
zEjoEEzN27j)H?F)A{t?soDyBp9pGi0C~(0e@H;{#U-(|U!5d&u;D1yr$RVYx`vQwg
zCZivVO=aJ*OKicv8UW~}%@0Kp3?U|Cfd&d|i$E|d&KX7F(mbjm{crs<(bK+|7h~St
zHwh`%9Pp45p22y(0+36rS2@ZW%%Oo4*St(GC>_Qn6}!3`w9-TvF8Y61|KUQnBEi-Z
zQV{s8`+YMUT0DK0?QMr?v+ZSSSAX7Q7ljb=sMd0(wFdB4vqxtw%D?jzkT$c0+Sb&8
z97fa=;qt6P6$ryf@n%k($Vp-@5*M+rR@@)+=Tn=w8&^ihbt%Y|HX~VU4<q|0l`NAA
z)F9`wu8IBJ8#Nu+0RDsd9et^LeAO&0ho7oFD<;Zh8f$H1EE+cn!j>!sj7pArQC+-G
z8fY^1YEF+E`{5z^%`ZQ`(U#DIH*~qq2t-q#JJC4`wy6u8xKa*^ADn#X6a@<fTZS&f
zAEAwyF36H|oP&>5s`HmT(WY4bG;b^>_5%vJG{ha9Xy?n~GN@}!;@EjB5dGjx{qVTI
z(qNps5JTm>I9Wc}f-RwCSek3fkY39XE)3V9S{23wijdbSY370O1r!{;EJd@K`a4k2
zJbw?s$6aTS-OLAkw1{hUmXBgGEZ`)KdAQOK$}9tQhc(x4@15M8fWe|e?t9SSjcPE>
zR4ZxOhMJcyS@8X8u*M^37YTR_6rGRc{Rj}!<?Bh>DP7cEL7t1mW0jem0lF`Qke0Y)
z%sIRo(aIHeqpzY0#kjTE%?%^H72Wf%=!~9-j96Lx3M0M)SrX0fjMb1dFqz8{3=fg!
z#-g4c*06FWF0y!%zkryv^C9uFpTC7>k`B3Km8<{(ihgRcWCem0^=fgePxqfckl3<w
z-r<|lH>QZ;k<T(<)844eHac0M;wsh)FV%X6TviJjx|Qcj6t~Hmi!C%lADNjpMby+=
z9=Cx|C}iU}zE?EoC}q-c%t=_YEuraq+x^5}+)c<a#omfxGJ+@Rbdc|q3|*0H(k2Af
zz>Y*es*9^`{k1?*DA+hyfz2th>4nXKRjhq-*x>C^sD8SwYOf=WG_s-dM#m2Wo0az~
z`Gtrb+hTl#>$Q8fG8MxadR!Erp-?Zun7G=$(+T~a@)c~oeMW+K{A4zyB(~C6OQ;?H
zk$s)^d$m&rq&&>w{Hj_V*EiQ!EkwoW$<Oa(dk(xW3Bhkjl^`r6`2W+eK1tlt3r<7L
z>)uPd-G%<dD5<Y62a(p(i;PHORV9U1)p+t!70g?TpvDTEvZBp3eC$Z3ceV;y!7-3s
zkVY<k*NNV9Oy6XykKRWeIm592MKzMsPWx{nv5h?C!rOZ5@^#w*-kvU#+LTrQ)UaeS
z)2B&o4By3*m6;aa%1jQCvfIwvy|EXUGYmr;O<yKN`?=>=eaa4t5i#`T*wPWMEzkQ(
z*X(^&pW+dH{k|UIJOq-(m+16H7{60Ks(h`qT`Pt8-eFJG#1~X6&3ln5A$wyTt)twe
zwb<Q75H&-KDGQlISEbd=@ArA8*qXNAAFn1UlUCTrCh-i}%opJ*T5HJ-j9j9<!IX#_
z+aOqP;5~LGE&JHr%;9(BIS(A(!c3?l$q=k2J(-$FCc#)}WEKlWP1_+4S-4_a*ysoM
zKzjg0Wj=CS#Z(grWLaBAv9n+&uA_FVxF7KO$XRjor*-p49vxPaz5=&g9gS<w)&`Qk
zPmbCTn<hu;<U!SVDVZ1dtpS$P-`N?+^#s=ybM@W_tjr-gv(QbF)Uqefqxw~WbB8mp
znQZiSj7-kqKoD`U)=N9#LUmRcMxP;&_2C8O%asU=$Y!fGg)()#Y;0*{6G3=#Z6KA#
zEx?)wQCH^g*23FfiXRi0Wfb)YL?hT`rzD>tCShWEP@k(#XTO{r0zuLDSURVoxBg?I
zL;o4Y#uQ@&5*%?p{H44ljPcK@#KC4JM3=?Jyzl#Go_qBVjJt|>cFHww*D8+*q)oK#
zA(1Xffy{FHVg1Zr9P*(4!riBndMEqJIAro=MQV{TpYH8cRIt47iEhZ+d&$U8njmL5
z81AbS`zbtK_yZy30f8&B52o7}iO&~N6+*@Rk#nQuBn*rVq@<<k0t}?)3q217j&Fcb
zuK!U&eR&xVhKaAhlq6s43uGXa|FRa>VB7}u-)DmK7!CzIg0QObXd6OB!*^iuRux@p
ziF`%kO3HmHYaskDVKwgYFGF!@KF;qiac6fl)O`VOc?}d>rlp3)uV70)xGY4+U$?nk
z^92A13YRpFmDpzeUFEhyj{R5)ztn(bZwSOCO?D)R+cO{idjI5eIn!K3;$|z)3HzRb
zA%owGQfr%`Wk<m-buY@&A-^fFh>gSiL+zgt$M<?J%G004#g|J1bNAtaFX(Y%enULi
zOii=MW^@;EL;AeaoKzj_R4igRdsT^OJ}P@ZAa?z+=VIlw40qKHD|ZH$^L_PVkvfz9
zWXVsPNG;Uxe;kao=_@Uo*X65S<&1tiitoNX9Fdndc06*kO&S|<qMb$+`RPcDK{B<x
zx+-YwtCQK7ac!b^EM=lU^~g7-oGZ!eGxEo=LaN|mmtG2+dhC3CKnC*6kSjU`^0<nN
zPpaFHZf|rNbWL!Eq=%~J6If=AS_|lqjpJlZ>&2g8g*C9ml>d16LZ!%h)0hI>oQRAf
zm?&senq&J7;64J1bpZbi2f;L-=Na(TNHIss&6lxbi$m^;KC?=W`Ik*{dXBnb4#1G^
zSu>QT8jERGx7QaHvW3447;*MBuFd<N!8ZiLc*y38;)CR(R}8;rYx2@2M&9E#TtBAc
z^C%KSC(6_fh<q@&?a^epUix6}lo9h_^xhTYSw_$;Pz%OXMYY2E?%NVynF%P~GkfUl
z%M16_bGCn`r&r*QLr^MVL^V<nMxQ=a;|Tu5RA4H@NL+5u;lu0RPqcRJrk{I+OxFnD
z8t6ygS@PjfuV9pJVW8FAZSELsW|S+v<YDKYtKr#$aMs!(17TyuK$!SyYGkza*u3ap
zt;uCJH;S&@2C5NU)-*xBwNKzmd-Egtu{Lt51zc+b!?Dqq3zUy|``&@g)z$jNAm?Mk
zs#<PRX@;qhpWsJ6)a?F?xRj|O(f;EXh>}yqv>pn7`WAOY*2xFC^(YSO6c)H^?Vk^?
z5HYHyk(PyS-&X%C%;H#j$y5CXcLy7scF16ztBq<BL8jGj&YU^QM*?fYyAHbl!N3RR
z{|yP0w2}qYR==ydPLbW}LC`9k4Fg@-(n1vZT!e6CnB%VMIZlx&$=dhFj-#h$eydR8
zsA;7m=6nZOrlfY=7gGlaP<t{UABC~g1K-o$AWJT^Sa&_5#*lxPS?k|`8-)=Mv@Lar
zuB?@g)yr9bx`q5rG}bj|nEBV{f(E*<t<9nWw;XysIAXZy`urvaFeD(SrGEchYS!Ij
z)z)sWm@h>Y_<tch^@ey?1PtDndeMt((#;+rkqwBA+PtscS9;OYibeD`L1V@_o9_A%
zbvY;{!w8UL(q7IJwvHQ&dO+{L;-Mm}2B!xvcDJQ`c?ODsjytRC(Lgex`B1g|W)G#m
zVNyoLC|D6liKzKsd*}bp^xDU9WNc%aBSZ(0!aQy_QLQhCCg1Kb%_Pz)B2;!Sx^XgJ
zqcGh&7COc$cg>eM$>~-}v=oa&k>*HW2pyYKc4~?V=Y4hGKisG8Kj8l1{$-EtdR$*V
zyY~59yROIk^?JTjx<NV={QiMeYPM;~r82{_hMcx!_oI!22Yvj6L_~s#@t**wS4T_v
zyq%3S6iamx9=2F;>fwe&C=mZ*Fx;o#L?P$co^+Uob6=BnZ{ZHzt@OQx;-%|dMsFt#
zA7#&lzL6Nc^&c<+OMifa!7(t{z;-1Hzq5wFk#%s;wNhL>F$b#44ibMxtVxn-;pN4|
zy@B7FdL;dLOT5XDCsOL0B>ucFD3v4f!8EMRpDcXD2`@+rjRHpbC1J&mh)En@eNf!2
z;ca{W=D>^chn@BY7g95_$gHB6g=S7A@JBY$5BU@s`YJqBSC>u1-l~?a`xB{S$<i&u
z?dkXtAtx@DFG_6!d}ITA`)^vb2PKZ*044Iqkgqd%BAR&9*R8JZHpWvIOUTR%-`%`w
z)qO7d9XOiwhkU^tQTuBJm15ZDboBYt0@e9DmHl~=T?YsQ9Dka|E4@am1L>sr=Mp23
z93BdBt(ej8=^cvuvEb$utQ6hf#9HURTxV4lpK&BA+sjAs3@qVK4-AB{3fevUQ{X9d
zh^jcz7^*U{qsVF~&t((&3?<S_7ECcSiCi9B4j8#*{6tz~B>WXOKzK2?Q<2rfijESJ
z<$0ZMQ<V0C%S>Dxnv4a}?yip!uOkUPGV)9NJVlw(KbUi!vX}IMdQg1eL+)Gh>ndzi
z{>i0g<+BM@p7*?$<-JXhQG=-Q7F)ozw$}FR@-oNp?F8u&%jU{t#H+fwzrr7@+v>@+
z?)-W+)5+Frg<0~%`E0<NN+on`Y}>Va2B9>qxYA^huV1uwR+k#(AoNZ#sRv=zeP|sI
z8@N|uKn?Ti{qeizSbKrZ)Ty^4uw@T*gcLOQ=bORM8Z&1rbB4QNc?~B1?iK8qRCK<x
zx>Il9a_;jH+q$b<-#Y>9N6L|_l^g1!mph-YCg~F{TRHIp_nq?K@&lr<T>`whOcPL}
z36pkxf)Lzh1!X+Kq_XD4#Et?dMqtV^YAROZxE+N7X(weHt0o-ima9pk<5DT^gxEYM
z;;c19I8kP6CaYNDAHti7VAD;xDG2=K6~a9IK#qI3#)GCa)=Hh-pWn}|O>KJuNO8vv
zba*CHF1m8WA~0ZDggWX8wvCrs<_o=7xYJI*kXLLiDuM~rgpP5LMQk~kF5Qk_OP9kw
z9<%w^`fc?{n2jiENU?2T_8lb7t{*=eN>{u)weoL}S3Ltxi5qq$jq@@Azlo`>Ydm+v
z*Etd#j3RpI;qeysWZkt45a%@anR!P5%u5Gnnl$$J?_vEGfw@&Mw}!H01jtr8??Il%
z0KyqFWvr(5huzXb%eA+uNNTMG^59=2VUqAs0I|f6Uhng<m4?&LKt?hblrd^WArRg*
z*~&*1PNvf({KO|V2)Y#y^b~b)pI0e5bd7F6%r+BJ3Sp4(NDikd42b^A-tdWpG$3+_
zUZX5UIt$8yRt*R&gk5yyip9XiFhat0Hz4q4AbsxX!%C33igR`@Mb5d*eQhT(nkL5r
zkY6uIIhw0Z?%*@qjod&poB=vVjn>)jqsLl}Rgg?Q6ELqBZ~_F$`*-?d5V8)2Al?XB
zv*=4P28b}>ERuDD9G{iGzt{d}SOWRIcU2?BXUv04cgDA-)&n_H9k7Es2olBs<`r*&
zY@w>AM3GrJIAS!>6Z$4-$ptpJ=_a9Is@)&kYd>t?G|JiBv`q$+A0{nawKn6O0EonI
z=0HHdeg;T*d4=l^^-)Cg$tvmFzZS-W6h0WfNq(X>M*=^$--p_CK)L2HfRRI3n7+)$
zuwMOC4b$l!k)>udv<k943FjnfWbkI}`AyrK2^SfsKSaYAPiKO2bg27EhZ*~+{>4+u
zE^jOTG9gezM2M4yKS*gydzlOP!lo&~UrGbv!YBm+7<TE(`e|?{YY58z>Jtw`@+Jpz
zzjB1+4#ObdAb=L_DFbdK$$VYT88S=J>!}GQhL+lZj}?ov6+UcB-8P`m?O8tq;9D~U
zmK7Pt3eTrJ-nx>d|4(i1<18W}2jZ?BHeRs$CW|0s{!D2rbG0lsW&Pyf21w;h*d>MO
zn@tnBz8juIS2Dns;76@NSl|UO3k|N`#*SOSr9q&jOfZ2+!`Bh9YpJ;W%rI<k{LBOP
z!YFCw;3^=E^nMRU4Af>-@SX&oFYt?NgX;lgGTHKY8wXM%GhnYF!daCK_h)#_k8^$P
zaCS(jkA%{^e;83)k^F;?C*1qW-H8GVt{!06w9$^WX10#x3EM!yGjzx=O9-S_Eh4SI
ziJTfvbjMP|fvYEA0BR7oyD`p4+stLlE@0RsbY)xXl7nztOkptu-|#Pp9adfX(9iAu
zZD^E=AVLhF=lT)8r7+DYhdx0VR7XJdcF7=ax(ssr-LWYthpz2L!m;KuHOx#GmYZfP
ztasnY&W2&lvxp6@pWaYBW?C2LTnGBLpAdX1km+D%{$1r$y??#rYNVZ;#6z?HC_}vv
z0MGbeYpZ?ytR{S<EZM4>`eh#%Q~}@jdB^V9UKKz9pfUc~QM8Kn?LU8BNOX5n0oKPK
wYodn6DtNip7k&KyvcH(A|Ml6ns9OB!ns|6}q(!Jh0~WlBw}&6)2X{us@1aVVApigX

literal 0
HcmV?d00001

diff --git a/docs/quantized_structural_evidence_20261031/storage-controls.svg b/docs/quantized_structural_evidence_20261031/storage-controls.svg
new file mode 100644
index 0000000..fda7909
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/storage-controls.svg
@@ -0,0 +1,1526 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="864pt" height="432pt" viewBox="0 0 864 432" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2026-10-31T11:40:12.175187</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 432 
+L 864 432 
+L 864 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 45.202109 217.692555 
+L 284.76 217.692555 
+L 284.76 103.249766 
+L 45.202109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_3">
+    <path d="M 56.091104 217.692555 
+L 92.387754 217.692555 
+L 92.387754 170.779997 
+L 56.091104 170.779997 
+z
+" clip-path="url(#pfe5d903cca)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 101.461917 217.692555 
+L 137.758567 217.692555 
+L 137.758567 130.791081 
+L 101.461917 130.791081 
+z
+" clip-path="url(#pfe5d903cca)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 146.83273 217.692555 
+L 183.12938 217.692555 
+L 183.12938 184.587781 
+L 146.83273 184.587781 
+z
+" clip-path="url(#pfe5d903cca)" style="fill: #599268"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 192.203542 217.692555 
+L 228.500192 217.692555 
+L 228.500192 155.263619 
+L 192.203542 155.263619 
+z
+" clip-path="url(#pfe5d903cca)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 237.574355 217.692555 
+L 273.871005 217.692555 
+L 273.871005 109.020189 
+L 237.574355 109.020189 
+z
+" clip-path="url(#pfe5d903cca)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="m25801f5056" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m25801f5056" x="74.239429" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(35.721698 248.424814) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_2">
+      <g>
+       <use xlink:href="#m25801f5056" x="119.610242" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(82.401417 247.814461) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#m25801f5056" x="164.981055" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(126.880083 248.230476) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#m25801f5056" x="210.351867" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(172.250896 248.230476) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#m25801f5056" x="255.72268" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(218.930615 247.620123) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_6">
+      <path d="M 45.202109 217.692555 
+L 284.76 217.692555 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_7">
+      <defs>
+       <path id="m5a40326d10" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="221.1115" transform="rotate(-0 38.202109 221.1115)">0</text>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_8">
+      <path d="M 45.202109 193.63578 
+L 284.76 193.63578 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="193.63578" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="197.054725" transform="rotate(-0 38.202109 197.054725)">1</text>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_10">
+      <path d="M 45.202109 169.579005 
+L 284.76 169.579005 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_11">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="169.579005" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_8">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="172.99795" transform="rotate(-0 38.202109 172.99795)">2</text>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_12">
+      <path d="M 45.202109 145.52223 
+L 284.76 145.52223 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_13">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="145.52223" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="148.941175" transform="rotate(-0 38.202109 148.941175)">3</text>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_14">
+      <path d="M 45.202109 121.465455 
+L 284.76 121.465455 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_15">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="121.465455" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="124.884401" transform="rotate(-0 38.202109 124.884401)">4</text>
+     </g>
+    </g>
+    <g id="text_11">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="26.31375" y="160.47116" transform="rotate(-90 26.31375 160.47116)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_1">
+    <path d="M 74.239429 170.779997 
+L 74.239429 170.779997 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 119.610242 130.791081 
+L 119.610242 130.791081 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 164.981055 184.650504 
+L 164.981055 184.468442 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 210.351867 155.376393 
+L 210.351867 155.041008 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 255.72268 109.195331 
+L 255.72268 108.699422 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_16">
+    <defs>
+     <path id="ma498c22696" d="M 3 0 
+L -3 -0 
+" style="stroke: #000000"/>
+    </defs>
+    <g clip-path="url(#pfe5d903cca)">
+     <use xlink:href="#ma498c22696" x="74.239429" y="170.779997" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="119.610242" y="130.791081" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="164.981055" y="184.650504" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="210.351867" y="155.376393" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="255.72268" y="109.195331" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_17">
+    <g clip-path="url(#pfe5d903cca)">
+     <use xlink:href="#ma498c22696" x="74.239429" y="170.779997" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="119.610242" y="130.791081" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="164.981055" y="184.468442" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="210.351867" y="155.041008" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="255.72268" y="108.699422" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_18">
+    <path d="M 45.202109 193.63578 
+L 284.76 193.63578 
+" clip-path="url(#pfe5d903cca)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 45.202109 217.692555 
+L 45.202109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 284.76 217.692555 
+L 284.76 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 45.202109 217.692555 
+L 284.76 217.692555 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 45.202109 103.249766 
+L 284.76 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_12">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="164.981055" y="97.249766" transform="rotate(-0 164.981055 97.249766)">SGNS, order 4 (n=3)</text>
+   </g>
+  </g>
+  <g id="axes_2">
+   <g id="patch_12">
+    <path d="M 329.962109 217.692555 
+L 569.52 217.692555 
+L 569.52 103.249766 
+L 329.962109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 340.851104 217.692555 
+L 377.147754 217.692555 
+L 377.147754 177.993596 
+L 340.851104 177.993596 
+z
+" clip-path="url(#pe442726ab6)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 386.221917 217.692555 
+L 422.518567 217.692555 
+L 422.518567 144.565164 
+L 386.221917 144.565164 
+z
+" clip-path="url(#pe442726ab6)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 431.59273 217.692555 
+L 467.88938 217.692555 
+L 467.88938 184.05533 
+L 431.59273 184.05533 
+z
+" clip-path="url(#pe442726ab6)" style="fill: #599268"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 476.963542 217.692555 
+L 513.260192 217.692555 
+L 513.260192 155.018869 
+L 476.963542 155.018869 
+z
+" clip-path="url(#pe442726ab6)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 522.334355 217.692555 
+L 558.631005 217.692555 
+L 558.631005 109.030723 
+L 522.334355 109.030723 
+z
+" clip-path="url(#pe442726ab6)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_3">
+    <g id="xtick_6">
+     <g id="line2d_19">
+      <g>
+       <use xlink:href="#m25801f5056" x="358.999429" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_13">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(320.481698 248.424814) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_20">
+      <g>
+       <use xlink:href="#m25801f5056" x="404.370242" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_14">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(367.161417 247.814461) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_8">
+     <g id="line2d_21">
+      <g>
+       <use xlink:href="#m25801f5056" x="449.741055" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_15">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(411.640083 248.230476) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_9">
+     <g id="line2d_22">
+      <g>
+       <use xlink:href="#m25801f5056" x="495.111867" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_16">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(457.010896 248.230476) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_10">
+     <g id="line2d_23">
+      <g>
+       <use xlink:href="#m25801f5056" x="540.48268" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_17">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(503.690615 247.620123) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_4">
+    <g id="ytick_6">
+     <g id="line2d_24">
+      <path d="M 329.962109 217.692555 
+L 569.52 217.692555 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_25">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_18">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="221.1115" transform="rotate(-0 322.962109 221.1115)">0</text>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_26">
+      <path d="M 329.962109 197.268849 
+L 569.52 197.268849 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_27">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="197.268849" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_19">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="200.687795" transform="rotate(-0 322.962109 200.687795)">1</text>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_28">
+      <path d="M 329.962109 176.845144 
+L 569.52 176.845144 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_29">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="176.845144" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_20">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="180.264089" transform="rotate(-0 322.962109 180.264089)">2</text>
+     </g>
+    </g>
+    <g id="ytick_9">
+     <g id="line2d_30">
+      <path d="M 329.962109 156.421439 
+L 569.52 156.421439 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_31">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="156.421439" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_21">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="159.840384" transform="rotate(-0 322.962109 159.840384)">3</text>
+     </g>
+    </g>
+    <g id="ytick_10">
+     <g id="line2d_32">
+      <path d="M 329.962109 135.997734 
+L 569.52 135.997734 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_33">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="135.997734" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_22">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="139.416679" transform="rotate(-0 322.962109 139.416679)">4</text>
+     </g>
+    </g>
+    <g id="ytick_11">
+     <g id="line2d_34">
+      <path d="M 329.962109 115.574028 
+L 569.52 115.574028 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_35">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="115.574028" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_23">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="118.992974" transform="rotate(-0 322.962109 118.992974)">5</text>
+     </g>
+    </g>
+    <g id="text_24">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="311.07375" y="160.47116" transform="rotate(-90 311.07375 160.47116)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_2">
+    <path d="M 358.999429 177.993596 
+L 358.999429 177.993596 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 404.370242 144.565164 
+L 404.370242 144.565164 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 449.741055 184.116513 
+L 449.741055 183.964525 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 495.111867 155.11927 
+L 495.111867 154.86922 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 540.48268 109.363064 
+L 540.48268 108.699422 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_36">
+    <g clip-path="url(#pe442726ab6)">
+     <use xlink:href="#ma498c22696" x="358.999429" y="177.993596" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="404.370242" y="144.565164" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="449.741055" y="184.116513" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="495.111867" y="155.11927" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="540.48268" y="109.363064" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_37">
+    <g clip-path="url(#pe442726ab6)">
+     <use xlink:href="#ma498c22696" x="358.999429" y="177.993596" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="404.370242" y="144.565164" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="449.741055" y="183.964525" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="495.111867" y="154.86922" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="540.48268" y="108.699422" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_38">
+    <path d="M 329.962109 197.268849 
+L 569.52 197.268849 
+" clip-path="url(#pe442726ab6)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 329.962109 217.692555 
+L 329.962109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 569.52 217.692555 
+L 569.52 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_20">
+    <path d="M 329.962109 217.692555 
+L 569.52 217.692555 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_21">
+    <path d="M 329.962109 103.249766 
+L 569.52 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_25">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="449.741055" y="97.249766" transform="rotate(-0 449.741055 97.249766)">SGNS, order 8 (n=3)</text>
+   </g>
+  </g>
+  <g id="axes_3">
+   <g id="patch_22">
+    <path d="M 614.722109 217.692555 
+L 854.28 217.692555 
+L 854.28 103.249766 
+L 614.722109 103.249766 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_23">
+    <path d="M 625.611104 217.692555 
+L 661.907754 217.692555 
+L 661.907754 178.051597 
+L 625.611104 178.051597 
+z
+" clip-path="url(#pcc2cf7f4a1)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_24">
+    <path d="M 670.981917 217.692555 
+L 707.278567 217.692555 
+L 707.278567 144.731662 
+L 670.981917 144.731662 
+z
+" clip-path="url(#pcc2cf7f4a1)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_25">
+    <path d="M 716.35273 217.692555 
+L 752.64938 217.692555 
+L 752.64938 184.069388 
+L 716.35273 184.069388 
+z
+" clip-path="url(#pcc2cf7f4a1)" style="fill: #599268"/>
+   </g>
+   <g id="patch_26">
+    <path d="M 761.723542 217.692555 
+L 798.020192 217.692555 
+L 798.020192 155.000098 
+L 761.723542 155.000098 
+z
+" clip-path="url(#pcc2cf7f4a1)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_27">
+    <path d="M 807.094355 217.692555 
+L 843.391005 217.692555 
+L 843.391005 109.122021 
+L 807.094355 109.122021 
+z
+" clip-path="url(#pcc2cf7f4a1)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_5">
+    <g id="xtick_11">
+     <g id="line2d_39">
+      <g>
+       <use xlink:href="#m25801f5056" x="643.759429" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_26">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(605.241698 248.424814) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_12">
+     <g id="line2d_40">
+      <g>
+       <use xlink:href="#m25801f5056" x="689.130242" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_27">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(651.921417 247.814461) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_13">
+     <g id="line2d_41">
+      <g>
+       <use xlink:href="#m25801f5056" x="734.501055" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_28">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(696.400083 248.230476) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_14">
+     <g id="line2d_42">
+      <g>
+       <use xlink:href="#m25801f5056" x="779.871867" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_29">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(741.770896 248.230476) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_15">
+     <g id="line2d_43">
+      <g>
+       <use xlink:href="#m25801f5056" x="825.24268" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_30">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(788.450615 247.620123) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_6">
+    <g id="ytick_12">
+     <g id="line2d_44">
+      <path d="M 614.722109 217.692555 
+L 854.28 217.692555 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_45">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="217.692555" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_31">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="221.1115" transform="rotate(-0 607.722109 221.1115)">0</text>
+     </g>
+    </g>
+    <g id="ytick_13">
+     <g id="line2d_46">
+      <path d="M 614.722109 197.289056 
+L 854.28 197.289056 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_47">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="197.289056" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_32">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="200.708002" transform="rotate(-0 607.722109 200.708002)">1</text>
+     </g>
+    </g>
+    <g id="ytick_14">
+     <g id="line2d_48">
+      <path d="M 614.722109 176.885558 
+L 854.28 176.885558 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_49">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="176.885558" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_33">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="180.304503" transform="rotate(-0 607.722109 180.304503)">2</text>
+     </g>
+    </g>
+    <g id="ytick_15">
+     <g id="line2d_50">
+      <path d="M 614.722109 156.48206 
+L 854.28 156.48206 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_51">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="156.48206" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_34">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="159.901005" transform="rotate(-0 607.722109 159.901005)">3</text>
+     </g>
+    </g>
+    <g id="ytick_16">
+     <g id="line2d_52">
+      <path d="M 614.722109 136.078562 
+L 854.28 136.078562 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_53">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="136.078562" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_35">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="139.497507" transform="rotate(-0 607.722109 139.497507)">4</text>
+     </g>
+    </g>
+    <g id="ytick_17">
+     <g id="line2d_54">
+      <path d="M 614.722109 115.675063 
+L 854.28 115.675063 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_55">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="115.675063" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_36">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="119.094009" transform="rotate(-0 607.722109 119.094009)">5</text>
+     </g>
+    </g>
+    <g id="text_37">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="595.83375" y="160.47116" transform="rotate(-90 595.83375 160.47116)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_3">
+    <path d="M 643.759429 178.051597 
+L 643.759429 178.051597 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 689.130242 144.731662 
+L 689.130242 144.731662 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 734.501055 184.134028 
+L 734.501055 183.980243 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 779.871867 155.102776 
+L 779.871867 154.850809 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 825.24268 109.465015 
+L 825.24268 108.699422 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_56">
+    <g clip-path="url(#pcc2cf7f4a1)">
+     <use xlink:href="#ma498c22696" x="643.759429" y="178.051597" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="689.130242" y="144.731662" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="734.501055" y="184.134028" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="779.871867" y="155.102776" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="825.24268" y="109.465015" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_57">
+    <g clip-path="url(#pcc2cf7f4a1)">
+     <use xlink:href="#ma498c22696" x="643.759429" y="178.051597" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="689.130242" y="144.731662" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="734.501055" y="183.980243" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="779.871867" y="154.850809" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="825.24268" y="108.699422" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_58">
+    <path d="M 614.722109 197.289056 
+L 854.28 197.289056 
+" clip-path="url(#pcc2cf7f4a1)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_28">
+    <path d="M 614.722109 217.692555 
+L 614.722109 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_29">
+    <path d="M 854.28 217.692555 
+L 854.28 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_30">
+    <path d="M 614.722109 217.692555 
+L 854.28 217.692555 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_31">
+    <path d="M 614.722109 103.249766 
+L 854.28 103.249766 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_38">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="734.501055" y="97.249766" transform="rotate(-0 734.501055 97.249766)">SGNS, order 12 (n=3)</text>
+   </g>
+  </g>
+  <g id="axes_4">
+   <g id="patch_32">
+    <path d="M 45.202109 389.170406 
+L 284.76 389.170406 
+L 284.76 274.727617 
+L 45.202109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_33">
+    <path d="M 56.091104 389.170406 
+L 92.387754 389.170406 
+L 92.387754 326.286229 
+L 56.091104 326.286229 
+z
+" clip-path="url(#pd807334b16)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_34">
+    <path d="M 101.461917 389.170406 
+L 137.758567 389.170406 
+L 137.758567 280.177274 
+L 101.461917 280.177274 
+z
+" clip-path="url(#pd807334b16)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_35">
+    <path d="M 146.83273 389.170406 
+L 183.12938 389.170406 
+L 183.12938 352.94697 
+L 146.83273 352.94697 
+z
+" clip-path="url(#pd807334b16)" style="fill: #599268"/>
+   </g>
+   <g id="patch_36">
+    <path d="M 192.203542 389.170406 
+L 228.500192 389.170406 
+L 228.500192 322.262398 
+L 192.203542 322.262398 
+z
+" clip-path="url(#pd807334b16)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_37">
+    <path d="M 237.574355 389.170406 
+L 273.871005 389.170406 
+L 273.871005 284.927634 
+L 237.574355 284.927634 
+z
+" clip-path="url(#pd807334b16)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_7">
+    <g id="xtick_16">
+     <g id="line2d_59">
+      <g>
+       <use xlink:href="#m25801f5056" x="74.239429" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_39">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(35.721698 419.902666) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_17">
+     <g id="line2d_60">
+      <g>
+       <use xlink:href="#m25801f5056" x="119.610242" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_40">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(82.401417 419.292312) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_18">
+     <g id="line2d_61">
+      <g>
+       <use xlink:href="#m25801f5056" x="164.981055" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_41">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(126.880083 419.708327) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_19">
+     <g id="line2d_62">
+      <g>
+       <use xlink:href="#m25801f5056" x="210.351867" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_42">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(172.250896 419.708327) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_20">
+     <g id="line2d_63">
+      <g>
+       <use xlink:href="#m25801f5056" x="255.72268" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_43">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(218.930615 419.097974) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_8">
+    <g id="ytick_18">
+     <g id="line2d_64">
+      <path d="M 45.202109 389.170406 
+L 284.76 389.170406 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_65">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_44">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="392.589351" transform="rotate(-0 38.202109 392.589351)">0</text>
+     </g>
+    </g>
+    <g id="ytick_19">
+     <g id="line2d_66">
+      <path d="M 45.202109 356.1178 
+L 284.76 356.1178 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_67">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="356.1178" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_45">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="359.536746" transform="rotate(-0 38.202109 359.536746)">1</text>
+     </g>
+    </g>
+    <g id="ytick_20">
+     <g id="line2d_68">
+      <path d="M 45.202109 323.065195 
+L 284.76 323.065195 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_69">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="323.065195" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_46">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="326.48414" transform="rotate(-0 38.202109 326.48414)">2</text>
+     </g>
+    </g>
+    <g id="ytick_21">
+     <g id="line2d_70">
+      <path d="M 45.202109 290.012589 
+L 284.76 290.012589 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_71">
+      <g>
+       <use xlink:href="#m5a40326d10" x="45.202109" y="290.012589" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_47">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="38.202109" y="293.431534" transform="rotate(-0 38.202109 293.431534)">3</text>
+     </g>
+    </g>
+    <g id="text_48">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="26.31375" y="331.949012" transform="rotate(-90 26.31375 331.949012)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_4">
+    <path d="M 74.239429 326.286229 
+L 74.239429 326.286229 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 119.610242 280.177274 
+L 119.610242 280.177274 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 164.981055 352.954155 
+L 164.981055 352.939692 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 210.351867 322.273096 
+L 210.351867 322.254359 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 255.72268 284.949182 
+L 255.72268 284.916756 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_72">
+    <g clip-path="url(#pd807334b16)">
+     <use xlink:href="#ma498c22696" x="74.239429" y="326.286229" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="119.610242" y="280.177274" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="164.981055" y="352.954155" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="210.351867" y="322.273096" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="255.72268" y="284.949182" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_73">
+    <g clip-path="url(#pd807334b16)">
+     <use xlink:href="#ma498c22696" x="74.239429" y="326.286229" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="119.610242" y="280.177274" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="164.981055" y="352.939692" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="210.351867" y="322.254359" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="255.72268" y="284.916756" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_74">
+    <path d="M 45.202109 356.1178 
+L 284.76 356.1178 
+" clip-path="url(#pd807334b16)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_38">
+    <path d="M 45.202109 389.170406 
+L 45.202109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_39">
+    <path d="M 284.76 389.170406 
+L 284.76 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_40">
+    <path d="M 45.202109 389.170406 
+L 284.76 389.170406 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_41">
+    <path d="M 45.202109 274.727617 
+L 284.76 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_49">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="164.981055" y="268.727617" transform="rotate(-0 164.981055 268.727617)">GRU, order 4 (n=3)</text>
+   </g>
+  </g>
+  <g id="axes_5">
+   <g id="patch_42">
+    <path d="M 329.962109 389.170406 
+L 569.52 389.170406 
+L 569.52 274.727617 
+L 329.962109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_43">
+    <path d="M 340.851104 389.170406 
+L 377.147754 389.170406 
+L 377.147754 332.509367 
+L 340.851104 332.509367 
+z
+" clip-path="url(#p84e72e1362)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_44">
+    <path d="M 386.221917 389.170406 
+L 422.518567 389.170406 
+L 422.518567 292.167537 
+L 386.221917 292.167537 
+z
+" clip-path="url(#p84e72e1362)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_45">
+    <path d="M 431.59273 389.170406 
+L 467.88938 389.170406 
+L 467.88938 348.7459 
+L 431.59273 348.7459 
+z
+" clip-path="url(#p84e72e1362)" style="fill: #599268"/>
+   </g>
+   <g id="patch_46">
+    <path d="M 476.963542 389.170406 
+L 513.260192 389.170406 
+L 513.260192 316.550636 
+L 476.963542 316.550636 
+z
+" clip-path="url(#p84e72e1362)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_47">
+    <path d="M 522.334355 389.170406 
+L 558.631005 389.170406 
+L 558.631005 280.236365 
+L 522.334355 280.236365 
+z
+" clip-path="url(#p84e72e1362)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_9">
+    <g id="xtick_21">
+     <g id="line2d_75">
+      <g>
+       <use xlink:href="#m25801f5056" x="358.999429" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_50">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(320.481698 419.902666) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_22">
+     <g id="line2d_76">
+      <g>
+       <use xlink:href="#m25801f5056" x="404.370242" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_51">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(367.161417 419.292312) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_23">
+     <g id="line2d_77">
+      <g>
+       <use xlink:href="#m25801f5056" x="449.741055" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_52">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(411.640083 419.708327) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_24">
+     <g id="line2d_78">
+      <g>
+       <use xlink:href="#m25801f5056" x="495.111867" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_53">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(457.010896 419.708327) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_25">
+     <g id="line2d_79">
+      <g>
+       <use xlink:href="#m25801f5056" x="540.48268" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_54">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(503.690615 419.097974) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_10">
+    <g id="ytick_22">
+     <g id="line2d_80">
+      <path d="M 329.962109 389.170406 
+L 569.52 389.170406 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_81">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_55">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="392.589351" transform="rotate(-0 322.962109 392.589351)">0</text>
+     </g>
+    </g>
+    <g id="ytick_23">
+     <g id="line2d_82">
+      <path d="M 329.962109 359.147079 
+L 569.52 359.147079 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_83">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="359.147079" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_56">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="362.566025" transform="rotate(-0 322.962109 362.566025)">1</text>
+     </g>
+    </g>
+    <g id="ytick_24">
+     <g id="line2d_84">
+      <path d="M 329.962109 329.123753 
+L 569.52 329.123753 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_85">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="329.123753" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_57">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="332.542698" transform="rotate(-0 322.962109 332.542698)">2</text>
+     </g>
+    </g>
+    <g id="ytick_25">
+     <g id="line2d_86">
+      <path d="M 329.962109 299.100426 
+L 569.52 299.100426 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_87">
+      <g>
+       <use xlink:href="#m5a40326d10" x="329.962109" y="299.100426" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_58">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="322.962109" y="302.519371" transform="rotate(-0 322.962109 302.519371)">3</text>
+     </g>
+    </g>
+    <g id="text_59">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="311.07375" y="331.949012" transform="rotate(-90 311.07375 331.949012)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_5">
+    <path d="M 358.999429 332.509367 
+L 358.999429 332.509367 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 404.370242 292.167537 
+L 404.370242 292.167537 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 449.741055 348.763733 
+L 449.741055 348.723337 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 495.111867 316.571679 
+L 495.111867 316.512181 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 540.48268 280.270842 
+L 540.48268 280.177274 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_88">
+    <g clip-path="url(#p84e72e1362)">
+     <use xlink:href="#ma498c22696" x="358.999429" y="332.509367" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="404.370242" y="292.167537" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="449.741055" y="348.763733" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="495.111867" y="316.571679" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="540.48268" y="280.270842" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_89">
+    <g clip-path="url(#p84e72e1362)">
+     <use xlink:href="#ma498c22696" x="358.999429" y="332.509367" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="404.370242" y="292.167537" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="449.741055" y="348.723337" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="495.111867" y="316.512181" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="540.48268" y="280.177274" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_90">
+    <path d="M 329.962109 359.147079 
+L 569.52 359.147079 
+" clip-path="url(#p84e72e1362)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_48">
+    <path d="M 329.962109 389.170406 
+L 329.962109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_49">
+    <path d="M 569.52 389.170406 
+L 569.52 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_50">
+    <path d="M 329.962109 389.170406 
+L 569.52 389.170406 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_51">
+    <path d="M 329.962109 274.727617 
+L 569.52 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_60">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="449.741055" y="268.727617" transform="rotate(-0 449.741055 268.727617)">GRU, order 8 (n=3)</text>
+   </g>
+  </g>
+  <g id="axes_6">
+   <g id="patch_52">
+    <path d="M 614.722109 389.170406 
+L 854.28 389.170406 
+L 854.28 274.727617 
+L 614.722109 274.727617 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="patch_53">
+    <path d="M 625.611104 389.170406 
+L 661.907754 389.170406 
+L 661.907754 334.910895 
+L 625.611104 334.910895 
+z
+" clip-path="url(#p5468449bdd)" style="fill: #5587b6"/>
+   </g>
+   <g id="patch_54">
+    <path d="M 670.981917 389.170406 
+L 707.278567 389.170406 
+L 707.278567 296.645867 
+L 670.981917 296.645867 
+z
+" clip-path="url(#p5468449bdd)" style="fill: #ed9c42"/>
+   </g>
+   <g id="patch_55">
+    <path d="M 716.35273 389.170406 
+L 752.64938 389.170406 
+L 752.64938 347.779177 
+L 716.35273 347.779177 
+z
+" clip-path="url(#p5468449bdd)" style="fill: #599268"/>
+   </g>
+   <g id="patch_56">
+    <path d="M 761.723542 389.170406 
+L 798.020192 389.170406 
+L 798.020192 315.598546 
+L 761.723542 315.598546 
+z
+" clip-path="url(#p5468449bdd)" style="fill: #83b4d7"/>
+   </g>
+   <g id="patch_57">
+    <path d="M 807.094355 389.170406 
+L 843.391005 389.170406 
+L 843.391005 280.189092 
+L 807.094355 280.189092 
+z
+" clip-path="url(#p5468449bdd)" style="fill: #f7bf7a"/>
+   </g>
+   <g id="matplotlib.axis_11">
+    <g id="xtick_26">
+     <g id="line2d_91">
+      <g>
+       <use xlink:href="#m25801f5056" x="643.759429" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_61">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(605.241698 419.902666) rotate(-25)">FP16 raw</text>
+     </g>
+    </g>
+    <g id="xtick_27">
+     <g id="line2d_92">
+      <g>
+       <use xlink:href="#m25801f5056" x="689.130242" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_62">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(651.921417 419.292312) rotate(-25)">INT8 raw</text>
+     </g>
+    </g>
+    <g id="xtick_28">
+     <g id="line2d_93">
+      <g>
+       <use xlink:href="#m25801f5056" x="734.501055" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_63">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(696.400083 419.708327) rotate(-25)">FP32 + S</text>
+     </g>
+    </g>
+    <g id="xtick_29">
+     <g id="line2d_94">
+      <g>
+       <use xlink:href="#m25801f5056" x="779.871867" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_64">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(741.770896 419.708327) rotate(-25)">FP16 + S</text>
+     </g>
+    </g>
+    <g id="xtick_30">
+     <g id="line2d_95">
+      <g>
+       <use xlink:href="#m25801f5056" x="825.24268" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_65">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(788.450615 419.097974) rotate(-25)">INT8 + S</text>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_12">
+    <g id="ytick_26">
+     <g id="line2d_96">
+      <path d="M 614.722109 389.170406 
+L 854.28 389.170406 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_97">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="389.170406" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_66">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="392.589351" transform="rotate(-0 607.722109 392.589351)">0</text>
+     </g>
+    </g>
+    <g id="ytick_27">
+     <g id="line2d_98">
+      <path d="M 614.722109 360.344067 
+L 854.28 360.344067 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_99">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="360.344067" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_67">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="363.763012" transform="rotate(-0 607.722109 363.763012)">1</text>
+     </g>
+    </g>
+    <g id="ytick_28">
+     <g id="line2d_100">
+      <path d="M 614.722109 331.517728 
+L 854.28 331.517728 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_101">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="331.517728" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_68">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="334.936673" transform="rotate(-0 607.722109 334.936673)">2</text>
+     </g>
+    </g>
+    <g id="ytick_29">
+     <g id="line2d_102">
+      <path d="M 614.722109 302.691388 
+L 854.28 302.691388 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.2; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_103">
+      <g>
+       <use xlink:href="#m5a40326d10" x="614.722109" y="302.691388" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_69">
+      <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: end" x="607.722109" y="306.110334" transform="rotate(-0 607.722109 306.110334)">3</text>
+     </g>
+    </g>
+    <g id="text_70">
+     <text style="font-size: 9px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="595.83375" y="331.949012" transform="rotate(-90 595.83375 331.949012)">FP32 raw / stored bytes</text>
+    </g>
+   </g>
+   <g id="LineCollection_6">
+    <path d="M 643.759429 334.910895 
+L 643.759429 334.910895 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 689.130242 296.645867 
+L 689.130242 296.645867 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 734.501055 347.801294 
+L 734.501055 347.762605 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 779.871867 315.640464 
+L 779.871867 315.569535 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+    <path d="M 825.24268 280.199721 
+L 825.24268 280.177274 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #000000; stroke-width: 1.5"/>
+   </g>
+   <g id="line2d_104">
+    <g clip-path="url(#p5468449bdd)">
+     <use xlink:href="#ma498c22696" x="643.759429" y="334.910895" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="689.130242" y="296.645867" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="734.501055" y="347.801294" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="779.871867" y="315.640464" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="825.24268" y="280.199721" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_105">
+    <g clip-path="url(#p5468449bdd)">
+     <use xlink:href="#ma498c22696" x="643.759429" y="334.910895" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="689.130242" y="296.645867" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="734.501055" y="347.762605" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="779.871867" y="315.569535" style="fill: #1f77b4; stroke: #000000"/>
+     <use xlink:href="#ma498c22696" x="825.24268" y="280.177274" style="fill: #1f77b4; stroke: #000000"/>
+    </g>
+   </g>
+   <g id="line2d_106">
+    <path d="M 614.722109 360.344067 
+L 854.28 360.344067 
+" clip-path="url(#p5468449bdd)" style="fill: none; stroke: #808080; stroke-width: 0.8; stroke-linecap: square"/>
+   </g>
+   <g id="patch_58">
+    <path d="M 614.722109 389.170406 
+L 614.722109 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_59">
+    <path d="M 854.28 389.170406 
+L 854.28 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_60">
+    <path d="M 614.722109 389.170406 
+L 854.28 389.170406 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_61">
+    <path d="M 614.722109 274.727617 
+L 854.28 274.727617 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_71">
+    <text style="font-size: 10.8px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif; text-anchor: middle" x="734.501055" y="268.727617" transform="rotate(-0 734.501055 268.727617)">GRU, order 12 (n=3)</text>
+   </g>
+  </g>
+  <g id="text_72">
+   <text style="font-size: 11px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(186.200703 18.099355)">Complete backend + common keys; S = cosine/norm &gt;= 0.99 on decoded encoded rows</text>
+   <text style="font-size: 11px; font-family: 'DejaVu Sans', 'Bitstream Vera Sans', 'Computer Modern Sans Serif', 'Lucida Grande', 'Verdana', 'Geneva', 'Lucid', 'Arial', 'Helvetica', 'Avant Garde', sans-serif" transform="translate(239.738906 31.302363)">Seed ranges; fixed threshold, no task-quality guarantee from this plot</text>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="pfe5d903cca">
+   <rect x="45.202109" y="103.249766" width="239.557891" height="114.442789"/>
+  </clipPath>
+  <clipPath id="pe442726ab6">
+   <rect x="329.962109" y="103.249766" width="239.557891" height="114.442789"/>
+  </clipPath>
+  <clipPath id="pcc2cf7f4a1">
+   <rect x="614.722109" y="103.249766" width="239.557891" height="114.442789"/>
+  </clipPath>
+  <clipPath id="pd807334b16">
+   <rect x="45.202109" y="274.727617" width="239.557891" height="114.442789"/>
+  </clipPath>
+  <clipPath id="p84e72e1362">
+   <rect x="329.962109" y="274.727617" width="239.557891" height="114.442789"/>
+  </clipPath>
+  <clipPath id="p5468449bdd">
+   <rect x="614.722109" y="274.727617" width="239.557891" height="114.442789"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/quantized_structural_evidence_20261031/summary.json b/docs/quantized_structural_evidence_20261031/summary.json
new file mode 100644
index 0000000..121b28f
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/summary.json
@@ -0,0 +1,3586 @@
+{
+  "source_commit": "3a54de2d8a7b97ee1432980c41b4edb0f64566d3",
+  "planner": "native",
+  "trained_models": 18,
+  "variant_count": 486,
+  "storage_denominator": "actual encoded backend + codec metadata + common keys JSON; whole GRU serving artifacts also include unchanged serialized backbone/registry",
+  "baseline_rule": "best of raw mmap / native identity / native layout / exact encoded-byte dedup, matched encoding; structural candidates compared against this lower byte count",
+  "error_rule": "final decoded vectors vs original FP32; additional error separately vs quantization-only; frequency weights from actual query traces",
+  "uncertainty": "three-seed min/mean/max are descriptive ranges, not confidence intervals or cross-corpus evidence",
+  "test_selection": "retain per-encoding validation choices; no test-based replacement",
+  "test_budget_exceedances": [
+    {
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.95",
+      "delta": {
+        "perplexity_relative_change": 0.00041829374079927037,
+        "mean_prediction_kl_nats": 0.0001224659868776353,
+        "prediction_kl_p99_nats": 6.492612482710993e-05,
+        "maximum_prediction_kl_nats": 0.049823547914828695,
+        "top1_changed_fraction": 0.0002300084336425669,
+        "accuracy_change": 0.0,
+        "maximum_absolute_logit_change": 0.6587400436401367,
+        "maximum_per_target_cross_entropy_increase": 0.3685579299926758
+      }
+    },
+    {
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.95",
+      "delta": {
+        "perplexity_relative_change": 0.0004171065973414183,
+        "mean_prediction_kl_nats": 0.0001224485145529409,
+        "prediction_kl_p99_nats": 6.468627058898175e-05,
+        "maximum_prediction_kl_nats": 0.049807480276882234,
+        "top1_changed_fraction": 0.0002300084336425669,
+        "accuracy_change": 0.0,
+        "maximum_absolute_logit_change": 0.6586532592773438,
+        "maximum_per_target_cross_entropy_increase": 0.3685433864593506
+      }
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.95",
+      "delta": {
+        "perplexity_relative_change": 0.00010423505069745625,
+        "mean_prediction_kl_nats": 0.00013875969726630407,
+        "prediction_kl_p99_nats": 0.00038196038107028794,
+        "maximum_prediction_kl_nats": 0.09296217712975313,
+        "top1_changed_fraction": 0.0010733726903319788,
+        "accuracy_change": 7.666947788076417e-05,
+        "maximum_absolute_logit_change": 1.504372239112854,
+        "maximum_per_target_cross_entropy_increase": 0.5252523422241211
+      }
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.95",
+      "delta": {
+        "perplexity_relative_change": 0.00010519237107762973,
+        "mean_prediction_kl_nats": 0.0001388013511152666,
+        "prediction_kl_p99_nats": 0.0003827823135934586,
+        "maximum_prediction_kl_nats": 0.09302745751300914,
+        "top1_changed_fraction": 0.0010733726903319788,
+        "accuracy_change": 7.666947788076417e-05,
+        "maximum_absolute_logit_change": 1.5042415857315063,
+        "maximum_per_target_cross_entropy_increase": 0.5253055095672607
+      }
+    },
+    {
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "name": "int8-joint-0.95",
+      "delta": {
+        "perplexity_relative_change": 6.299487197111428e-05,
+        "mean_prediction_kl_nats": 0.00013896683904643248,
+        "prediction_kl_p99_nats": 0.00035191132917633707,
+        "maximum_prediction_kl_nats": 0.09188349093556392,
+        "top1_changed_fraction": 0.0017633979912596795,
+        "accuracy_change": 0.00015333895576163936,
+        "maximum_absolute_logit_change": 1.4925585985183716,
+        "maximum_per_target_cross_entropy_increase": 0.5185873508453369
+      }
+    },
+    {
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "name": "fp32-joint-0.9",
+      "delta": {
+        "perplexity_relative_change": -0.0002687747523804419,
+        "mean_prediction_kl_nats": 0.0001433063275818475,
+        "prediction_kl_p99_nats": 0.00047574067175172846,
+        "maximum_prediction_kl_nats": 0.14949254966897688,
+        "top1_changed_fraction": 0.0013800506018554013,
+        "accuracy_change": -0.00030667791152338975,
+        "maximum_absolute_logit_change": 1.5382030010223389,
+        "maximum_per_target_cross_entropy_increase": 0.7367382049560547
+      }
+    },
+    {
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "name": "fp16-joint-0.9",
+      "delta": {
+        "perplexity_relative_change": -0.0002686467273177534,
+        "mean_prediction_kl_nats": 0.00014329286792632542,
+        "prediction_kl_p99_nats": 0.0004777807634440265,
+        "maximum_prediction_kl_nats": 0.1495226025186514,
+        "top1_changed_fraction": 0.0013800506018554013,
+        "accuracy_change": -0.00030667791152338975,
+        "maximum_absolute_logit_change": 1.538262128829956,
+        "maximum_per_target_cross_entropy_increase": 0.7369163036346436
+      }
+    }
+  ],
+  "models": [
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 2802233,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 2679981,
+      "joint_099_backend_with_keys_bytes": 2039832,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2388632605977431,
+      "joint_099_saving_vs_raw_encoded": 0.2720690963242528,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.373756760360657,
+      "joint_099_weighted_relative_frobenius": 0.00684819310974004,
+      "joint_099_added_weighted_relative_frobenius": 0.00684819310974004,
+      "joint_099_max_relative_l2": 0.14212765851757603,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1351826966148333,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.24137410952742033,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.3789356019073995
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1436986,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1401408,
+      "joint_099_backend_with_keys_bytes": 1081785,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2280727668173722,
+      "joint_099_saving_vs_raw_encoded": 0.2471847324886951,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.590378864561812,
+      "joint_099_weighted_relative_frobenius": 0.0068512795300496,
+      "joint_099_added_weighted_relative_frobenius": 0.006848195096817759,
+      "joint_099_max_relative_l2": 0.14214298103013276,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0375786909548252,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.23270187036322465,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.6324476448111644
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 775737,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 775737,
+      "joint_099_backend_with_keys_bytes": 621162,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.19926212105391394,
+      "joint_099_saving_vs_raw_encoded": 0.19926212105391394,
+      "joint_099_factor_vs_raw_float32_with_keys": 4.511275641459072,
+      "joint_099_weighted_relative_frobenius": 0.009423937975726222,
+      "joint_099_added_weighted_relative_frobenius": 0.006974880559954164,
+      "joint_099_max_relative_l2": 0.14188875915362323,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0675390597903482,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.20669003114223405,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.676268026779755
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 2802233,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 2679584,
+      "joint_099_backend_with_keys_bytes": 2029029,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.24278208856300088,
+      "joint_099_saving_vs_raw_encoded": 0.2759242361359673,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.3810709457577985,
+      "joint_099_weighted_relative_frobenius": 0.006743679010149183,
+      "joint_099_added_weighted_relative_frobenius": 0.006743679010149183,
+      "joint_099_max_relative_l2": 0.14087181586808722,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1301373730529407,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.24533451295128494,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.386379638518033
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1436986,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1401405,
+      "joint_099_backend_with_keys_bytes": 1075994,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.23220339587770844,
+      "joint_099_saving_vs_raw_encoded": 0.2512146952023193,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.604320284313853,
+      "joint_099_weighted_relative_frobenius": 0.006748195908759052,
+      "joint_099_added_weighted_relative_frobenius": 0.0067452159501694255,
+      "joint_099_max_relative_l2": 0.1408746714806218,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.039525,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.2369163474762418,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.64699231764423
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 775737,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 775737,
+      "joint_099_backend_with_keys_bytes": 618504,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.20268854005932424,
+      "joint_099_saving_vs_raw_encoded": 0.20268854005932424,
+      "joint_099_factor_vs_raw_float32_with_keys": 4.530662695795015,
+      "joint_099_weighted_relative_frobenius": 0.009414340895132815,
+      "joint_099_added_weighted_relative_frobenius": 0.006861641269675814,
+      "joint_099_max_relative_l2": 0.1411979477508241,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0735416564627516,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.2102441770440685,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.697312681798634
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 2802233,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 2679520,
+      "joint_099_backend_with_keys_bytes": 2040209,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2385916134232997,
+      "joint_099_saving_vs_raw_encoded": 0.27193456075922307,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.3735029107312045,
+      "joint_099_weighted_relative_frobenius": 0.006788218213522045,
+      "joint_099_added_weighted_relative_frobenius": 0.006788218213522045,
+      "joint_099_max_relative_l2": 0.14137685298673708,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1413276576532998,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.24110004291680398,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.3786772653206654
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1436986,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1401091,
+      "joint_099_backend_with_keys_bytes": 1081734,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2279345167444513,
+      "joint_099_saving_vs_raw_encoded": 0.24722022343989436,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.5905009919259263,
+      "joint_099_weighted_relative_frobenius": 0.006792836185212061,
+      "joint_099_added_weighted_relative_frobenius": 0.0067896740613937155,
+      "joint_099_max_relative_l2": 0.14139286698093315,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.037615823600401,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.23256188224259455,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.632575038714967
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 775737,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 775737,
+      "joint_099_backend_with_keys_bytes": 621331,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.19904426371308837,
+      "joint_099_saving_vs_raw_encoded": 0.19904426371308837,
+      "joint_099_factor_vs_raw_float32_with_keys": 4.510048589238265,
+      "joint_099_weighted_relative_frobenius": 0.00940051238979808,
+      "joint_099_added_weighted_relative_frobenius": 0.006914346925094502,
+      "joint_099_max_relative_l2": 0.1417056444563921,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0778523599944267,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.20646405271581947,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.674936347107521
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7077841,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6685716,
+      "joint_099_backend_with_keys_bytes": 4301281,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.356646169236025,
+      "joint_099_saving_vs_raw_encoded": 0.3922891175430474,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6455193231969731,
+      "joint_099_weighted_relative_frobenius": 0.009587863324407826,
+      "joint_099_added_weighted_relative_frobenius": 0.009587863324407826,
+      "joint_099_max_relative_l2": 0.14211742856778714,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.149934767889287,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3618064870507832,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6601544250075786
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3641298,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3452287,
+      "joint_099_backend_with_keys_bytes": 2308296,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.33137192823192274,
+      "joint_099_saving_vs_raw_encoded": 0.36607879937319054,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0662622991158845,
+      "joint_099_weighted_relative_frobenius": 0.009591286480164959,
+      "joint_099_added_weighted_relative_frobenius": 0.009589247498575619,
+      "joint_099_max_relative_l2": 0.14211255515914975,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.036509090909091,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3407847822907293,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.155297929451318
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 1976766,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1860550,
+      "joint_099_backend_with_keys_bytes": 1334408,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2827884227782107,
+      "joint_099_saving_vs_raw_encoded": 0.32495399050772833,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.304105640853472,
+      "joint_099_weighted_relative_frobenius": 0.011525639114851247,
+      "joint_099_added_weighted_relative_frobenius": 0.009713811108145775,
+      "joint_099_max_relative_l2": 0.14306266325996833,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0692774268035872,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.29806468864045543,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.63534460216359
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7077841,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6687782,
+      "joint_099_backend_with_keys_bytes": 4285923,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3591413416286595,
+      "joint_099_saving_vs_raw_encoded": 0.3944589882705757,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6514158093834164,
+      "joint_099_weighted_relative_frobenius": 0.009429837428214146,
+      "joint_099_added_weighted_relative_frobenius": 0.009429837428214146,
+      "joint_099_max_relative_l2": 0.14236738964640794,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1489232585983502,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3643361336175788,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6662387213949807
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3641298,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3453902,
+      "joint_099_backend_with_keys_bytes": 2300988,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3338004378815612,
+      "joint_099_saving_vs_raw_encoded": 0.36808577600624837,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0760008309474016,
+      "joint_099_weighted_relative_frobenius": 0.009429329011061569,
+      "joint_099_added_weighted_relative_frobenius": 0.009427344865478818,
+      "joint_099_max_relative_l2": 0.1423848947835388,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0368272727272727,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.34327771601163126,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.165752491802803
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 1976766,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1856058,
+      "joint_099_backend_with_keys_bytes": 1326283,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.28543019668566394,
+      "joint_099_saving_vs_raw_encoded": 0.32906423926757133,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.336599353230042,
+      "joint_099_weighted_relative_frobenius": 0.011437149201513133,
+      "joint_099_added_weighted_relative_frobenius": 0.00957913732749358,
+      "joint_099_max_relative_l2": 0.14274862236861094,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.078121273428569,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.30088850924233634,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.6725419135334585
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7077841,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6688172,
+      "joint_099_backend_with_keys_bytes": 4305324,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3562779186898901,
+      "joint_099_saving_vs_raw_encoded": 0.3917178981556664,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6439740655987796,
+      "joint_099_weighted_relative_frobenius": 0.009517378602255747,
+      "joint_099_added_weighted_relative_frobenius": 0.009517378602255747,
+      "joint_099_max_relative_l2": 0.14199628030247896,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1293635966132687,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3614309879116906,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6585601125709268
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3641298,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3454732,
+      "joint_099_backend_with_keys_bytes": 2310183,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.33129892564748875,
+      "joint_099_saving_vs_raw_encoded": 0.36556057757426064,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0637577196265404,
+      "joint_099_weighted_relative_frobenius": 0.009520497179207372,
+      "joint_099_added_weighted_relative_frobenius": 0.009518618838387841,
+      "joint_099_max_relative_l2": 0.14199922735932338,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0364142927742688,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3407028567210101,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.1526096620638993
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 1976766,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1849681,
+      "joint_099_backend_with_keys_bytes": 1330314,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2807873357622206,
+      "joint_099_saving_vs_raw_encoded": 0.32702505000591875,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.320428861156088,
+      "joint_099_weighted_relative_frobenius": 0.012055645188533535,
+      "joint_099_added_weighted_relative_frobenius": 0.00963143524074153,
+      "joint_099_max_relative_l2": 0.14283478277746048,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0735416564627516,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.29604947771935075,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.6540262907726415
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7454867,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 7029964,
+      "joint_099_backend_with_keys_bytes": 4527126,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.35602429827521165,
+      "joint_099_saving_vs_raw_encoded": 0.39272880388073994,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6467107387777589,
+      "joint_099_weighted_relative_frobenius": 0.009597568466419546,
+      "joint_099_added_weighted_relative_frobenius": 0.009597568466419546,
+      "joint_099_max_relative_l2": 0.14213808847272216,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1747773128392094,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.36141031635485366,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6620313588219864
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3837076,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3626449,
+      "joint_099_backend_with_keys_bytes": 2428020,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3304690070093361,
+      "joint_099_saving_vs_raw_encoded": 0.3672212903784027,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0703482673124602,
+      "joint_099_weighted_relative_frobenius": 0.009600233959965716,
+      "joint_099_added_weighted_relative_frobenius": 0.009598270767519452,
+      "joint_099_max_relative_l2": 0.14217809684457094,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0363361657654384,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3403000781160599,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.1637096073007944
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 2084752,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1953224,
+      "joint_099_backend_with_keys_bytes": 1405422,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2804604080228381,
+      "joint_099_saving_vs_raw_encoded": 0.3258565047545223,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.304361963879888,
+      "joint_099_weighted_relative_frobenius": 0.011273324565210031,
+      "joint_099_added_weighted_relative_frobenius": 0.009708818886474999,
+      "joint_099_max_relative_l2": 0.14267755652829675,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0778555181250178,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.29635620609178026,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.65107222816794
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7454867,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 7030864,
+      "joint_099_backend_with_keys_bytes": 4511864,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.35827744641341375,
+      "joint_099_saving_vs_raw_encoded": 0.3947760570376373,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6522809641425362,
+      "joint_099_weighted_relative_frobenius": 0.009467831744684692,
+      "joint_099_added_weighted_relative_frobenius": 0.009467831744684692,
+      "joint_099_max_relative_l2": 0.1422066988799605,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1662823511783362,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3636968463339676,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6677870562442678
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3837076,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3626389,
+      "joint_099_backend_with_keys_bytes": 2420451,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3325451296041324,
+      "joint_099_saving_vs_raw_encoded": 0.3691938861779126,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0799495631186087,
+      "joint_099_weighted_relative_frobenius": 0.009470324713106664,
+      "joint_099_added_weighted_relative_frobenius": 0.009468034050420173,
+      "joint_099_max_relative_l2": 0.1422308437423335,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0361909090909092,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3424381315092502,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.1740504429574834
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 2084752,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1946680,
+      "joint_099_backend_with_keys_bytes": 1395550,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2831127868987199,
+      "joint_099_saving_vs_raw_encoded": 0.3305918401805107,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.341884561642363,
+      "joint_099_weighted_relative_frobenius": 0.011592827136221024,
+      "joint_099_added_weighted_relative_frobenius": 0.009600591901907743,
+      "joint_099_max_relative_l2": 0.14200820684716933,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0753869892808483,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.29921592430482635,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.694291996182165
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 7454867,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 7032071,
+      "joint_099_backend_with_keys_bytes": 4532540,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.3554473497210139,
+      "joint_099_saving_vs_raw_encoded": 0.39200256691366864,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.6447437860449108,
+      "joint_099_weighted_relative_frobenius": 0.009554490322035257,
+      "joint_099_added_weighted_relative_frobenius": 0.009554490322035257,
+      "joint_099_max_relative_l2": 0.1419349417581233,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1280072991532342,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.3608230040398106,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.6599991327470642
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 3837076,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3628003,
+      "joint_099_backend_with_keys_bytes": 2430195,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.33015628708135025,
+      "joint_099_saving_vs_raw_encoded": 0.3666544525049803,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.0676003365985034,
+      "joint_099_weighted_relative_frobenius": 0.009560715856289807,
+      "joint_099_added_weighted_relative_frobenius": 0.009558478461585218,
+      "joint_099_max_relative_l2": 0.1419611647297449,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.036754915059693,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.33997372302799955,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.1607505539838026
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 2084752,
+      "best_encoded_baseline": "int8-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1944152,
+      "joint_099_backend_with_keys_bytes": 1402010,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2788578259313058,
+      "joint_099_saving_vs_raw_encoded": 0.32749315026439596,
+      "joint_099_factor_vs_raw_float32_with_keys": 5.3172709181817535,
+      "joint_099_weighted_relative_frobenius": 0.011588159396950687,
+      "joint_099_added_weighted_relative_frobenius": 0.00966408415736297,
+      "joint_099_max_relative_l2": 0.142252491783661,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0752103506868385,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.294740745009476,
+      "joint_099_factor_vs_raw_float32_with_datrie": 5.665935629688787
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 3173089,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3071670,
+      "joint_099_backend_with_keys_bytes": 2895339,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.05740558067761181,
+      "joint_099_saving_vs_raw_encoded": 0.0875330001774296,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.0959300448064977,
+      "joint_099_weighted_relative_frobenius": 0.0052940877733579465,
+      "joint_099_added_weighted_relative_frobenius": 0.0052940877733579465,
+      "joint_099_max_relative_l2": 0.14017569822550982,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.174781279807998,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.05867480804265901,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.0981832475872195,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.9",
+        "backend_with_key_registry_bytes": 2893447,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.610478337983415,
+          "character_perplexity": 5.005204834898665,
+          "next_character_accuracy": 0.5303227785018784,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00012570950190301332,
+          "mean_prediction_kl_nats": 3.522476674748964e-05,
+          "prediction_kl_p99_nats": 3.073411681134878e-05,
+          "maximum_prediction_kl_nats": 0.069073305132374,
+          "top1_changed_fraction": 0.0007666947788085563,
+          "accuracy_change": 0.0,
+          "maximum_absolute_logit_change": 0.6207461357116699,
+          "maximum_per_target_cross_entropy_increase": 0.810072660446167
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -4.4151146362623543e-05,
+            0.00031408959841323583
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.058021532260952524,
+      "selected_factor_vs_raw_float32_with_keys": 1.0966466639962646,
+      "selected_full_model_factor_vs_raw_float32": 1.087713404679165
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1667810,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1654552,
+      "joint_099_backend_with_keys_bytes": 1567320,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.05272242879039157,
+      "joint_099_saving_vs_raw_encoded": 0.06025266667066398,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.0245316846591632,
+      "joint_099_weighted_relative_frobenius": 0.005302751473250229,
+      "joint_099_added_weighted_relative_frobenius": 0.005299381939658822,
+      "joint_099_max_relative_l2": 0.14016502249394194,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0618789300797746,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.054928288836961214,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.069888565003748,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.9",
+        "backend_with_key_registry_bytes": 1566355,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6104803438537196,
+          "character_perplexity": 5.0052148747004805,
+          "next_character_accuracy": 0.5303227785018784,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00012771562637668983,
+          "mean_prediction_kl_nats": 3.5253858489440136e-05,
+          "prediction_kl_p99_nats": 3.0714668360973565e-05,
+          "maximum_prediction_kl_nats": 0.0691435144903208,
+          "top1_changed_fraction": 0.0007666947788085563,
+          "accuracy_change": 0.0,
+          "maximum_absolute_logit_change": 0.6211075782775879,
+          "maximum_per_target_cross_entropy_increase": 0.8102507591247559
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -4.18414171096396e-05,
+            0.00031688913937407293
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.05330566824131244,
+      "selected_factor_vs_raw_float32_with_keys": 2.0257789581544414,
+      "selected_full_model_factor_vs_raw_float32": 1.8633522850920534
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 962252,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 962252,
+      "joint_099_backend_with_keys_bytes": 1006310,
+      "joint_099_added_saving_vs_best_encoded_baseline": -0.04578634287068262,
+      "joint_099_saving_vs_raw_encoded": -0.04578634287068262,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.153192356232175,
+      "joint_099_weighted_relative_frobenius": 0.007636228340675911,
+      "joint_099_added_weighted_relative_frobenius": 0.005520060633454694,
+      "joint_099_max_relative_l2": 0.12213938394952205,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1206418242604694,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": -0.04918246899164669,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.305415139408319,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-raw",
+        "backend_with_key_registry_bytes": 962252,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6103997491236468,
+          "character_perplexity": 5.004811497013974,
+          "next_character_accuracy": 0.5307061258912826,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 4.711385118005514e-05,
+          "mean_prediction_kl_nats": 3.3553609696799543e-06,
+          "prediction_kl_p99_nats": 2.355900870385665e-05,
+          "maximum_prediction_kl_nats": 7.72629051648873e-05,
+          "top1_changed_fraction": 0.0013800506018554013,
+          "accuracy_change": 0.00038334738940426494,
+          "maximum_absolute_logit_change": 0.029384613037109375,
+          "maximum_per_target_cross_entropy_increase": 0.021229267120361328
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            8.000077854203593e-07,
+            9.973376735015557e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.0,
+      "selected_factor_vs_raw_float32_with_keys": 3.2975655025918367,
+      "selected_full_model_factor_vs_raw_float32": 2.7589069627937097
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 3173089,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3071649,
+      "joint_099_backend_with_keys_bytes": 2895906,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.057214545021257335,
+      "joint_099_saving_vs_raw_encoded": 0.08735430994844451,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.095715468665074,
+      "joint_099_weighted_relative_frobenius": 0.005299696904874133,
+      "joint_099_added_weighted_relative_frobenius": 0.005299696904874133,
+      "joint_099_max_relative_l2": 0.11643283329987608,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1615017998270556,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.05847955746099098,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.0979631809733372,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.95",
+        "backend_with_key_registry_bytes": 2894980,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6159370315575023,
+          "character_perplexity": 5.0326014211237675,
+          "next_character_accuracy": 0.5292494058115464,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00041829374079927037,
+          "mean_prediction_kl_nats": 0.0001224659868776353,
+          "prediction_kl_p99_nats": 6.492612482710993e-05,
+          "maximum_prediction_kl_nats": 0.049823547914828695,
+          "top1_changed_fraction": 0.0002300084336425669,
+          "accuracy_change": 0.0,
+          "maximum_absolute_logit_change": 0.6587400436401367,
+          "maximum_per_target_cross_entropy_increase": 0.3685579299926758
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            9.471540831570154e-05,
+            0.0007101388272276771
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.05751601175785381,
+      "selected_factor_vs_raw_float32_with_keys": 1.0960659486421322,
+      "selected_full_model_factor_vs_raw_float32": 1.0871906337528756
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1667810,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1654548,
+      "joint_099_backend_with_keys_bytes": 1567759,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.05245480941018332,
+      "joint_099_saving_vs_raw_encoded": 0.05998944723919386,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.023964780301054,
+      "joint_099_weighted_relative_frobenius": 0.0053040528702744776,
+      "joint_099_added_weighted_relative_frobenius": 0.005301355563665608,
+      "joint_099_max_relative_l2": 0.1164297624166434,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0363339928189348,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.054649478025039944,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.0692833078223476,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.95",
+        "backend_with_key_registry_bytes": 1567336,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6159358449097074,
+          "character_perplexity": 5.032595449201931,
+          "next_character_accuracy": 0.5292494058115464,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.0004171065973414183,
+          "mean_prediction_kl_nats": 0.0001224485145529409,
+          "prediction_kl_p99_nats": 6.468627058898175e-05,
+          "maximum_prediction_kl_nats": 0.049807480276882234,
+          "top1_changed_fraction": 0.0002300084336425669,
+          "accuracy_change": 0.0,
+          "maximum_absolute_logit_change": 0.6586532592773438,
+          "maximum_per_target_cross_entropy_increase": 0.3685433864593506
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            9.510922932824986e-05,
+            0.0007089831271132332
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.052710468357521245,
+      "selected_factor_vs_raw_float32_with_keys": 2.024511017420642,
+      "selected_full_model_factor_vs_raw_float32": 1.862370584235847
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 962252,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 962252,
+      "joint_099_backend_with_keys_bytes": 1005997,
+      "joint_099_added_saving_vs_best_encoded_baseline": -0.045461064253438765,
+      "joint_099_saving_vs_raw_encoded": -0.045461064253438765,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.154173421988336,
+      "joint_099_weighted_relative_frobenius": 0.007637971226019644,
+      "joint_099_added_weighted_relative_frobenius": 0.005479980336186081,
+      "joint_099_max_relative_l2": 0.11602073490844073,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1232070236978005,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": -0.0488330633719094,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.3065162971288444,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-raw",
+        "backend_with_key_registry_bytes": 962252,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.615536524896122,
+          "character_perplexity": 5.0305862343053445,
+          "next_character_accuracy": 0.5290960668557847,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 1.7699775619881114e-05,
+          "mean_prediction_kl_nats": 3.5440430999465437e-06,
+          "prediction_kl_p99_nats": 2.424724186036613e-05,
+          "maximum_prediction_kl_nats": 0.00011723431737023591,
+          "top1_changed_fraction": 0.0010733726903319788,
+          "accuracy_change": -0.00015333895576175038,
+          "maximum_absolute_logit_change": 0.02951216697692871,
+          "maximum_per_target_cross_entropy_increase": 0.0291440486907959
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -3.6594241267184036e-05,
+            7.115336931680388e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.0,
+      "selected_factor_vs_raw_float32_with_keys": 3.2975655025918367,
+      "selected_full_model_factor_vs_raw_float32": 2.7589069627937097
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 3173089,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 3071342,
+      "joint_099_backend_with_keys_bytes": 2894750,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.057496690371830916,
+      "joint_099_saving_vs_raw_encoded": 0.08771862371335948,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.0961530356680196,
+      "joint_099_weighted_relative_frobenius": 0.005649047524990139,
+      "joint_099_added_weighted_relative_frobenius": 0.005649047524990139,
+      "joint_099_max_relative_l2": 0.11261831137802518,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.2134813021805575,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.05876807091890335,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.0984119463777775,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.9",
+        "backend_with_key_registry_bytes": 2891408,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.605444559273432,
+          "character_perplexity": 4.98007304835536,
+          "next_character_accuracy": 0.5310128038028061,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -5.5385669269262635e-05,
+          "mean_prediction_kl_nats": 2.0394254485204406e-05,
+          "prediction_kl_p99_nats": 6.292058917393448e-05,
+          "maximum_prediction_kl_nats": 0.028937972454724202,
+          "top1_changed_fraction": 0.00038334738940427816,
+          "accuracy_change": -7.666947788087519e-05,
+          "maximum_absolute_logit_change": 0.6746394634246826,
+          "maximum_per_target_cross_entropy_increase": 0.259132981300354
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00013110323318399718,
+            2.8910119316644106e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.05858481406499183,
+      "selected_factor_vs_raw_float32_with_keys": 1.0974200112886179,
+      "selected_full_model_factor_vs_raw_float32": 1.0884095070641355
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 1667810,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 1654633,
+      "joint_099_backend_with_keys_bytes": 1567446,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.05269265148223201,
+      "joint_099_saving_vs_raw_encoded": 0.06017711849671126,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.0243689415775727,
+      "joint_099_weighted_relative_frobenius": 0.005608434419236457,
+      "joint_099_added_weighted_relative_frobenius": 0.005604080214656733,
+      "joint_099_max_relative_l2": 0.11263148326372621,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0635481057016951,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.05489715323374811,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.069714810316582,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.9",
+        "backend_with_key_registry_bytes": 1565742,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6054448741033316,
+          "character_perplexity": 4.980074616231503,
+          "next_character_accuracy": 0.5310128038028061,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -5.5070856757365275e-05,
+          "mean_prediction_kl_nats": 2.0374639076691894e-05,
+          "prediction_kl_p99_nats": 6.243811826060971e-05,
+          "maximum_prediction_kl_nats": 0.028911209971021787,
+          "top1_changed_fraction": 0.00038334738940427816,
+          "accuracy_change": -7.666947788087519e-05,
+          "maximum_absolute_logit_change": 0.67431640625,
+          "maximum_per_target_cross_entropy_increase": 0.2590094804763794
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00012999504614585823,
+            2.8694272122474748e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.05372248710136929,
+      "selected_factor_vs_raw_float32_with_keys": 2.0265720661513837,
+      "selected_full_model_factor_vs_raw_float32": 1.8639662486266602
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 962252,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 962252,
+      "joint_099_backend_with_keys_bytes": 1005999,
+      "joint_099_added_saving_vs_best_encoded_baseline": -0.045463142711057,
+      "joint_099_saving_vs_raw_encoded": -0.045463142711057,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.154167151259594,
+      "joint_099_weighted_relative_frobenius": 0.007915395391086759,
+      "joint_099_added_weighted_relative_frobenius": 0.005829303558166024,
+      "joint_099_max_relative_l2": 0.11380766731945188,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1052328226907326,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": -0.04883529599567771,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.3065092586482523,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-raw",
+        "backend_with_key_registry_bytes": 962252,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.6055288730005035,
+          "character_perplexity": 4.980492954576834,
+          "next_character_accuracy": 0.5311661427585678,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 2.8926942335284213e-05,
+          "mean_prediction_kl_nats": 3.594473232078083e-06,
+          "prediction_kl_p99_nats": 2.5250991242415894e-05,
+          "maximum_prediction_kl_nats": 9.39906069725258e-05,
+          "top1_changed_fraction": 0.0011500421682128345,
+          "accuracy_change": 7.666947788076417e-05,
+          "maximum_absolute_logit_change": 0.03656506538391113,
+          "maximum_per_target_cross_entropy_increase": 0.019799232482910156
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -2.5258228333548203e-05,
+            8.626173798269781e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.0,
+      "selected_factor_vs_raw_float32_with_keys": 3.2975655025918367,
+      "selected_full_model_factor_vs_raw_float32": 2.7589069627937097
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 10013493,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 9681520,
+      "joint_099_backend_with_keys_bytes": 7440315,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.23149309199381918,
+      "joint_099_saving_vs_raw_encoded": 0.25697106893668376,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.345842615534423,
+      "joint_099_weighted_relative_frobenius": 0.011433905190859801,
+      "joint_099_added_weighted_relative_frobenius": 0.011433905190859801,
+      "joint_099_max_relative_l2": 0.1407557896887402,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1877255184964386,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.23896095504842274,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.3605024773899466,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.95",
+        "backend_with_key_registry_bytes": 7430160,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.733085906821203,
+          "character_perplexity": 5.658087325916751,
+          "next_character_accuracy": 0.5241892202714099,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00010423505069745625,
+          "mean_prediction_kl_nats": 0.00013875969726630407,
+          "prediction_kl_p99_nats": 0.00038196038107028794,
+          "maximum_prediction_kl_nats": 0.09296217712975313,
+          "top1_changed_fraction": 0.0010733726903319788,
+          "accuracy_change": 7.666947788076417e-05,
+          "maximum_absolute_logit_change": 1.504372239112854,
+          "maximum_per_target_cross_entropy_increase": 0.5252523422241211
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00022564232065017386,
+            0.0003975916668243442
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.23254199753757676,
+      "selected_factor_vs_raw_float32_with_keys": 1.3476820149229627,
+      "selected_full_model_factor_vs_raw_float32": 1.3177469613751664
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 5305910,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 5248623,
+      "joint_099_backend_with_keys_bytes": 4141097,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.21101267894455367,
+      "joint_099_saving_vs_raw_encoded": 0.21953123969309696,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.4180773838429768,
+      "joint_099_weighted_relative_frobenius": 0.011436593582149768,
+      "joint_099_added_weighted_relative_frobenius": 0.011436043946536932,
+      "joint_099_max_relative_l2": 0.1407469103080355,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0654486678895083,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.22392076767335312,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.5298530481412707,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.95",
+        "backend_with_key_registry_bytes": 4136212,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.733086864041349,
+          "character_perplexity": 5.658092741954519,
+          "next_character_accuracy": 0.5241892202714099,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00010519237107762973,
+          "mean_prediction_kl_nats": 0.0001388013511152666,
+          "prediction_kl_p99_nats": 0.0003827823135934586,
+          "maximum_prediction_kl_nats": 0.09302745751300914,
+          "top1_changed_fraction": 0.0010733726903319788,
+          "accuracy_change": 7.666947788076417e-05,
+          "maximum_absolute_logit_change": 1.5042415857315063,
+          "maximum_per_target_cross_entropy_increase": 0.5253055095672607
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00022603695046941323,
+            0.00039856463735664214
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.21194339924966987,
+      "selected_factor_vs_raw_float32_with_keys": 2.4209332113537703,
+      "selected_full_model_factor_vs_raw_float32": 2.2152658796867795
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3099273,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3099273,
+      "joint_099_backend_with_keys_bytes": 2760694,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.10924465189094346,
+      "joint_099_saving_vs_raw_encoded": 0.10924465189094346,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.627165125870524,
+      "joint_099_weighted_relative_frobenius": 0.01266636913425628,
+      "joint_099_added_weighted_relative_frobenius": 0.011752570284712499,
+      "joint_099_max_relative_l2": 0.13922942015502465,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1508901824706497,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.12106323425508236,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.950531561961863,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.95",
+        "backend_with_key_registry_bytes": 2757967,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7330446700904785,
+          "character_perplexity": 5.657854009703907,
+          "next_character_accuracy": 0.5242658897492908,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 6.299487197111428e-05,
+          "mean_prediction_kl_nats": 0.00013896683904643248,
+          "prediction_kl_p99_nats": 0.00035191132917633707,
+          "maximum_prediction_kl_nats": 0.09188349093556392,
+          "top1_changed_fraction": 0.0017633979912596795,
+          "accuracy_change": 0.00015333895576163936,
+          "maximum_absolute_logit_change": 1.4925585985183716,
+          "maximum_per_target_cross_entropy_increase": 0.5185873508453369
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0002516761914661864,
+            0.00035003994847103626
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.11012453565723312,
+      "selected_factor_vs_raw_float32_with_keys": 3.630751564467595,
+      "selected_full_model_factor_vs_raw_float32": 3.0982068933606906
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 10013493,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 9681369,
+      "joint_099_backend_with_keys_bytes": 7432884,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.23224866235343367,
+      "joint_099_saving_vs_raw_encoded": 0.2577131676229264,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.347188117021603,
+      "joint_099_weighted_relative_frobenius": 0.011233518943283134,
+      "joint_099_added_weighted_relative_frobenius": 0.011233518943283134,
+      "joint_099_max_relative_l2": 0.1398521329039012,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1570228240486526,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.23974102039406286,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.3619203505928132,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.97",
+        "backend_with_key_registry_bytes": 7425813,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7263920138538618,
+          "character_perplexity": 5.620339176943785,
+          "next_character_accuracy": 0.5251859234838611,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -9.943168672067081e-05,
+          "mean_prediction_kl_nats": 3.599514161387495e-05,
+          "prediction_kl_p99_nats": 0.00012654597219580023,
+          "maximum_prediction_kl_nats": 0.04607604998831831,
+          "top1_changed_fraction": 0.0013033811239745456,
+          "accuracy_change": 7.666947788087519e-05,
+          "maximum_absolute_logit_change": 0.7387614250183105,
+          "maximum_per_target_cross_entropy_increase": 0.36521947383880615
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00019782683373067314,
+            4.029123812401072e-06
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.2329790342667447,
+      "selected_factor_vs_raw_float32_with_keys": 1.3484709351016515,
+      "selected_full_model_factor_vs_raw_float32": 1.3184519059082225
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 5305910,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 5249177,
+      "joint_099_backend_with_keys_bytes": 4137706,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.21174195497694215,
+      "joint_099_saving_vs_raw_encoded": 0.22017033835854738,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.4200590858799536,
+      "joint_099_weighted_relative_frobenius": 0.011234116695951897,
+      "joint_099_added_weighted_relative_frobenius": 0.011232898757745064,
+      "joint_099_max_relative_l2": 0.139832944885907,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0567026305344063,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.22469320440478902,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.532089920980823,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.97",
+        "backend_with_key_registry_bytes": 4134227,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.726390375275437,
+          "character_perplexity": 5.620329967584816,
+          "next_character_accuracy": 0.5251859234838611,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -0.00010107010087641331,
+          "mean_prediction_kl_nats": 3.6004410187967044e-05,
+          "prediction_kl_p99_nats": 0.00012695645761842848,
+          "maximum_prediction_kl_nats": 0.04610446029724359,
+          "top1_changed_fraction": 0.0013033811239745456,
+          "accuracy_change": 7.666947788087519e-05,
+          "maximum_absolute_logit_change": 0.739013671875,
+          "maximum_per_target_cross_entropy_increase": 0.36529219150543213
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0001983225788790956,
+            1.5536949280217424e-06
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.21240472554078482,
+      "selected_factor_vs_raw_float32_with_keys": 2.4220955936865587,
+      "selected_full_model_factor_vs_raw_float32": 2.2161754986580062
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3099273,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3099273,
+      "joint_099_backend_with_keys_bytes": 2758324,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.1100093473533954,
+      "joint_099_saving_vs_raw_encoded": 0.1100093473533954,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.630281649291381,
+      "joint_099_weighted_relative_frobenius": 0.012475970273467448,
+      "joint_099_added_weighted_relative_frobenius": 0.011543854934588026,
+      "joint_099_max_relative_l2": 0.13970731928662025,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1356318727090968,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.12191065794404288,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.954344128484711,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.97",
+        "backend_with_key_registry_bytes": 2756386,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7263646895656914,
+          "character_perplexity": 5.6201856072746,
+          "next_character_accuracy": 0.5252625929617419,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -0.00012675288472309662,
+          "mean_prediction_kl_nats": 3.98149611035077e-05,
+          "prediction_kl_p99_nats": 0.0001327648061789036,
+          "maximum_prediction_kl_nats": 0.045853842864706854,
+          "top1_changed_fraction": 0.0018400674691405351,
+          "accuracy_change": 0.00015333895576175038,
+          "maximum_absolute_logit_change": 0.7336316108703613,
+          "maximum_per_target_cross_entropy_increase": 0.36336004734039307
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0002373574082006347,
+            -1.4517555775323528e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.11063465528851446,
+      "selected_factor_vs_raw_float32_with_keys": 3.632834080567816,
+      "selected_full_model_factor_vs_raw_float32": 3.09962405797504
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 10013493,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 9680528,
+      "joint_099_backend_with_keys_bytes": 7437903,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.23166350017271786,
+      "joint_099_saving_vs_raw_encoded": 0.2572119439240632,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.3462790520392642,
+      "joint_099_weighted_relative_frobenius": 0.011360509821225311,
+      "joint_099_added_weighted_relative_frobenius": 0.011360509821225311,
+      "joint_099_max_relative_l2": 0.14115591128178223,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1783718155366227,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.23913765104952922,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.360962375734758,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.9",
+        "backend_with_key_registry_bytes": 7422143,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7281426950457552,
+          "character_perplexity": 5.630187216906834,
+          "next_character_accuracy": 0.5290193973779038,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 7.878053941357795e-05,
+          "mean_prediction_kl_nats": 7.239235945488115e-05,
+          "prediction_kl_p99_nats": 0.00025523719050292914,
+          "maximum_prediction_kl_nats": 0.15028831154148714,
+          "top1_changed_fraction": 0.0007666947788085563,
+          "accuracy_change": -0.00023000843364262558,
+          "maximum_absolute_logit_change": 1.3504877090454102,
+          "maximum_per_target_cross_entropy_increase": 0.8670740127563477
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00012532674483123354,
+            0.000296544972959154
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.23329151054570574,
+      "selected_factor_vs_raw_float32_with_keys": 1.3491377086105725,
+      "selected_full_model_factor_vs_raw_float32": 1.3190476501208241
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 5305910,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 5249238,
+      "joint_099_backend_with_keys_bytes": 4140890,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.21114455088529038,
+      "joint_099_saving_vs_raw_encoded": 0.219570252793583,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.418198261726344,
+      "joint_099_weighted_relative_frobenius": 0.011362454733114946,
+      "joint_099_added_weighted_relative_frobenius": 0.011360453108480639,
+      "joint_099_max_relative_l2": 0.1411682070021142,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0613761148069605,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.224059100685167,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.5299894824023683,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.9",
+        "backend_with_key_registry_bytes": 4133142,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7281424986147633,
+          "character_perplexity": 5.630186110963683,
+          "next_character_accuracy": 0.5290193973779038,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 7.858409296605416e-05,
+          "mean_prediction_kl_nats": 7.239406989054103e-05,
+          "prediction_kl_p99_nats": 0.0002553027836586025,
+          "maximum_prediction_kl_nats": 0.15030648367116142,
+          "top1_changed_fraction": 0.0007666947788085563,
+          "accuracy_change": -0.00023000843364262558,
+          "maximum_absolute_logit_change": 1.349926471710205,
+          "maximum_per_target_cross_entropy_increase": 0.867246150970459
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0001246097273672068,
+            0.00029588735143539364
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.21262057464340534,
+      "selected_factor_vs_raw_float32_with_keys": 2.4227314232126553,
+      "selected_full_model_factor_vs_raw_float32": 2.216673011748056
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3099273,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3099273,
+      "joint_099_backend_with_keys_bytes": 2760444,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.1093253159692612,
+      "joint_099_saving_vs_raw_encoded": 0.1093253159692612,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.62749362059147,
+      "joint_099_weighted_relative_frobenius": 0.012504361072079999,
+      "joint_099_added_weighted_relative_frobenius": 0.011554937193940731,
+      "joint_099_max_relative_l2": 0.1411733068123005,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1320600286985667,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.1211526249395719,
+      "joint_099_factor_vs_raw_float32_with_datrie": 3.950933384542714,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.9",
+        "backend_with_key_registry_bytes": 2756191,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7281543275316205,
+          "character_perplexity": 5.6302527103609785,
+          "next_character_accuracy": 0.5291727363336656,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 9.041400935520268e-05,
+          "mean_prediction_kl_nats": 9.501836386167312e-05,
+          "prediction_kl_p99_nats": 0.0002800923076272734,
+          "maximum_prediction_kl_nats": 0.14853157432377162,
+          "top1_changed_fraction": 0.0024534232921873803,
+          "accuracy_change": -7.666947788087519e-05,
+          "maximum_absolute_logit_change": 1.359821081161499,
+          "maximum_per_target_cross_entropy_increase": 0.8680667877197266
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00016767168309531454,
+            0.00033279514032229094
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.11069757326960228,
+      "selected_factor_vs_raw_float32_with_keys": 3.63309110290252,
+      "selected_full_model_factor_vs_raw_float32": 3.0997989403935953
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 11783824,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 11391663,
+      "joint_099_backend_with_keys_bytes": 8211066,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.27920392307953634,
+      "joint_099_saving_vs_raw_encoded": 0.3031917313089537,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.4351150021203094,
+      "joint_099_weighted_relative_frobenius": 0.012203466418320411,
+      "joint_099_added_weighted_relative_frobenius": 0.012203466418320411,
+      "joint_099_max_relative_l2": 0.14041193528604085,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1594861617907517,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.28910008220535777,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.456809057629733,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.9",
+        "backend_with_key_registry_bytes": 8191912,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7467407476364325,
+          "character_perplexity": 5.735877505237137,
+          "next_character_accuracy": 0.522579161235912,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 8.545016806342631e-05,
+          "mean_prediction_kl_nats": 7.555171199507978e-05,
+          "prediction_kl_p99_nats": 0.0002332713868702684,
+          "maximum_prediction_kl_nats": 0.07069631943714265,
+          "top1_changed_fraction": 0.0017633979912596795,
+          "accuracy_change": -0.00023000843364262558,
+          "maximum_absolute_logit_change": 1.421870231628418,
+          "maximum_per_target_cross_entropy_increase": 0.5875310897827148
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00011373525728950033,
+            0.0002831974613994154
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.2808853281562139,
+      "selected_factor_vs_raw_float32_with_keys": 1.4384705304451513,
+      "selected_full_model_factor_vs_raw_float32": 1.398220381356355
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 6260368,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6192529,
+      "joint_099_backend_with_keys_bytes": 4619676,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2539920281358392,
+      "joint_099_saving_vs_raw_encoded": 0.2620759674191677,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.5507901419926418,
+      "joint_099_weighted_relative_frobenius": 0.012205143139227746,
+      "joint_099_added_weighted_relative_frobenius": 0.012203608015228266,
+      "joint_099_max_relative_l2": 0.1404184277793818,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.0572761848824968,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.271060882896614,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.693760522246224,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.9",
+        "backend_with_key_registry_bytes": 4609985,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7467389892458764,
+          "character_perplexity": 5.735867419333168,
+          "next_character_accuracy": 0.522579161235912,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 8.369162879872298e-05,
+          "mean_prediction_kl_nats": 7.55530360250437e-05,
+          "prediction_kl_p99_nats": 0.00023711060763044312,
+          "maximum_prediction_kl_nats": 0.07071264041728009,
+          "top1_changed_fraction": 0.0017633979912596795,
+          "accuracy_change": -0.00023000843364262558,
+          "maximum_absolute_logit_change": 1.4215927124023438,
+          "maximum_per_target_cross_entropy_increase": 0.5875155925750732
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00011714467232062939,
+            0.0002800202357481195
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.25555697841705705,
+      "selected_factor_vs_raw_float32_with_keys": 2.5561523519057006,
+      "selected_full_model_factor_vs_raw_float32": 2.3192095304453875
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 3,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3671291,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3671291,
+      "joint_099_backend_with_keys_bytes": 3116940,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.15099620269817893,
+      "joint_099_saving_vs_raw_encoded": 0.15099620269817893,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.780574537848018,
+      "joint_099_weighted_relative_frobenius": 0.0133093761146089,
+      "joint_099_added_weighted_relative_frobenius": 0.01244834613064305,
+      "joint_099_max_relative_l2": 0.14034170133988702,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1160896130346232,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.16894022693140376,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.178183442348404,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.9",
+        "backend_with_key_registry_bytes": 3111386,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7467207411986971,
+          "character_perplexity": 5.735762751908877,
+          "next_character_accuracy": 0.5227325001916737,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 6.544222091906036e-05,
+          "mean_prediction_kl_nats": 7.611414126180771e-05,
+          "prediction_kl_p99_nats": 0.00023912776528949614,
+          "maximum_prediction_kl_nats": 0.07220868673265157,
+          "top1_changed_fraction": 0.002300084336425669,
+          "accuracy_change": -7.666947788087519e-05,
+          "maximum_absolute_logit_change": 1.4234991073608398,
+          "maximum_per_target_cross_entropy_increase": 0.597667932510376
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00014768831565003417,
+            0.00027000310437506474
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.15250902203066985,
+      "selected_factor_vs_raw_float32_with_keys": 3.7873230772395323,
+      "selected_full_model_factor_vs_raw_float32": 3.2014705852488614
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 11783824,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 11389143,
+      "joint_099_backend_with_keys_bytes": 8203394,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.27971806131506116,
+      "joint_099_saving_vs_raw_encoded": 0.3038427933071641,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.4364571541973967,
+      "joint_099_weighted_relative_frobenius": 0.012525398130393038,
+      "joint_099_added_weighted_relative_frobenius": 0.012525398130393038,
+      "joint_099_max_relative_l2": 0.14116478475441507,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.191513651349131,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.2896347151191778,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.4582394940414902,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.95",
+        "backend_with_key_registry_bytes": 8192404,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7468335463514388,
+          "character_perplexity": 5.736409811997366,
+          "next_character_accuracy": 0.5232691865368397,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 5.126287092804774e-05,
+          "mean_prediction_kl_nats": 4.523398162602008e-05,
+          "prediction_kl_p99_nats": 0.0002614981201286399,
+          "maximum_prediction_kl_nats": 0.031281574788080815,
+          "top1_changed_fraction": 0.0018400674691405351,
+          "accuracy_change": -0.00023000843364251455,
+          "maximum_absolute_logit_change": 0.6498794555664062,
+          "maximum_per_target_cross_entropy_increase": 0.5136287212371826
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00014062225521751923,
+            0.0002640022597950617
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.28068301539457363,
+      "selected_factor_vs_raw_float32_with_keys": 1.4383841421883004,
+      "selected_full_model_factor_vs_raw_float32": 1.3981441181889676
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 6260368,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6190190,
+      "joint_099_backend_with_keys_bytes": 4615224,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.254429347079815,
+      "joint_099_saving_vs_raw_encoded": 0.26278710772274094,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.5532507197917154,
+      "joint_099_weighted_relative_frobenius": 0.012524791627337375,
+      "joint_099_added_weighted_relative_frobenius": 0.012523978773244526,
+      "joint_099_max_relative_l2": 0.14112562218626845,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.057025491895454,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.2715344857103401,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.696598826538473,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.95",
+        "backend_with_key_registry_bytes": 4609709,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.746831640034469,
+          "character_perplexity": 5.7363988765924185,
+          "next_character_accuracy": 0.5232691865368397,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 4.93564580521361e-05,
+          "mean_prediction_kl_nats": 4.522092181157221e-05,
+          "prediction_kl_p99_nats": 0.000260726444150113,
+          "maximum_prediction_kl_nats": 0.03128432153710157,
+          "top1_changed_fraction": 0.0018400674691405351,
+          "accuracy_change": -0.00023000843364251455,
+          "maximum_absolute_logit_change": 0.6495251655578613,
+          "maximum_per_target_cross_entropy_increase": 0.5136415958404541
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00014176603083662905,
+            0.00026122043476795856
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.2553202728833849,
+      "selected_factor_vs_raw_float32_with_keys": 2.5563053980197012,
+      "selected_full_model_factor_vs_raw_float32": 2.31932724584094
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 7,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3671291,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3671291,
+      "joint_099_backend_with_keys_bytes": 3116568,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.15109752945217358,
+      "joint_099_saving_vs_raw_encoded": 0.15109752945217358,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.781025795041212,
+      "joint_099_weighted_relative_frobenius": 0.013529571057738162,
+      "joint_099_added_weighted_relative_frobenius": 0.01272182586954238,
+      "joint_099_max_relative_l2": 0.14050498208265808,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.128973194668229,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.1690535951122467,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.178753482790604,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.95",
+        "backend_with_key_registry_bytes": 3113298,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7468335912146888,
+          "character_perplexity": 5.7364100693513596,
+          "next_character_accuracy": 0.5231925170589589,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 5.130773647893945e-05,
+          "mean_prediction_kl_nats": 4.9148167713019224e-05,
+          "prediction_kl_p99_nats": 0.00026751634360011476,
+          "maximum_prediction_kl_nats": 0.030909915141433902,
+          "top1_changed_fraction": 0.0026067622479490913,
+          "accuracy_change": -0.00030667791152338975,
+          "maximum_absolute_logit_change": 0.652705192565918,
+          "maximum_per_target_cross_entropy_increase": 0.5167644023895264
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.00014600205117785967,
+            0.0002798015539844717
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.1519882243058368,
+      "selected_factor_vs_raw_float32_with_keys": 3.784997131659096,
+      "selected_full_model_factor_vs_raw_float32": 3.1999174890695854
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp32",
+      "raw_encoded_backend_with_keys_bytes": 11783824,
+      "best_encoded_baseline": "fp32-dedup",
+      "best_encoded_baseline_with_keys_bytes": 11388281,
+      "joint_099_backend_with_keys_bytes": 8205579,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.2794716779468297,
+      "joint_099_saving_vs_raw_encoded": 0.30365736962805967,
+      "joint_099_factor_vs_raw_float32_with_keys": 1.4360746511611187,
+      "joint_099_weighted_relative_frobenius": 0.013052669069275194,
+      "joint_099_added_weighted_relative_frobenius": 0.013052669069275194,
+      "joint_099_max_relative_l2": 0.1400040347803519,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1577321344867262,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.28938037342746636,
+      "joint_099_factor_vs_raw_float32_with_datrie": 1.4578318170558695,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp32-joint-0.9",
+        "backend_with_key_registry_bytes": 8186195,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7491682414699585,
+          "character_perplexity": 5.749818226172276,
+          "next_character_accuracy": 0.5252625929617419,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -0.0002687747523804419,
+          "mean_prediction_kl_nats": 0.0001433063275818475,
+          "prediction_kl_p99_nats": 0.00047574067175172846,
+          "maximum_prediction_kl_nats": 0.14949254966897688,
+          "top1_changed_fraction": 0.0013800506018554013,
+          "accuracy_change": -0.00030667791152338975,
+          "maximum_absolute_logit_change": 1.5382030010223389,
+          "maximum_per_target_cross_entropy_increase": 0.7367382049560547
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0005444561415285015,
+            1.527656112117525e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.28117377855358505,
+      "selected_factor_vs_raw_float32_with_keys": 1.439475116339154,
+      "selected_full_model_factor_vs_raw_float32": 1.3991071635586236
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "fp16",
+      "raw_encoded_backend_with_keys_bytes": 6260368,
+      "best_encoded_baseline": "fp16-dedup",
+      "best_encoded_baseline_with_keys_bytes": 6189032,
+      "joint_099_backend_with_keys_bytes": 4616234,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.254126655024566,
+      "joint_099_saving_vs_raw_encoded": 0.26262577535378107,
+      "joint_099_factor_vs_raw_float32_with_keys": 2.5526920862330638,
+      "joint_099_weighted_relative_frobenius": 0.013052639637527957,
+      "joint_099_added_weighted_relative_frobenius": 0.01305117528543782,
+      "joint_099_max_relative_l2": 0.13994770767903386,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.057732670135994,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.27121485544702306,
+      "joint_099_factor_vs_raw_float32_with_datrie": 2.6959543921177147,
+      "validation_selection": {
+        "feasible": true,
+        "name": "fp16-joint-0.9",
+        "backend_with_key_registry_bytes": 4606495,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7491683695294322,
+          "character_perplexity": 5.749818962491019,
+          "next_character_accuracy": 0.5252625929617419,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": -0.0002686467273177534,
+          "mean_prediction_kl_nats": 0.00014329286792632542,
+          "prediction_kl_p99_nats": 0.0004777807634440265,
+          "maximum_prediction_kl_nats": 0.1495226025186514,
+          "top1_changed_fraction": 0.0013800506018554013,
+          "accuracy_change": -0.00030667791152338975,
+          "maximum_absolute_logit_change": 1.538262128829956,
+          "maximum_per_target_cross_entropy_increase": 0.7369163036346436
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            -0.0005467265885629537,
+            1.8822879602251045e-05
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": false
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.2557002452079744,
+      "selected_factor_vs_raw_float32_with_keys": 2.55808895917612,
+      "selected_full_model_factor_vs_raw_float32": 2.3206989134036973
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "seed": 11,
+      "encoding": "int8",
+      "raw_encoded_backend_with_keys_bytes": 3671291,
+      "best_encoded_baseline": "int8-raw",
+      "best_encoded_baseline_with_keys_bytes": 3671291,
+      "joint_099_backend_with_keys_bytes": 3117210,
+      "joint_099_added_saving_vs_best_encoded_baseline": 0.15092265908640856,
+      "joint_099_saving_vs_raw_encoded": 0.15092265908640856,
+      "joint_099_factor_vs_raw_float32_with_keys": 3.7802470799208265,
+      "joint_099_weighted_relative_frobenius": 0.014090331843047801,
+      "joint_099_added_weighted_relative_frobenius": 0.013331484320787465,
+      "joint_099_max_relative_l2": 0.1410713069702977,
+      "joint_099_warm_query_ratio_vs_raw_encoded": 1.1465622808578337,
+      "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": 0.16885794357434025,
+      "joint_099_factor_vs_raw_float32_with_datrie": 4.177769800712289,
+      "validation_selection": {
+        "feasible": true,
+        "name": "int8-joint-0.95",
+        "backend_with_key_registry_bytes": 3114251,
+        "test": {
+          "targets": 13043,
+          "cross_entropy_nats": 1.7496451964622277,
+          "character_perplexity": 5.752561284785639,
+          "next_character_accuracy": 0.5254159319175037,
+          "unknown_targets": 0
+        },
+        "test_delta": {
+          "perplexity_relative_change": 0.00020816577697060302,
+          "mean_prediction_kl_nats": 6.48036425053271e-05,
+          "prediction_kl_p99_nats": 0.00021414928574367274,
+          "maximum_prediction_kl_nats": 0.15112539268236266,
+          "top1_changed_fraction": 0.0026067622479490913,
+          "accuracy_change": -0.00015333895576163936,
+          "maximum_absolute_logit_change": 1.0701985359191895,
+          "maximum_per_target_cross_entropy_increase": 0.7534070014953613
+        },
+        "test_paired_block_interval": {
+          "perplexity_relative_change_95_percent_interval": [
+            1.1390863152666506e-05,
+            0.0004288786464272205
+          ],
+          "block_characters": 256,
+          "observed_blocks": 52,
+          "repeats": 1000,
+          "seed": 42,
+          "limitation": "Paired contiguous character blocks within one text split; not independent corpora."
+        },
+        "test_all_budgets_passed": true
+      },
+      "selected_added_saving_vs_best_encoded_baseline": 0.15172864259466223,
+      "selected_factor_vs_raw_float32_with_keys": 3.78383887490122,
+      "selected_full_model_factor_vs_raw_float32": 3.1991439404258837
+    }
+  ],
+  "groups": [
+    {
+      "category": "gru",
+      "max_order": 4,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.05262329656093564,
+          "min": 0.05245480941018332,
+          "max": 0.05272242879039157
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.06013974413552303,
+          "min": 0.05998944723919386,
+          "max": 0.06025266667066398
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.02428846884593,
+          "min": 2.023964780301054,
+          "max": 2.0245316846591632
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.005405079587587055,
+          "min": 0.005302751473250229,
+          "max": 0.005608434419236457
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.005401605905993721,
+          "min": 0.005299381939658822,
+          "max": 0.005604080214656733
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.12307542272477053,
+          "min": 0.11263148326372621,
+          "max": 0.14016502249394194
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0539203428668016,
+          "min": 1.0363339928189348,
+          "max": 1.0635481057016951
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.05482497336524975,
+          "min": 0.054649478025039944,
+          "max": 0.054928288836961214
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 2.0696288943808927,
+          "min": 2.0692833078223476,
+          "max": 2.069888565003748
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp16-joint-0.9",
+          "fp16-joint-0.95",
+          "fp16-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.053246207900067656,
+          "min": 0.052710468357521245,
+          "max": 0.05372248710136929
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.0256206805754893,
+          "min": 2.024511017420642,
+          "max": 2.0265720661513837
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 1.8632297059848535,
+          "min": 1.862370584235847,
+          "max": 1.8639662486266602
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.057372272023566685,
+          "min": 0.057214545021257335,
+          "max": 0.057496690371830916
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.08753531127974452,
+          "min": 0.08735430994844451,
+          "max": 0.08771862371335948
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.095932849713197,
+          "min": 1.095715468665074,
+          "max": 1.0961530356680196
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.005414277401074073,
+          "min": 0.0052940877733579465,
+          "max": 0.005649047524990139
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.005414277401074073,
+          "min": 0.0052940877733579465,
+          "max": 0.005649047524990139
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.12307561430113703,
+          "min": 0.11261831137802518,
+          "max": 0.14017569822550982
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.183254793938537,
+          "min": 1.1615017998270556,
+          "max": 1.2134813021805575
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.058640812140851116,
+          "min": 0.05847955746099098,
+          "max": 0.05876807091890335
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.0981861249794447,
+          "min": 1.0979631809733372,
+          "max": 1.0984119463777775
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp32-joint-0.9",
+          "fp32-joint-0.95",
+          "fp32-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.05804078602793272,
+          "min": 0.05751601175785381,
+          "max": 0.05858481406499183
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.0967108746423382,
+          "min": 1.0960659486421322,
+          "max": 1.0974200112886179
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 1.0877711818320588,
+          "min": 1.0871906337528756,
+          "max": 1.0884095070641355
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 4,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": -0.045570183278392795,
+          "min": -0.04578634287068262,
+          "max": -0.045461064253438765
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": -0.045570183278392795,
+          "min": -0.04578634287068262,
+          "max": -0.045461064253438765
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.1538443098267015,
+          "min": 3.153192356232175,
+          "max": 3.154173421988336
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.007729864985927438,
+          "min": 0.007636228340675911,
+          "max": 0.007915395391086759
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.005609781509268933,
+          "min": 0.005479980336186081,
+          "max": 0.005829303558166024
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.11732259539247156,
+          "min": 0.11380766731945188,
+          "max": 0.12213938394952205
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.1163605568830008,
+          "min": 1.1052328226907326,
+          "max": 1.1232070236978005
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": -0.0489502761197446,
+          "min": -0.04918246899164669,
+          "max": -0.0488330633719094
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 3.3061468983951388,
+          "min": 3.305415139408319,
+          "max": 3.3065162971288444
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 3,
+        "selected_names": [
+          "int8-raw",
+          "int8-raw",
+          "int8-raw"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.0,
+          "min": 0.0,
+          "max": 0.0
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.2975655025918367,
+          "min": 3.2975655025918367,
+          "max": 3.2975655025918367
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 2.7589069627937097,
+          "min": 2.7589069627937097,
+          "max": 2.7589069627937097
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.21129972826892873,
+          "min": 0.21101267894455367,
+          "max": 0.21174195497694215
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.2197572769484091,
+          "min": 0.21953123969309696,
+          "max": 0.22017033835854738
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.418778243816425,
+          "min": 2.4180773838429768,
+          "max": 2.4200590858799536
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011344388337072204,
+          "min": 0.011234116695951897,
+          "max": 0.011436593582149768
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011343131937587545,
+          "min": 0.011232898757745064,
+          "max": 0.011436043946536932
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14058268739868557,
+          "min": 0.139832944885907,
+          "max": 0.1411682070021142
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0611758044102917,
+          "min": 1.0567026305344063,
+          "max": 1.0654486678895083
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.2242243575877697,
+          "min": 0.22392076767335312,
+          "max": 0.22469320440478902
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 2.530644150508154,
+          "min": 2.5298530481412707,
+          "max": 2.532089920980823
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp16-joint-0.95",
+          "fp16-joint-0.97",
+          "fp16-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.21232289981128669,
+          "min": 0.21194339924966987,
+          "max": 0.21262057464340534
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.4219200760843282,
+          "min": 2.4209332113537703,
+          "max": 2.4227314232126553
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 2.216038130030947,
+          "min": 2.2152658796867795,
+          "max": 2.216673011748056
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.2318017515066569,
+          "min": 0.23149309199381918,
+          "max": 0.23224866235343367
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.2572987268278911,
+          "min": 0.25697106893668376,
+          "max": 0.2577131676229264
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.3464365948650967,
+          "min": 1.345842615534423,
+          "max": 1.347188117021603
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011342644651789415,
+          "min": 0.011233518943283134,
+          "max": 0.011433905190859801
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011342644651789415,
+          "min": 0.011233518943283134,
+          "max": 0.011433905190859801
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14058794462480786,
+          "min": 0.1398521329039012,
+          "max": 0.14115591128178223
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.174373386027238,
+          "min": 1.1570228240486526,
+          "max": 1.1877255184964386
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.23927987549733828,
+          "min": 0.23896095504842274,
+          "max": 0.23974102039406286
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.3611284012391727,
+          "min": 1.3605024773899466,
+          "max": 1.3619203505928132
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp32-joint-0.95",
+          "fp32-joint-0.97",
+          "fp32-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.23293751411667574,
+          "min": 0.23254199753757676,
+          "max": 0.23329151054570574
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.3484302195450621,
+          "min": 1.3476820149229627,
+          "max": 1.3491377086105725
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 1.3184155058014044,
+          "min": 1.3177469613751664,
+          "max": 1.3190476501208241
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 8,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.10952643840453335,
+          "min": 0.10924465189094346,
+          "max": 0.1100093473533954
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.10952643840453335,
+          "min": 0.10924465189094346,
+          "max": 0.1100093473533954
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.628313465251125,
+          "min": 3.627165125870524,
+          "max": 3.630281649291381
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012548900159934576,
+          "min": 0.012475970273467448,
+          "max": 0.01266636913425628
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011617120804413752,
+          "min": 0.011543854934588026,
+          "max": 0.011752570284712499
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14003668208464848,
+          "min": 0.13922942015502465,
+          "max": 0.1411733068123005
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.139527361292771,
+          "min": 1.1320600286985667,
+          "max": 1.1508901824706497
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.12137550571289905,
+          "min": 0.12106323425508236,
+          "max": 0.12191065794404288
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 3.9519363583297626,
+          "min": 3.950531561961863,
+          "max": 3.954344128484711
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "int8-joint-0.95",
+          "int8-joint-0.97",
+          "int8-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.11048558807178328,
+          "min": 0.11012453565723312,
+          "max": 0.11069757326960228
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.632225582645977,
+          "min": 3.630751564467595,
+          "max": 3.63309110290252
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 3.099209963909775,
+          "min": 3.0982068933606906,
+          "max": 3.0997989403935953
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.25418267674674005,
+          "min": 0.2539920281358392,
+          "max": 0.254429347079815
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.26249628349856324,
+          "min": 0.2620759674191677,
+          "max": 0.26278710772274094
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.552244316005807,
+          "min": 2.5507901419926418,
+          "max": 2.5532507197917154
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012594191468031027,
+          "min": 0.012205143139227746,
+          "max": 0.013052639637527957
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012592920691303537,
+          "min": 0.012203608015228266,
+          "max": 0.01305117528543782
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14049725254822804,
+          "min": 0.13994770767903386,
+          "max": 0.14112562218626845
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0573447823046482,
+          "min": 1.057025491895454,
+          "max": 1.057732670135994
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.2712700746846591,
+          "min": 0.271060882896614,
+          "max": 0.2715344857103401
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 2.6954379136341373,
+          "min": 2.693760522246224,
+          "max": 2.696598826538473
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp16-joint-0.9",
+          "fp16-joint-0.95",
+          "fp16-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.2555258321694721,
+          "min": 0.2553202728833849,
+          "max": 0.2557002452079744
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.5568489030338406,
+          "min": 2.5561523519057006,
+          "max": 2.55808895917612
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 2.3197452298966748,
+          "min": 2.3192095304453875,
+          "max": 2.3206989134036973
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.27946455411380905,
+          "min": 0.27920392307953634,
+          "max": 0.27971806131506116
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.3035639647480592,
+          "min": 0.3031917313089537,
+          "max": 0.3038427933071641
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.4358822691596083,
+          "min": 1.4351150021203094,
+          "max": 1.4364571541973967
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012593844539329548,
+          "min": 0.012203466418320411,
+          "max": 0.013052669069275194
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012593844539329548,
+          "min": 0.012203466418320411,
+          "max": 0.013052669069275194
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.1405269182736026,
+          "min": 0.1400040347803519,
+          "max": 0.14116478475441507
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.1695773158755363,
+          "min": 1.1577321344867262,
+          "max": 1.191513651349131
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.28937172358400065,
+          "min": 0.28910008220535777,
+          "max": 0.2896347151191778
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.4576267895756976,
+          "min": 1.456809057629733,
+          "max": 1.4582394940414902
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 2,
+        "selected_names": [
+          "fp32-joint-0.9",
+          "fp32-joint-0.95",
+          "fp32-joint-0.9"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.28091404070145753,
+          "min": 0.28068301539457363,
+          "max": 0.28117377855358505
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.4387765963242019,
+          "min": 1.4383841421883004,
+          "max": 1.439475116339154
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 1.398490554367982,
+          "min": 1.3981441181889676,
+          "max": 1.3991071635586236
+        }
+      }
+    },
+    {
+      "category": "gru",
+      "max_order": 12,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.15100546374558702,
+          "min": 0.15092265908640856,
+          "max": 0.15109752945217358
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.15100546374558702,
+          "min": 0.15092265908640856,
+          "max": 0.15109752945217358
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.7806158042700186,
+          "min": 3.7802470799208265,
+          "max": 3.781025795041212
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.013643093005131621,
+          "min": 0.0133093761146089,
+          "max": 0.014090331843047801
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.012833885440324298,
+          "min": 0.01244834613064305,
+          "max": 0.013331484320787465
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.1406393301309476,
+          "min": 0.14034170133988702,
+          "max": 0.1410713069702977
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.1305416961868953,
+          "min": 1.1160896130346232,
+          "max": 1.1465622808578337
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.16895058853933023,
+          "min": 0.16885794357434025,
+          "max": 0.1690535951122467
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 4.178235575283765,
+          "min": 4.177769800712289,
+          "max": 4.178753482790604
+        }
+      },
+      "validation_selected": {
+        "feasible_models": 3,
+        "test_all_budgets_passed_models": 3,
+        "selected_names": [
+          "int8-joint-0.9",
+          "int8-joint-0.95",
+          "int8-joint-0.95"
+        ],
+        "added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.15207529631038963,
+          "min": 0.15172864259466223,
+          "max": 0.15250902203066985
+        },
+        "factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.785386361266616,
+          "min": 3.78383887490122,
+          "max": 3.7873230772395323
+        },
+        "full_model_factor_vs_raw_float32": {
+          "n": 3,
+          "mean": 3.20017733824811,
+          "min": 3.1991439404258837,
+          "max": 3.2014705852488614
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.2294035598131773,
+          "min": 0.2279345167444513,
+          "max": 0.23220339587770844
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.24853988371030292,
+          "min": 0.2471847324886951,
+          "max": 0.2512146952023193
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 2.5950667136005303,
+          "min": 2.590378864561812,
+          "max": 2.604320284313853
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.006797437208006904,
+          "min": 0.006748195908759052,
+          "max": 0.0068512795300496
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.006794361702793634,
+          "min": 0.0067452159501694255,
+          "max": 0.006848195096817759
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.1414701731638959,
+          "min": 0.1408746714806218,
+          "max": 0.14214298103013276
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0382398381850755,
+          "min": 1.0375786909548252,
+          "max": 1.039525
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.234060033360687,
+          "min": 0.23256188224259455,
+          "max": 0.2369163474762418
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 2.637338333723454,
+          "min": 2.6324476448111644,
+          "max": 2.64699231764423
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.24007898752801457,
+          "min": 0.2385916134232997,
+          "max": 0.24278208856300088
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.2733092977398144,
+          "min": 0.27193456075922307,
+          "max": 0.2759242361359673
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.3761102056165533,
+          "min": 1.3735029107312045,
+          "max": 1.3810709457577985
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.0067933634444704225,
+          "min": 0.006743679010149183,
+          "max": 0.00684819310974004
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.0067933634444704225,
+          "min": 0.006743679010149183,
+          "max": 0.00684819310974004
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.1414587757908001,
+          "min": 0.14087181586808722,
+          "max": 0.14212765851757603
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.135549242440358,
+          "min": 1.1301373730529407,
+          "max": 1.1413276576532998
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.24260288846516975,
+          "min": 0.24110004291680398,
+          "max": 0.24533451295128494
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.3813308352486993,
+          "min": 1.3786772653206654,
+          "max": 1.386379638518033
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 4,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.2003316416087755,
+          "min": 0.19904426371308837,
+          "max": 0.20268854005932424
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.2003316416087755,
+          "min": 0.19904426371308837,
+          "max": 0.20268854005932424
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 4.517328975497451,
+          "min": 4.510048589238265,
+          "max": 4.530662695795015
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.00941293042021904,
+          "min": 0.00940051238979808,
+          "max": 0.009423937975726222
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.006916956251574826,
+          "min": 0.006861641269675814,
+          "max": 0.006974880559954164
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14159745045361313,
+          "min": 0.1411979477508241,
+          "max": 0.14188875915362323
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.072977692082509,
+          "min": 1.0675390597903482,
+          "max": 1.0778523599944267
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.20779942030070733,
+          "min": 0.20646405271581947,
+          "max": 0.2102441770440685
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 4.68283901856197,
+          "min": 4.674936347107521,
+          "max": 4.697312681798634
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.33215709725365755,
+          "min": 0.33129892564748875,
+          "max": 0.3338004378815612
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.3665750509845665,
+          "min": 0.36556057757426064,
+          "max": 0.36808577600624837
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.0686736165632755,
+          "min": 3.0637577196265404,
+          "max": 3.0760008309474016
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009513704223477967,
+          "min": 0.009429329011061569,
+          "max": 0.009591286480164959
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.00951173706748076,
+          "min": 0.009427344865478818,
+          "max": 0.009589247498575619
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14216555910067064,
+          "min": 0.14199922735932338,
+          "max": 0.1423848947835388
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0365835521368776,
+          "min": 1.0364142927742688,
+          "max": 1.0368272727272727
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.3415884516744569,
+          "min": 0.3407028567210101,
+          "max": 0.34327771601163126
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 3.1578866944393402,
+          "min": 3.1526096620638993,
+          "max": 3.165752491802803
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.3573551431848582,
+          "min": 0.3562779186898901,
+          "max": 0.3591413416286595
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.39282200132309647,
+          "min": 0.3917178981556664,
+          "max": 0.3944589882705757
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.6469697327263897,
+          "min": 1.6439740655987796,
+          "max": 1.6514158093834164
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009511693118292574,
+          "min": 0.009429837428214146,
+          "max": 0.009587863324407826
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009511693118292574,
+          "min": 0.009429837428214146,
+          "max": 0.009587863324407826
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.1421603661722247,
+          "min": 0.14199628030247896,
+          "max": 0.14236738964640794
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.1427405410336353,
+          "min": 1.1293635966132687,
+          "max": 1.149934767889287
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.36252453619335084,
+          "min": 0.3614309879116906,
+          "max": 0.3643361336175788
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.6616510863244953,
+          "min": 1.6585601125709268,
+          "max": 1.6662387213949807
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 8,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.28300198507536506,
+          "min": 0.2807873357622206,
+          "max": 0.28543019668566394
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.32701442659373947,
+          "min": 0.32495399050772833,
+          "max": 0.32906423926757133
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 5.320377951746535,
+          "min": 5.304105640853472,
+          "max": 5.336599353230042
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011672811168299305,
+          "min": 0.011437149201513133,
+          "max": 0.012055645188533535
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009641461225460295,
+          "min": 0.00957913732749358,
+          "max": 0.009713811108145775
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14288202280201326,
+          "min": 0.14274862236861094,
+          "max": 0.14306266325996833
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0736467855649692,
+          "min": 1.0692774268035872,
+          "max": 1.078121273428569
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.2983342252007142,
+          "min": 0.29604947771935075,
+          "max": 0.30088850924233634
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 5.653970935489896,
+          "min": 5.63534460216359,
+          "max": 5.6725419135334585
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "encoding": "fp16",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.3310568078982729,
+          "min": 0.33015628708135025,
+          "max": 0.3325451296041324
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.3676898763537652,
+          "min": 0.3666544525049803,
+          "max": 0.3691938861779126
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 3.0726327223431906,
+          "min": 3.0676003365985034,
+          "max": 3.0799495631186087
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009543758176454063,
+          "min": 0.009470324713106664,
+          "max": 0.009600233959965716
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.00954159442650828,
+          "min": 0.009468034050420173,
+          "max": 0.009598270767519452
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14212336843888312,
+          "min": 0.1419611647297449,
+          "max": 0.1422308437423335
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.0364273299720135,
+          "min": 1.0361909090909092,
+          "max": 1.036754915059693
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.3409039775511032,
+          "min": 0.33997372302799955,
+          "max": 0.3424381315092502
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 3.166170201414027,
+          "min": 3.1607505539838026,
+          "max": 3.1740504429574834
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "encoding": "fp32",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.35658303146987974,
+          "min": 0.3554473497210139,
+          "max": 0.35827744641341375
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.393169142610682,
+          "min": 0.39200256691366864,
+          "max": 0.3947760570376373
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 1.6479118296550685,
+          "min": 1.6447437860449108,
+          "max": 1.6522809641425362
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009539963511046499,
+          "min": 0.009467831744684692,
+          "max": 0.009597568466419546
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009539963511046499,
+          "min": 0.009467831744684692,
+          "max": 0.009597568466419546
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14209324303693532,
+          "min": 0.1419349417581233,
+          "max": 0.1422066988799605
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.15635565439026,
+          "min": 1.1280072991532342,
+          "max": 1.1747773128392094
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.3619767222428773,
+          "min": 0.3608230040398106,
+          "max": 0.3636968463339676
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 1.6632725159377728,
+          "min": 1.6599991327470642,
+          "max": 1.6677870562442678
+        }
+      }
+    },
+    {
+      "category": "sgns",
+      "max_order": 12,
+      "encoding": "int8",
+      "seeds": [
+        3,
+        7,
+        11
+      ],
+      "joint_099": {
+        "joint_099_added_saving_vs_best_encoded_baseline": {
+          "n": 3,
+          "mean": 0.2808103402842879,
+          "min": 0.2788578259313058,
+          "max": 0.2831127868987199
+        },
+        "joint_099_saving_vs_raw_encoded": {
+          "n": 3,
+          "mean": 0.32798049839980964,
+          "min": 0.3258565047545223,
+          "max": 0.3305918401805107
+        },
+        "joint_099_factor_vs_raw_float32_with_keys": {
+          "n": 3,
+          "mean": 5.321172481234668,
+          "min": 5.304361963879888,
+          "max": 5.341884561642363
+        },
+        "joint_099_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.011484770366127247,
+          "min": 0.011273324565210031,
+          "max": 0.011592827136221024
+        },
+        "joint_099_added_weighted_relative_frobenius": {
+          "n": 3,
+          "mean": 0.009657831648581904,
+          "min": 0.009600591901907743,
+          "max": 0.009708818886474999
+        },
+        "joint_099_max_relative_l2": {
+          "n": 3,
+          "mean": 0.14231275171970903,
+          "min": 0.14200820684716933,
+          "max": 0.14267755652829675
+        },
+        "joint_099_warm_query_ratio_vs_raw_encoded": {
+          "n": 3,
+          "mean": 1.076150952697568,
+          "min": 1.0752103506868385,
+          "max": 1.0778555181250178
+        },
+        "joint_099_added_saving_vs_best_encoded_baseline_with_datrie": {
+          "n": 3,
+          "mean": 0.2967709584686942,
+          "min": 0.294740745009476,
+          "max": 0.29921592430482635
+        },
+        "joint_099_factor_vs_raw_float32_with_datrie": {
+          "n": 3,
+          "mean": 5.67043328467963,
+          "min": 5.65107222816794,
+          "max": 5.694291996182165
+        }
+      }
+    }
+  ],
+  "raw_report_sha256": "eb73b44ef9ccd359160b38a371c2629f9c1f7ea8d0990450dc67ec125cfa08d0"
+}
diff --git a/docs/quantized_structural_evidence_20261031/tests.txt b/docs/quantized_structural_evidence_20261031/tests.txt
new file mode 100644
index 0000000..074576f
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/tests.txt
@@ -0,0 +1,29 @@
+test_failed_export_removes_only_new_owned_directory (tests.test_quantized_memory.CodecTest.test_failed_export_removes_only_new_owned_directory) ... ok
+test_finite_subnormal_zero_signed_zero_and_overflow (tests.test_quantized_memory.CodecTest.test_finite_subnormal_zero_signed_zero_and_overflow) ... ok
+test_int8_code_equality_does_not_discard_different_scales (tests.test_quantized_memory.CodecTest.test_int8_code_equality_does_not_discard_different_scales) ... ok
+test_mark_compact_forwards_entire_quantized_representative (tests.test_quantized_memory.QuantizedNativeTest.test_mark_compact_forwards_entire_quantized_representative) ... ok
+test_original_ids_padding_repeated_queries_and_scale_sensitive_dedup (tests.test_quantized_memory.QuantizedNativeTest.test_original_ids_padding_repeated_queries_and_scale_sensitive_dedup) ... ok
+test_quantized_reader_preserves_model_reduction_logits_and_restores_on_failure (tests.test_quantized_memory.QuantizedNativeTest.test_quantized_reader_preserves_model_reduction_logits_and_restores_on_failure) ... ok
+test_size_winner_requires_all_budgets_and_cannot_use_test (tests.test_quantized_memory.ValidationSelectionTest.test_size_winner_requires_all_budgets_and_cannot_use_test) ... ok
+test_rejects_dangling_chained_out_of_range_and_noninteger_maps (tests.test_structural_native.CompactionTest.test_rejects_dangling_chained_out_of_range_and_noninteger_maps) ... ok
+test_changed_source_and_failed_export_do_not_leave_partial_directory (tests.test_structural_native.RealStructuralTest.test_changed_source_and_failed_export_do_not_leave_partial_directory) ... ok
+test_compact_export_uses_existing_frozen_embedding_adapter (tests.test_structural_native.RealStructuralTest.test_compact_export_uses_existing_frozen_embedding_adapter) ... ok
+test_default_preserves_bytes_and_keeps_unindexed_rows (tests.test_structural_native.RealStructuralTest.test_default_preserves_bytes_and_keeps_unindexed_rows) ... ok
+test_engine_cli_uses_original_key_ids_after_structural_compaction (tests.test_structural_native.RealStructuralTest.test_engine_cli_uses_original_key_ids_after_structural_compaction) ... ok
+test_joint_final_guard_rejects_direction_norm_and_chain_drift (tests.test_structural_native.RealStructuralTest.test_joint_final_guard_rejects_direction_norm_and_chain_drift) ... ok
+test_layout_only_bytes_exact_signed_zero_and_duplicate_keys (tests.test_structural_native.RealStructuralTest.test_layout_only_bytes_exact_signed_zero_and_duplicate_keys) ... ok
+test_prefix_suffix_utf8_keys_original_ids_compact_forwarding_and_both_caches (tests.test_structural_native.RealStructuralTest.test_prefix_suffix_utf8_keys_original_ids_compact_forwarding_and_both_caches) ... ok
+test_quantization_before_datrie_plan_keeps_scales_padding_and_original_ids (tests.test_structural_native.RealStructuralTest.test_quantization_before_datrie_plan_keeps_scales_padding_and_original_ids) ... ok
+test_full_softmax_metrics_against_scalar_probability_oracle (tests.test_causal_ngram_lm.CausalMemoryTest.test_full_softmax_metrics_against_scalar_probability_oracle) ... ok
+test_future_perturbation_cannot_change_previous_keys_or_logits (tests.test_causal_ngram_lm.CausalMemoryTest.test_future_perturbation_cannot_change_previous_keys_or_logits) ... ok
+test_identical_scores_have_zero_paired_character_block_interval (tests.test_causal_ngram_lm.CausalMemoryTest.test_identical_scores_have_zero_paired_character_block_interval) ... ok
+test_streaming_scores_include_unknown_targets_and_keep_state (tests.test_causal_ngram_lm.CausalMemoryTest.test_streaming_scores_include_unknown_targets_and_keep_state) ... ok
+test_test_budget_audit_preserves_validation_choice (tests.test_causal_ngram_lm.CausalMemoryTest.test_test_budget_audit_preserves_validation_choice) ... ok
+test_train_only_registry_and_original_split_boundaries (tests.test_causal_ngram_lm.CausalMemoryTest.test_train_only_registry_and_original_split_boundaries) ... ok
+test_validation_selection_rejects_distribution_shift_despite_low_ppl (tests.test_causal_ngram_lm.CausalMemoryTest.test_validation_selection_rejects_distribution_shift_despite_low_ppl) ... ok
+test_tiny_trained_lm_queries_native_storage_and_has_bit_exact_logits (tests.test_causal_ngram_lm.CausalNativeTest.test_tiny_trained_lm_queries_native_storage_and_has_bit_exact_logits) ... ok
+
+----------------------------------------------------------------------
+Ran 24 tests in 4.520s
+
+OK
diff --git a/docs/quantized_structural_evidence_20261031/verify_codec_revision.py b/docs/quantized_structural_evidence_20261031/verify_codec_revision.py
new file mode 100644
index 0000000..782fe2a
--- /dev/null
+++ b/docs/quantized_structural_evidence_20261031/verify_codec_revision.py
@@ -0,0 +1,76 @@
+"""Check the finite-range codec fix against all cached study inputs.
+
+Run from this trusted repository. Executes the pinned study's own codec source
+from Git to compare encoded bytes; never loads arbitrary network code.
+"""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import platform
+import shlex
+import subprocess
+import sys
+
+import numpy as np
+import torch
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+from tools import quantized_memory as current
+
+
+def sha(raw):
+    return hashlib.sha256(raw).hexdigest()
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--report", type=Path, required=True)
+    p.add_argument("--sgns-dir", type=Path, required=True)
+    p.add_argument("--gru-dir", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    args = p.parse_args()
+    raw = args.report.read_bytes()
+    study = json.loads(raw)
+    source = subprocess.check_output(["git", "show", study["commit"] + ":tools/quantized_memory.py"], cwd=ROOT)
+    if sha(source) != study["source_sha256"]["tools/quantized_memory.py"]:
+        raise ValueError("pinned codec source differs from study")
+    reference = {"__name__": "tools._pinned_study_codec", "__package__": "tools"}
+    exec(compile(source, "pinned study codec", "exec"), reference)
+    checks = []
+    for run in study["runs"]:
+        folder = f"order-{run['max_order']}-seed-{run['seed']}"
+        if run["category"] == "sgns":
+            rows = np.frombuffer((args.sgns_dir / folder / "trained-ngram.f32").read_bytes(), dtype="<f4").reshape(-1, run["dim"])
+        else:
+            state = torch.load(args.gru_dir / folder / "reference.pt", map_location="cpu", weights_only=True)
+            rows = state["model_state"]["memory.weight"].numpy().astype("<f4")
+        if sha(rows.tobytes()) != run["source_float32_sha256"]:
+            raise ValueError("cached trained rows differ from study")
+        variants = {v["name"]: v for v in run["variants"]}
+        for encoding in ("fp32", "fp16", "int8"):
+            old = reference["encode_rows"](rows, encoding)
+            new = current.encode_rows(rows, encoding)
+            decoded = current.decode_rows(new, run["dim"], encoding)
+            expected_sha = variants[encoding + "-raw"]["metadata"]["decoded_float32_sha256"]
+            if old.tobytes() != new.tobytes() or sha(decoded.tobytes()) != expected_sha:
+                raise ValueError("codec revision changed a trained study table")
+            checks.append({"category": run["category"], "max_order": run["max_order"], "seed": run["seed"],
+                           "encoding": encoding, "source_float32_sha256": run["source_float32_sha256"],
+                           "encoded_sha256": sha(new.tobytes()), "decoded_sha256": expected_sha,
+                           "encoded_bytes_identical": True, "decoded_bytes_identical": True})
+    result = {"study_commit": study["commit"], "report_sha256": sha(raw),
+              "revision_commit": subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=ROOT, text=True).strip(),
+              "revision_codec_sha256": sha((ROOT / "tools/quantized_memory.py").read_bytes()),
+              "verification_script_sha256": sha(Path(__file__).read_bytes()),
+              "command": shlex.join([sys.executable, *sys.argv]), "working_directory": str(ROOT),
+              "python": sys.version, "pytorch": torch.__version__, "numpy": np.__version__,
+              "platform": platform.platform(), "device": "cpu", "gpu": "unused",
+              "all_trained_encodings_unchanged": True, "checks": checks,
+              "scope": "byte compatibility of a finite-range guard; benchmark timings remain tied to the original study commit"}
+    args.output.write_text(json.dumps(result, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    main()