From cbb0c962def7db6d7d1bc85e30f3aa0aa30bdd80 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Mon, 16 Nov 2026 04:31:14 -0400 Subject: [PATCH 1/4] Partly implements #2650: the 1.7 rewrite records the block stride it wrote, and the reader prefers it over the vote MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The geometry is exact by construction and was being thrown away. `canonical_token_fconst17()` computes `Fconst17Geom g` from `fconst17_geometry(fc.size, d, &g)` before writing anything — arithmetic on size and `Dims` — and the caller kept only the copy's path, so the reader downstream had nothing but bytes and asked the epsilon vote, which this issue shows losing to a 12-byte anchor inside a 4-bit tile (16,232,526 B into block 0, not even 64-aligned; 320 gaps on Phi-3-mini-4k). **What this does** 1. the writer **measures** the stride while it writes it — `o.tellp()` before block 0 and before block 1 — so the number comes from the bytes that were actually emitted, not from a second copy of the arithmetic. A one-layer model has no second block to measure against, so it falls back to `g.stride + 3 * 64`: this loop writes exactly three 64-byte headers per block (two `hdr` and one `sep`), which is visible in the loop body; 2. it records that under the **pack dir** rather than a path — the rewrite and the reader are looking at the same pack, so no path matching is involved and a stale entry cannot outlive the process; 3. `locate_fconst_with_header()` prefers the recorded stride when the vote failed, and **refuses naming both** when the vote succeeded with a different value. The second rule matters more than the first: a wrong stride reads weights from the wrong place instead of failing cleanly, which is the same reason the 1.9 header path refuses on disagreement. The vote is untouched for every pack this process did not rewrite — the 1.8 / R1-Distill line keeps the witness that works there. **The test is a consistency check against the file, not against the arithmetic** `tests/npu_pack_import_test.cpp` already builds a synthetic 1.7 stream; the arm asserts `layers × recorded_stride + head` equals the copy's exact size. An off-by-64 (one header) fails it, and it cannot pass by re-deriving the same expression that produced the number. **What I have not done, stated plainly** * **No local build.** Disk is at 158 GB, below this lane's 160 GB floor for starting a build, so CI's `build` is the compile — which is also the check `docs/pre-pr-checks.md` names for a change to a file no local target can cheaply isolate. * **The Phi packs are not exercised.** The synthetic stream proves the plumbing and the stride consistency; it does not prove the 320 gaps are gone, because that needs the real 3.8 GB packs and, for the end-to-end claim, a device import. That verification belongs to whoever runs the TAMDCOL sweep, and the prediction is specific: the `attention payload is … not a whole number of 108800-byte tiles` message should disappear for the 1.7 `-onnx-ryzenai-npu` line. --- npu/pack_import.cpp | 44 ++++++++++++++++++++++++++++++++++ tests/npu_pack_import_test.cpp | 12 ++++++++++ 2 files changed, 56 insertions(+) diff --git a/npu/pack_import.cpp b/npu/pack_import.cpp index 27ce52a7b..2a24f6d4e 100644 --- a/npu/pack_import.cpp +++ b/npu/pack_import.cpp @@ -956,6 +956,18 @@ std::string fconst17_geometry(uint64_t size, const Dims& d, Fconst17Geom* g) { // Write the 1.8 form of a 1.7 headerless Token .fconst to `work`. Returns `work`, or the source path unchanged when the // file is not in that form (so a 1.8 / 1.9 pack is untouched). Throws when it IS that form and the graph does not give // layer 0's input norm. +// engine#2650: the 1.7 rewrite writes every header itself, so the block stride of the copy it produces is known exactly -- +// but it was a local (`Fconst17Geom g`), and the reader downstream had nothing but bytes and asked the epsilon vote, which +// loses to a 12-byte anchor occurring inside a 4-bit tile. Record what was written, keyed by the PACK (both the rewrite and +// the reader are looking at the same pack, so no path matching is involved), and let the reader prefer it over the vote. +namespace { +struct Geom17Known { + int64_t stride = 0; // bytes per layer block in the canonical copy, measured from the writer's own offsets + int64_t head = 0; // the trailing head block +}; +std::map g_geom17_by_pack; +} // namespace + std::string canonical_token_fconst17(const std::string& path, const std::string& pack_dir, const Dims& d, const std::string& work) { Fconst fc = open_fconst(path); @@ -1008,8 +1020,11 @@ std::string canonical_token_fconst17(const std::string& path, const std::string& char sep[64] = {0}; sep[0] = 1; // 1.8's gate/up | down separator: 01 then 63 zeros (measured) const auto put = [&](const uint8_t* p, int64_t n) { o.write(reinterpret_cast(p), std::streamsize(n)); }; + std::streampos block0 = 0; for (int L = 0; L < d.layers; ++L) { const uint8_t* b = fc.map + size_t(L) * size_t(g.stride); + if (L == 0) block0 = o.tellp(); + if (L == 1) g_geom17_by_pack[pack_dir].stride = int64_t(o.tellp() - block0); // measured, not derived o.write(hdr, 64); if (L == 0) put(in0.data(), 2 * H); else put(b - 2 * H, 2 * H); // the previous block's trailing gain @@ -1029,6 +1044,9 @@ std::string canonical_token_fconst17(const std::string& path, const std::string& o.close(); unmap_file(fc.map, fc.size); if (!o) throw std::runtime_error("writing " + work + " failed"); + g_geom17_by_pack[pack_dir].head = g.head; + if (g_geom17_by_pack[pack_dir].stride == 0) // one layer: no second block to measure against + g_geom17_by_pack[pack_dir].stride = g.stride + 3 * 64; // the three 64-byte headers this loop writes per block std::fprintf(stderr, "1bit npu-pack: note: a Ryzen AI 1.7 headerless Token .fconst (engine#2634) was rewritten into its " "1.8 form at %s (remove it when done)\n", work.c_str()); return work; @@ -1940,6 +1958,21 @@ int intermediate_size_from_graph(const std::string& model_path, int64_t hidden) // vote as the fallback for packs with no 1.9 header -- the 1.8 / R1-Distill line, where it works today. FconstGeom locate_fconst_with_header(const std::string& tok, const std::string& pack_dir, const Dims& dims) { FconstGeom g = locate_fconst(tok, dims.eps_bits); + // engine#2650: if this process rewrote the pack from its 1.7 headerless form, the stride of the copy is known from the + // writer's own offsets, and the epsilon vote is the weaker witness (a 12-byte anchor occurs inside 4-bit tiles: measured + // 16,232,526 B into block 0 of Phi-3-mini-4k, at an offset that is not even 64-aligned, which cost 320 gaps). + if (const auto it = g_geom17_by_pack.find(pack_dir); it != g_geom17_by_pack.end() && it->second.stride > 0) { + if (g.stride != 0 && g.stride != it->second.stride) { + // Two witnesses that disagree. They cannot both be right, and a wrong stride reads weights from the wrong + // place instead of failing cleanly -- so refuse naming both, as the 1.9 header path already does. + g.why = "the 1.7 rewrite produced stride " + std::to_string(it->second.stride) + + " and the epsilon anchors give " + std::to_string(g.stride) + "; refusing rather than choosing"; + g.stride = 0; + return g; + } + if (g.stride == 0) g.why.clear(); // the vote failed; the rewrite's own measurement is the answer + g.stride = it->second.stride; + } // engine#2604: the 1.8 gemma3 6-header form -- per-layer starts from every header, not one stride. Only on a file with // no 1.9 header (below, a 6-header 1.9 block is refused by name). auto six_18 = [&]() -> FconstGeom { @@ -7792,6 +7825,17 @@ std::string fconst17_geometry_exported(uint64_t size, const Dims& d) { Fconst17Geom g; return fconst17_geometry(size, d, &g); } +// engine#2650: what the 1.7 rewrite recorded for this pack (0 when it did not rewrite one). Exported so a test can check it +// against the file the writer produced rather than against the same arithmetic that produced it. +int64_t fconst17_known_stride_exported(const std::string& pack_dir) { + const auto it = g_geom17_by_pack.find(pack_dir); + return it == g_geom17_by_pack.end() ? 0 : it->second.stride; +} +int64_t fconst17_known_head_exported(const std::string& pack_dir) { + const auto it = g_geom17_by_pack.find(pack_dir); + return it == g_geom17_by_pack.end() ? 0 : it->second.head; +} + std::string canonical_token_fconst17_exported(const std::string& path, const std::string& pack_dir, const Dims& d, const std::string& work) { return canonical_token_fconst17(path, pack_dir, d, work); diff --git a/tests/npu_pack_import_test.cpp b/tests/npu_pack_import_test.cpp index f640b13cf..823706e46 100644 --- a/tests/npu_pack_import_test.cpp +++ b/tests/npu_pack_import_test.cpp @@ -437,6 +437,18 @@ void test_fconst17_rewrite() { std::string got; try { got = pi::canonical_token_fconst17_exported(tok, dir.string(), d, work); + + // engine#2650: the rewrite records the block stride it WROTE, and the reader must prefer it over the epsilon vote + // (a 12-byte anchor occurs inside 4-bit tiles). Checked against the file it produced, not against the arithmetic that + // produced it: layers x stride + head has to be the copy's exact size, and an off-by-64 (a header) fails here. + { + const int64_t st = pi::fconst17_known_stride_exported(dir.string()); + const int64_t hd = pi::fconst17_known_head_exported(dir.string()); + check(st > 0, "1.7 rewrite: the block stride it wrote is recorded"); + const auto sz = std::filesystem::file_size(work); + check(int64_t(sz) == int64_t(d.layers) * st + hd, + "1.7 rewrite: layers x recorded stride + head is the copy's exact size"); + } } catch (const std::exception& e) { said = e.what(); } From d0bbbbe4f882ceacd14f949cceb79639c4e5144c Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Mon, 16 Nov 2026 04:40:42 -0400 Subject: [PATCH 2/4] Declare the two new exported accessors in pack_import.h The test calls fconst17_known_stride_exported()/head_exported() through pack_import.h, which is where every other _exported function is declared -- I added the definitions in the .cpp and not the declarations, so the test translation unit would not have compiled. Caught by reading the seam before CI reported it. --- npu/pack_import.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/npu/pack_import.h b/npu/pack_import.h index 60a0d6b76..845df1787 100644 --- a/npu/pack_import.h +++ b/npu/pack_import.h @@ -996,6 +996,11 @@ std::string fconst17_geometry_exported(uint64_t size, const Dims& d); // The 1.8 form of such a file written to `work` (returns `work`), or `path` unchanged when it is not in that form. std::string canonical_token_fconst17_exported(const std::string& path, const std::string& pack_dir, const Dims& d, const std::string& work); +// engine#2650: the block stride and head size that the 1.7 rewrite above actually WROTE for `pack_dir` (measured from the +// writer's own offsets), or 0 when this process did not rewrite that pack. The reader prefers these over the epsilon vote, +// which loses when a 12-byte anchor occurs inside a 4-bit tile. +int64_t fconst17_known_stride_exported(const std::string& pack_dir); +int64_t fconst17_known_head_exported(const std::string& pack_dir); // The epsilon the graph's RMSNorm nodes state (0 when none), how many state it, and whether two disagree. float graph_norm_eps_exported(const std::string& onnx_path, int* nodes, bool* conflict); // The rms_norm_eps to serve with: config.json's when it states one, else the graph's when its nodes agree; when they From 3dd7711796fd4edfea4d3dcfdbb5cec4cd66e1f4 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Mon, 16 Nov 2026 04:51:26 -0400 Subject: [PATCH 3/4] Pin the refusal: extract the two-witness decision and test it directly The review asked for the branch a later edit is most likely to relax. 'Helpfully' preferring the recorded stride when the vote disagrees would pass every existing arm and reintroduce the failure in the other direction, so the decision is now a pure function (fconst17_reconcile) with four arms: a failed vote yields to the rewrite's measurement; agreement keeps it; no record leaves the vote alone (the 1.8 / R1-Distill line); and disagreement returns 0 with a message naming BOTH numbers. Pure rather than a fixture that lies about its own geometry: the branch is about two numbers, so it is tested with two numbers. Also note for the record: this work was re-done in its own worktree because the shared ~/1bit-engine clone had been switched to another lane's branch underneath it, so edits there landed in the wrong tree. My commits were already safe on the pushed branch. --- npu/pack_import.cpp | 29 +++++++++++++++++++++++------ npu/pack_import.h | 3 +++ tests/npu_pack_import_test.cpp | 17 +++++++++++++++++ 3 files changed, 43 insertions(+), 6 deletions(-) diff --git a/npu/pack_import.cpp b/npu/pack_import.cpp index 2a24f6d4e..3732911ff 100644 --- a/npu/pack_import.cpp +++ b/npu/pack_import.cpp @@ -1956,22 +1956,36 @@ int intermediate_size_from_graph(const std::string& model_path, int64_t hidden) // with "the epsilon headers do not repeat with a single period" while its own header reported the stride exactly. // So ask the header first on the SOURCE file (the canonical copy has the 1.9 header removed by construction), and keep the eps // vote as the fallback for packs with no 1.9 header -- the 1.8 / R1-Distill line, where it works today. +// engine#2650 review: the two-witness decision as a pure function, so a test can pin the REFUSAL without a fixture that has +// to lie about its own geometry. `vote` is the epsilon anchors' stride (0 when they failed); `recorded` is what the 1.7 +// rewrite measured while writing. Returns the stride to use, or 0 with `why` naming both numbers when they disagree -- a +// wrong stride reads weights from the wrong place instead of failing cleanly, so a disagreement is refused, never tie-broken. +int64_t fconst17_reconcile(int64_t vote, int64_t recorded, std::string* why) { + if (recorded <= 0) return vote; + if (vote != 0 && vote != recorded) { + *why = "the 1.7 rewrite produced stride " + std::to_string(recorded) + " and the epsilon anchors give " + + std::to_string(vote) + "; refusing rather than choosing"; + return 0; + } + return recorded; +} + FconstGeom locate_fconst_with_header(const std::string& tok, const std::string& pack_dir, const Dims& dims) { FconstGeom g = locate_fconst(tok, dims.eps_bits); // engine#2650: if this process rewrote the pack from its 1.7 headerless form, the stride of the copy is known from the // writer's own offsets, and the epsilon vote is the weaker witness (a 12-byte anchor occurs inside 4-bit tiles: measured // 16,232,526 B into block 0 of Phi-3-mini-4k, at an offset that is not even 64-aligned, which cost 320 gaps). if (const auto it = g_geom17_by_pack.find(pack_dir); it != g_geom17_by_pack.end() && it->second.stride > 0) { - if (g.stride != 0 && g.stride != it->second.stride) { - // Two witnesses that disagree. They cannot both be right, and a wrong stride reads weights from the wrong - // place instead of failing cleanly -- so refuse naming both, as the 1.9 header path already does. - g.why = "the 1.7 rewrite produced stride " + std::to_string(it->second.stride) + - " and the epsilon anchors give " + std::to_string(g.stride) + "; refusing rather than choosing"; + { + std::string why; + const int64_t agreed = fconst17_reconcile(g.stride, it->second.stride, &why); + if (agreed == 0) { // two witnesses that disagree: refuse naming both (see fconst17_reconcile) + g.why = why; g.stride = 0; return g; } if (g.stride == 0) g.why.clear(); // the vote failed; the rewrite's own measurement is the answer - g.stride = it->second.stride; + g.stride = agreed; } // engine#2604: the 1.8 gemma3 6-header form -- per-layer starts from every header, not one stride. Only on a file with // no 1.9 header (below, a 6-header 1.9 block is refused by name). @@ -7827,6 +7841,9 @@ std::string fconst17_geometry_exported(uint64_t size, const Dims& d) { } // engine#2650: what the 1.7 rewrite recorded for this pack (0 when it did not rewrite one). Exported so a test can check it // against the file the writer produced rather than against the same arithmetic that produced it. +int64_t fconst17_reconcile_exported(int64_t vote, int64_t recorded, std::string* why) { + return fconst17_reconcile(vote, recorded, why); +} int64_t fconst17_known_stride_exported(const std::string& pack_dir) { const auto it = g_geom17_by_pack.find(pack_dir); return it == g_geom17_by_pack.end() ? 0 : it->second.stride; diff --git a/npu/pack_import.h b/npu/pack_import.h index 845df1787..bfa603e63 100644 --- a/npu/pack_import.h +++ b/npu/pack_import.h @@ -1000,6 +1000,9 @@ std::string canonical_token_fconst17_exported(const std::string& path, const std // writer's own offsets), or 0 when this process did not rewrite that pack. The reader prefers these over the epsilon vote, // which loses when a 12-byte anchor occurs inside a 4-bit tile. int64_t fconst17_known_stride_exported(const std::string& pack_dir); +// The two-witness decision itself (engine#2650 review): the stride to use, or 0 with `why` naming both when the epsilon +// anchors and the rewrite's measurement disagree. Pure, so a test pins the refusal directly. +int64_t fconst17_reconcile_exported(int64_t vote, int64_t recorded, std::string* why); int64_t fconst17_known_head_exported(const std::string& pack_dir); // The epsilon the graph's RMSNorm nodes state (0 when none), how many state it, and whether two disagree. float graph_norm_eps_exported(const std::string& onnx_path, int* nodes, bool* conflict); diff --git a/tests/npu_pack_import_test.cpp b/tests/npu_pack_import_test.cpp index 823706e46..a1c2564a9 100644 --- a/tests/npu_pack_import_test.cpp +++ b/tests/npu_pack_import_test.cpp @@ -448,6 +448,23 @@ void test_fconst17_rewrite() { const auto sz = std::filesystem::file_size(work); check(int64_t(sz) == int64_t(d.layers) * st + hd, "1.7 rewrite: layers x recorded stride + head is the copy's exact size"); + + // engine#2650 review: the REFUSAL is the branch a later edit is most likely to relax ("helpfully" preferring the + // recorded value would pass every other arm and reintroduce the failure in the other direction), so pin it directly. + { + std::string why; + check(pi::fconst17_reconcile_exported(0, 200, &why) == 200 && why.empty(), + "reconcile: a failed vote yields to the rewrite's measurement"); + check(pi::fconst17_reconcile_exported(200, 200, &why) == 200 && why.empty(), + "reconcile: two witnesses that agree keep the stride"); + check(pi::fconst17_reconcile_exported(100, 0, &why) == 100 && why.empty(), + "reconcile: no rewrite record leaves the vote alone (the 1.8 / R1-Distill line)"); + why.clear(); + check(pi::fconst17_reconcile_exported(100, 200, &why) == 0, + "reconcile: disagreement REFUSES rather than choosing"); + check(why.find("100") != std::string::npos && why.find("200") != std::string::npos, + "reconcile: the refusal names both numbers"); + } } } catch (const std::exception& e) { said = e.what(); From 8b604ead185c9cc3ceda429e224e5640abb94fc6 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Mon, 16 Nov 2026 05:02:41 -0400 Subject: [PATCH 4/4] Fix the brace, and measure the tail the test was modelling Two defects, both caught by building locally before pushing again: 1. extracting the refusal by string offsets dropped a scope, so the if swallowed the rest of the file ('a function-definition is not allowed here' at five sites in CI, 2m1s). Compiles now. 2. my size arm failed against the real binary: the writer emits, after the last layer block, a 64-byte header, the final norm (2H) and the head block -- I had asserted layers x stride + head, missing the header and the norm. The tail is now MEASURED from the writer's offsets (tellp before and after) and exported, so the test no longer models the layout at all; it just checks that layers x stride + tail is the file size. Verified locally, not by reading: cmake configure + build npu_pack_import_test rc=0, then the binary run rc=0 with the four reconcile arms and the size arm green. That is the check this row's own page demands, done in its own worktree because the shared clone had been switched to another lane's branch. --- npu/pack_import.cpp | 8 +++++++- npu/pack_import.h | 2 ++ tests/npu_pack_import_test.cpp | 5 +++-- 3 files changed, 12 insertions(+), 3 deletions(-) diff --git a/npu/pack_import.cpp b/npu/pack_import.cpp index 3732911ff..fccdc184b 100644 --- a/npu/pack_import.cpp +++ b/npu/pack_import.cpp @@ -964,6 +964,7 @@ namespace { struct Geom17Known { int64_t stride = 0; // bytes per layer block in the canonical copy, measured from the writer's own offsets int64_t head = 0; // the trailing head block + int64_t tail = 0; // everything after the last layer block: a 64-byte header, the final norm, the head block }; std::map g_geom17_by_pack; } // namespace @@ -1038,9 +1039,11 @@ std::string canonical_token_fconst17(const std::string& path, const std::string& o.write(sep, 64); put(b + g.payload + 2 * H + g.gu, g.down); } + const std::streampos tail0 = o.tellp(); o.write(hdr, 64); put(fc.map + size_t(d.layers) * size_t(g.stride) - size_t(2 * H), 2 * H); // the final norm put(fc.map + size_t(d.layers) * size_t(g.stride), g.head); + g_geom17_by_pack[pack_dir].tail = int64_t(o.tellp() - tail0); // measured, so the test need not model it o.close(); unmap_file(fc.map, fc.size); if (!o) throw std::runtime_error("writing " + work + " failed"); @@ -1976,7 +1979,6 @@ FconstGeom locate_fconst_with_header(const std::string& tok, const std::string& // writer's own offsets, and the epsilon vote is the weaker witness (a 12-byte anchor occurs inside 4-bit tiles: measured // 16,232,526 B into block 0 of Phi-3-mini-4k, at an offset that is not even 64-aligned, which cost 320 gaps). if (const auto it = g_geom17_by_pack.find(pack_dir); it != g_geom17_by_pack.end() && it->second.stride > 0) { - { std::string why; const int64_t agreed = fconst17_reconcile(g.stride, it->second.stride, &why); if (agreed == 0) { // two witnesses that disagree: refuse naming both (see fconst17_reconcile) @@ -7848,6 +7850,10 @@ int64_t fconst17_known_stride_exported(const std::string& pack_dir) { const auto it = g_geom17_by_pack.find(pack_dir); return it == g_geom17_by_pack.end() ? 0 : it->second.stride; } +int64_t fconst17_known_tail_exported(const std::string& pack_dir) { + const auto it = g_geom17_by_pack.find(pack_dir); + return it == g_geom17_by_pack.end() ? 0 : it->second.tail; +} int64_t fconst17_known_head_exported(const std::string& pack_dir) { const auto it = g_geom17_by_pack.find(pack_dir); return it == g_geom17_by_pack.end() ? 0 : it->second.head; diff --git a/npu/pack_import.h b/npu/pack_import.h index bfa603e63..1fb43988c 100644 --- a/npu/pack_import.h +++ b/npu/pack_import.h @@ -1004,6 +1004,8 @@ int64_t fconst17_known_stride_exported(const std::string& pack_dir); // anchors and the rewrite's measurement disagree. Pure, so a test pins the refusal directly. int64_t fconst17_reconcile_exported(int64_t vote, int64_t recorded, std::string* why); int64_t fconst17_known_head_exported(const std::string& pack_dir); +// Everything after the last layer block (a 64-byte header, the final norm, the head block), measured the same way. +int64_t fconst17_known_tail_exported(const std::string& pack_dir); // The epsilon the graph's RMSNorm nodes state (0 when none), how many state it, and whether two disagree. float graph_norm_eps_exported(const std::string& onnx_path, int* nodes, bool* conflict); // The rms_norm_eps to serve with: config.json's when it states one, else the graph's when its nodes agree; when they diff --git a/tests/npu_pack_import_test.cpp b/tests/npu_pack_import_test.cpp index a1c2564a9..cdc41868b 100644 --- a/tests/npu_pack_import_test.cpp +++ b/tests/npu_pack_import_test.cpp @@ -446,8 +446,9 @@ void test_fconst17_rewrite() { const int64_t hd = pi::fconst17_known_head_exported(dir.string()); check(st > 0, "1.7 rewrite: the block stride it wrote is recorded"); const auto sz = std::filesystem::file_size(work); - check(int64_t(sz) == int64_t(d.layers) * st + hd, - "1.7 rewrite: layers x recorded stride + head is the copy's exact size"); + const int64_t tl = pi::fconst17_known_tail_exported(dir.string()); + check(int64_t(sz) == int64_t(d.layers) * st + tl, + "1.7 rewrite: layers x recorded stride + measured tail is the copy's exact size"); // engine#2650 review: the REFUSAL is the branch a later edit is most likely to relax ("helpfully" preferring the // recorded value would pass every other arm and reintroduce the failure in the other direction), so pin it directly.