diff --git a/research/qq16-adaptive-coordinate-reads/README.md b/research/qq16-adaptive-coordinate-reads/README.md
new file mode 100644
index 0000000000..08adbb1af1
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/README.md
@@ -0,0 +1,330 @@
+# QQ16: adaptive coordinate reads still need 66 ports
+
+**Scoped proof and exact finite premises; no supplier or new κ.**
+On the rational hidden-input family of
+[PR2354](https://github.com/CrocSwap/integer-mult-bounds/pull/2354), every
+deterministic reader that always recovers the original selected A defect
+needs **at least 66 distinct source-port reads on every input**, even when
+its port choices and stopping time depend arbitrarily on earlier reads.
+The same statement holds almost surely for a randomized reader that
+terminates and is exact with probability one for each rational input.
+
+There are **exactly 45 possible read sets at a successful 66-read leaf**.
+All contain these 22 ports:
+
+```text
+1,2,3,4,5,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109.
+```
+
+The other 44 reads choose all but one of 45 explicitly listed ports.
+PR2354's attaining set is one choice. Port 77 can replace any of 44
+specified members of that set. The sets and the exact recovery relation
+are in [RESULT.json](RESULT.json), fields `eligible_optimal_ports`,
+`optimal_omissions`, and `coordinate_relation`.
+
+The fixed-set threshold and underlying rank-66 family are credited
+predecessor results. The new delta is the adaptive/zero-error implication,
+the complete classification of optimal terminal read sets, and explicit
+family decoders for all 45 sets. Exact rechecking of the rank is a premise
+check, not a claim to have discovered that rank independently. The claim
+is in [discussion #2205](https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942816).
+
+## Exact observation contract
+
+Use the actual 8-by-112 rational centre matrix R, selected sets A and T,
+and ordinary 96-port set U from the retained
+[QQ16 packet](../joint-query/README.md). Let r_p be column p of R and
+b_p the first local chart axis of port p. For an owner d in the finite
+regular cover group G, put
+
+```text
+f_b(d) = bit_0(d b), interpreted in Q,
+V = ker(R_U) subset Q^96,
+h_p(d) = c_p f_(b_p)(d),       c in V,
+H(c)(d) = sum_(p in U) r_p c_p f_(b_p)(d).
+```
+
+The fields are constant in payload coordinates. This is the exact
+first-axis family of PR2093/PR2326/PR2354. The actual routes obey
+`rho_s(p)b_p=e_(9+8(s-1))`, so `B_s h=0` for every s=1,...,8 and every
+owner whenever `R_U c=0`. The original selected input is
+`X_A=-P_(0,A)H(c)`, with `Y_A=-X_A`, `X_U=h`, `Y_U=0` and all other
+fields zero. The selected section is invertible: the packet has
+`R_A R_A^T=4I`. Recovering this original A defect is equivalent to
+recovering H(c).
+
+Under the credited ordered F0/B1 maps, F0 leaves `X_U=Y_U=h` and all
+selected fields zero. B1 leaves only `Y_U=h`. The retained ordinary tail
+has zero selected/completed-X/history observations and finally places h
+in the former-Y endpoint, which is outside the permitted observation
+contract. This inherited family argument is explained in this account's
+[PR2326](https://github.com/CrocSwap/integer-mult-bounds/pull/2326) and
+PR2354; this package rechecks the route and rank premises but does not
+replay their full native schedule.
+
+Here a reader can request any **complete initial ordinary array** h_p,
+one port at a time, without modifying it. It can retain all responses,
+perform arbitrary computations, choose the next port adaptively, and
+stop based on its transcript. The unmodified QQ16 observations above may
+be supplied for free; they are zero throughout this family. Repeated
+reads count only once. No other input-dependent information, header,
+dense query, source preprocessing, or changed physical call is available.
+In particular, this theorem does not assume that a complete dense
+`B0 h` array has one scalar's information.
+
+For each p the function f_(b_p) is nonzero at a certified actual owner.
+Thus h_p is equivalent to the one rational scalar c_p: the complete
+array is determined by c_p, and reading a nonzero entry recovers it.
+The oracle model grants that scalar for free. It is a favorable
+information relaxation, with no charge for native access or retention.
+The claim concerns this side-effect-free reader, not arbitrary physical
+adaptive interventions inside the QQ16 word.
+
+## Transcript-fiber theorem
+
+Let V be a finite-dimensional vector space over a field F. Let H be a
+linear target and let q_1,...,q_N be scalar linear query functionals on V.
+An exact deterministic oracle algorithm receives no input-dependent
+information except answers to adaptively selected q_i. It terminates
+with H(c) for every c in V. Its internal computations and output map
+need not be linear, continuous, or bounded in cost.
+
+Fix any input c and its finite terminal transcript, and let S be the set
+of queried indices. Write `Q_S=(q_i)_(i in S)` and `K_S=ker(Q_S|V)`.
+For every v in K_S, the run on c+v has exactly the same transcript.
+Indeed, its first query is the same; if the histories agree through a
+step, its next query or stopping decision is the same. Every query on
+the fixed path lies in S and has the same answer on c and c+v. Induction
+reaches the same leaf and output.
+
+Exactness on both inputs therefore gives
+
+```text
+H(K_S)=0,      ker(Q_S|V) subset ker(H|V).                 (1)
+```
+
+Consequently H factors through Q_S and
+
+```text
+|S| >= rank(Q_S|V) >= rank(H|V).                          (2)
+```
+
+This holds for **every terminal path**, not only the zero-input branch
+or the worst case. Conversely, a fixed S satisfying (1) admits a linear
+decoder for H; define it on Q_S(V) using H(c), which is well-defined by
+(1). Adaptive choice cannot manufacture information about a direction
+in the terminal query kernel.
+
+For QQ16 the checked rank is 66, so (2) excludes every path with fewer
+than 66 distinct port reads. The original fixed 66-port set attains
+family decoding, proving a sharp threshold in this oracle contract.
+
+### Zero-error randomization
+
+Assume one input-independent probability space of random seeds. For
+each c in the **countable** rational space V, the reader terminates and
+returns H(c) with probability one. Intersect these full-measure events
+over all c in V. Countability gives a common full-measure set of seeds
+for which the deterministic seeded reader is total and exact on all V.
+The preceding theorem applies to each such seed and every input.
+Thus at least 66 distinct reads are required almost surely, and the
+expected count on each input is at least 66.
+
+The statement includes the optimal-set classification below on every
+66-read path for these seeds. It makes no bounded-error assertion and
+does not silently interchange an uncountable family of probability-one
+events. Input-dependent advice or side channels violate the contract.
+The all-input assertion is for V over Q; it does not claim the same
+pathwise minimum on an arbitrary finite, bounded coefficient promise.
+
+## Source-bound finite premises
+
+Group the ports by their first axes. If C_b is one group, let
+`L_b(c)=sum_(p in C_b) r_p c_p`. H factors through the direct sum L of
+these group maps. The actual source has 47 groups. The axis-2 group C
+has 30 columns and rank eight; all other groups have independent
+columns, 66 columns in total. Hence `rank L=74`.
+
+Vectors supported on C with `R_C c_C=0` form a 22-dimensional subspace
+K of V and have H(c)=f_2 R_C c_C=0. Also `dim V=96-8=88`. Therefore
+`rank(H|V)<=88-22=66` for the **whole owner array**.
+
+For a matching lower bound, the verifier constructs an integer basis
+N of V and evaluates H on the 17 actual owners used by PR2354:
+identity and `rho_1(p)` for p=0,...,15. The resulting 136-by-88 matrix
+has a 66-by-66 integer minor with determinant
+
+```text
+174085318024506601157689344.
+```
+
+The receipt includes the minor, its original row and basis-column
+indices, and a digest of the reproducibly constructed basis N. Exact
+rational elimination selects it; fraction-free integer elimination
+checks the determinant with every division checked. This is a direct
+certificate on V, complementary to the predecessor's rank-74 certificate
+on the whole coefficient space. A nonzero evaluation minor proves a
+lower bound for the complete owner map; the matching upper bound is the
+all-owner factorization above. No independence of formal bit functions
+or sampled-owner extrapolation is assumed. We have proved
+
+```text
+rank(H|V)=66,       ker(H|V)=K.                           (3)
+```
+
+## All 45 optimal terminal sets
+
+If an exact leaf has |S|=66, (1), (3), and rank-nullity imply
+`ker(Q_S|V)=K`: both kernels have dimension 22. In particular, every
+queried coordinate must vanish on K. The exact source census gives:
+
+* Every coordinate outside C vanishes on K, since K is supported on C.
+* Each of the 29 coordinates in `C minus {77}` varies on K. The receipt
+  supplies a kernel vector with that coordinate nonzero, and deleting
+  its R_C column leaves rank eight.
+* Coordinate 77 vanishes on K. Deleting that column reduces rank to seven.
+
+Thus every optimal S is a 66-subset of the 67-element set
+`J=(U minus C) union {77}`. The single dependence among these 67
+coordinate functionals on V is particularly simple. Set
+
+```text
+w=(-1,0,1,0,1,0,1,0),
+alpha_p=(w r_p)/(-4),             p in U minus C.
+```
+
+The checker verifies that w annihilates `R_(C minus {77})`, while
+`w r_77=-4`. Therefore `R_U c=0` gives
+
+```text
+c_77 + sum_(p in U minus C) alpha_p c_p = 0.              (4)
+```
+
+Exactly 44 of the 66 alpha_p are nonzero, all in `{1/2,-1/2}`. The
+original 66 coordinates `U minus C` are independent on V: H factors
+through them and has rank 66. Thus (4) spans the entire dependence
+space on J. Removing one coordinate q from J leaves an independent
+66-set exactly when its coefficient in (4) is nonzero. This gives
+**45 sets**: omit 77, or omit one of those 44 ports. Omitting one of
+the other 22 ports leaves query rank 65 and cannot recover H.
+
+The verifier checks all 67 candidate ranks separately. Any 66-read
+adaptive leaf outside J is already excluded by its explicit nuisance
+vector in K. Together these arguments exhaust all `choose(96,66)`
+possible read sets without enumerating them. Adaptivity may choose
+among the 45 successful leaves, but cannot reduce the count or use a
+29-coordinate nuisance direction at an optimal leaf.
+
+### Explicit attaining decoders
+
+Let S0=U minus C. Since all unread first axes equal 2 and R_U c=0,
+
+```text
+H(c)(d) = sum_(p in S0) r_p c_p [f_(b_p)(d)-f_2(d)].     (5)
+```
+
+This is an all-owner identity. It reconstructs H from the 66 scalars in
+S0, without reconstructing the 30 unread coefficients. If a successful
+set omits q in S0 and reads 77 instead, use (4) to obtain
+
+```text
+c_q = [-c_77 - sum_(p in S0 minus {q}) alpha_p c_p]/alpha_q
+```
+
+and apply (5). Every division is by a nonzero rational. The verifier
+checks (5) on all 88 kernel-basis vectors and all 136 evaluation rows,
+and checks every exchanged decoder on all 88 basis vectors. Its formal
+proof covers every owner. Finally apply `-P_(0,A)` if the requested
+output is the original selected A input rather than H.
+
+These are family decoders only. They do not establish recovery on a
+different hidden family or arbitrary QQ16 inputs, legal native final
+reads, a restored physical controller, or any favorable recursive bill.
+
+## Reproduction and evidence boundary
+
+Python 3.12 and the standard library suffice:
+
+```sh
+python3 -I -B scripts/research_package.py --package research/qq16-adaptive-coordinate-reads
+python3 -I -O -B research/qq16-adaptive-coordinate-reads/verify.py
+```
+
+The direct replay prints:
+
+```text
+PASS_QQ16_ADAPTIVE_READS defect=66 optimum=66 optimal_sets=45 nuisance_coordinates=29 controls=11 no_new_kappa
+```
+
+The replay is read-only. `--emit NEW_PATH` creates a receipt exclusively.
+The whole canonical receipt, including JSON scalar types, must agree.
+Source bytes and the consumed archive member are authenticated before
+arithmetic; main-file pins and Git blobs are in [SOURCES.json](SOURCES.json).
+No pending-PR executable is required or imported.
+
+The 11 rejecting controls include a singular minor, wrong determinant,
+identity-owner/routing shortcuts, an omitted attaining coordinate,
+wrong decoder sign, the false 65-read and unique-set claims, a wrong
+kernel-constant assertion, a singular exchanged read set, and a JSON
+type mutation. A separate exhaustive decision-tree control over 16
+binary inputs considers every adaptive branch choice (147 distinct
+cells): two pair-parity targets with five scalar queries require three
+reads even on average. A dense vector query reduces that toy count to
+one; a nonlinear OR target permits shorter paths. These controls expose
+the observation and linear-target hypotheses; they do not prove the
+rational infinite-domain theorem.
+
+All results are author-checked, with substantial AI assistance. The
+proof is written mathematics, not proof-assistant formalization. The
+rank, route and decoder checks do not reexecute native QQ16 children,
+the full selected supplier, all-size precision or the outer multiplier.
+The count 66 is neither per owner nor a recursive-rank/native-line
+tariff. No selected-frontier change or independent human review is claimed.
+
+## Open next questions
+
+1. **Which of the 45 family-optimal sets has a favorable native access
+   bill, and does it detect other hidden families?** The new classification
+   narrows that search to a finite list. All 45 sets omit the same 29
+   ports `C minus {77}`. A separate hidden-input witness supported there
+   would defeat all 45 sets at once. First check that precise support
+   and the full ordered observations, then price any surviving change.
+   Family sufficiency is the blocker; the complementary second-axis
+   investigation tests the original set. That separate witness is not
+   checked or incorporated into a stronger bound by this package.
+2. **What quantitative bound holds for bounded-error readers?** The
+   zero-error countable-intersection argument does not answer it. First
+   specify an input distribution and success criterion and derive a
+   distributional decision-tree bound. Arbitrary rational inputs have no
+   preferred uniform distribution, so an unstated average-case model
+   would not be meaningful.
+
+Structured questions and the task card are in [TASK.json](TASK.json).
+
+## Credit and exact predecessors
+
+Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance.
+
+* **kyzer1023, PR2354**, head
+  `308ebc7405303bb7ed91b012bb705949c6091a16`: whole-owner rank 74,
+  defect 66, the 17-owner certificate idea, and the fixed-set family
+  threshold. Its exclusion of adaptive reads is the changed premise here.
+* **commdata2338, PR2326**, head
+  `fb7d64cd4a51c49bc56920305b0aca64011a420c`: coordinate-access contract,
+  eight-dimensional identity-owner defect, and the threshold handoff.
+* **Adam Gall, PR2093**, head
+  `8b21a900eb520e4f11ea177b310f66316f8e8983`: common-axis rational
+  bit-function family, initial A cancellation and retained-tail argument.
+* **Ali Romman, PR1969**: local QQ16 contracts, actual route packet,
+  native frame conventions and original lost-query witness.
+* **Cinna Davis, PR2216/PR2268**, and **EdDiboi's parallel fixed-set
+  parity-subspace work**: the shear/tap question and complementary
+  fixed-coordinate threshold evidence. The selected-shear acts trivially
+  on this family and is not charged as a new construction here.
+
+Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority
+revision 4. The selected result and all frozen inputs are unchanged.
+Retain the QQ16 [NOTICE.md](../joint-query/NOTICE.md) and original
+construction lineage. New proof and code are Apache-2.0. OpenAI Codex
+did the derivation, implementation, checking and writing; no independent
+human review is claimed.
diff --git a/research/qq16-adaptive-coordinate-reads/RESULT.json b/research/qq16-adaptive-coordinate-reads/RESULT.json
new file mode 100644
index 0000000000..7e5fa1531a
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/RESULT.json
@@ -0,0 +1,609 @@
+{
+  "H_kernel_dimension": 22,
+  "H_on_V_rank": 66,
+  "V_basis_sha256": "aa6f9152067a4b3fbee1b72c6ed3eab2124ab393bde3111b4259d487c4bcb4b8",
+  "V_dimension": 88,
+  "adaptive_tree_control": {
+    "dense_vector_query_optimum": 1,
+    "domain": "F2^4, five scalar linear queries",
+    "nonlinear_OR_mean_queries": "3/2",
+    "optimal_mean_queries": "3",
+    "optimal_worst_queries": 3,
+    "states": 147
+  },
+  "axis_groups": 47,
+  "candidate_read_ranks": [
+    {
+      "omitted_port": 1,
+      "rank": 65
+    },
+    {
+      "omitted_port": 2,
+      "rank": 65
+    },
+    {
+      "omitted_port": 3,
+      "rank": 65
+    },
+    {
+      "omitted_port": 4,
+      "rank": 65
+    },
+    {
+      "omitted_port": 5,
+      "rank": 65
+    },
+    {
+      "omitted_port": 6,
+      "rank": 66
+    },
+    {
+      "omitted_port": 8,
+      "rank": 66
+    },
+    {
+      "omitted_port": 9,
+      "rank": 66
+    },
+    {
+      "omitted_port": 10,
+      "rank": 66
+    },
+    {
+      "omitted_port": 11,
+      "rank": 66
+    },
+    {
+      "omitted_port": 12,
+      "rank": 66
+    },
+    {
+      "omitted_port": 13,
+      "rank": 66
+    },
+    {
+      "omitted_port": 14,
+      "rank": 66
+    },
+    {
+      "omitted_port": 15,
+      "rank": 66
+    },
+    {
+      "omitted_port": 16,
+      "rank": 66
+    },
+    {
+      "omitted_port": 17,
+      "rank": 66
+    },
+    {
+      "omitted_port": 18,
+      "rank": 66
+    },
+    {
+      "omitted_port": 19,
+      "rank": 66
+    },
+    {
+      "omitted_port": 22,
+      "rank": 66
+    },
+    {
+      "omitted_port": 23,
+      "rank": 66
+    },
+    {
+      "omitted_port": 24,
+      "rank": 66
+    },
+    {
+      "omitted_port": 25,
+      "rank": 66
+    },
+    {
+      "omitted_port": 26,
+      "rank": 66
+    },
+    {
+      "omitted_port": 28,
+      "rank": 66
+    },
+    {
+      "omitted_port": 29,
+      "rank": 66
+    },
+    {
+      "omitted_port": 30,
+      "rank": 66
+    },
+    {
+      "omitted_port": 31,
+      "rank": 66
+    },
+    {
+      "omitted_port": 32,
+      "rank": 66
+    },
+    {
+      "omitted_port": 33,
+      "rank": 66
+    },
+    {
+      "omitted_port": 34,
+      "rank": 66
+    },
+    {
+      "omitted_port": 35,
+      "rank": 66
+    },
+    {
+      "omitted_port": 38,
+      "rank": 66
+    },
+    {
+      "omitted_port": 39,
+      "rank": 66
+    },
+    {
+      "omitted_port": 40,
+      "rank": 66
+    },
+    {
+      "omitted_port": 41,
+      "rank": 66
+    },
+    {
+      "omitted_port": 42,
+      "rank": 66
+    },
+    {
+      "omitted_port": 43,
+      "rank": 66
+    },
+    {
+      "omitted_port": 77,
+      "rank": 66
+    },
+    {
+      "omitted_port": 78,
+      "rank": 66
+    },
+    {
+      "omitted_port": 79,
+      "rank": 66
+    },
+    {
+      "omitted_port": 80,
+      "rank": 66
+    },
+    {
+      "omitted_port": 82,
+      "rank": 66
+    },
+    {
+      "omitted_port": 83,
+      "rank": 66
+    },
+    {
+      "omitted_port": 84,
+      "rank": 66
+    },
+    {
+      "omitted_port": 85,
+      "rank": 66
+    },
+    {
+      "omitted_port": 86,
+      "rank": 66
+    },
+    {
+      "omitted_port": 88,
+      "rank": 66
+    },
+    {
+      "omitted_port": 89,
+      "rank": 66
+    },
+    {
+      "omitted_port": 90,
+      "rank": 66
+    },
+    {
+      "omitted_port": 91,
+      "rank": 66
+    },
+    {
+      "omitted_port": 93,
+      "rank": 65
+    },
+    {
+      "omitted_port": 94,
+      "rank": 65
+    },
+    {
+      "omitted_port": 95,
+      "rank": 65
+    },
+    {
+      "omitted_port": 96,
+      "rank": 65
+    },
+    {
+      "omitted_port": 97,
+      "rank": 65
+    },
+    {
+      "omitted_port": 98,
+      "rank": 65
+    },
+    {
+      "omitted_port": 99,
+      "rank": 65
+    },
+    {
+      "omitted_port": 100,
+      "rank": 65
+    },
+    {
+      "omitted_port": 101,
+      "rank": 65
+    },
+    {
+      "omitted_port": 102,
+      "rank": 65
+    },
+    {
+      "omitted_port": 103,
+      "rank": 65
+    },
+    {
+      "omitted_port": 104,
+      "rank": 65
+    },
+    {
+      "omitted_port": 105,
+      "rank": 65
+    },
+    {
+      "omitted_port": 106,
+      "rank": 65
+    },
+    {
+      "omitted_port": 107,
+      "rank": 65
+    },
+    {
+      "omitted_port": 108,
+      "rank": 65
+    },
+    {
+      "omitted_port": 109,
+      "rank": 65
+    }
+  ],
+  "claim": "Exact side-effect-free coordinate-oracle recovery on the credited rational family; not full controller recovery or a physical cost.",
+  "coloop_ports": [77],
+  "coordinate_relation": {
+    "1": "0",
+    "10": "1/2",
+    "100": "0",
+    "101": "0",
+    "102": "0",
+    "103": "0",
+    "104": "0",
+    "105": "0",
+    "106": "0",
+    "107": "0",
+    "108": "0",
+    "109": "0",
+    "11": "1/2",
+    "12": "-1/2",
+    "13": "-1/2",
+    "14": "-1/2",
+    "15": "-1/2",
+    "16": "-1/2",
+    "17": "1/2",
+    "18": "1/2",
+    "19": "1/2",
+    "2": "0",
+    "22": "1/2",
+    "23": "1/2",
+    "24": "1/2",
+    "25": "1/2",
+    "26": "1/2",
+    "28": "1/2",
+    "29": "1/2",
+    "3": "0",
+    "30": "1/2",
+    "31": "1/2",
+    "32": "1/2",
+    "33": "1/2",
+    "34": "1/2",
+    "35": "1/2",
+    "38": "1/2",
+    "39": "1/2",
+    "4": "0",
+    "40": "1/2",
+    "41": "-1/2",
+    "42": "-1/2",
+    "43": "-1/2",
+    "5": "0",
+    "6": "-1/2",
+    "77": "1",
+    "78": "-1/2",
+    "79": "1/2",
+    "8": "-1/2",
+    "80": "-1/2",
+    "82": "-1/2",
+    "83": "-1/2",
+    "84": "-1/2",
+    "85": "1/2",
+    "86": "1/2",
+    "88": "1/2",
+    "89": "1/2",
+    "9": "1/2",
+    "90": "1/2",
+    "91": "1/2",
+    "93": "0",
+    "94": "0",
+    "95": "0",
+    "96": "0",
+    "97": "0",
+    "98": "0",
+    "99": "0"
+  },
+  "data_member_sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa",
+  "decoder_basis_equalities": 11968,
+  "defect_minor": {
+    "basis_columns": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 37, 40, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87],
+    "determinant": "174085318024506601157689344",
+    "matrix": [
+      [-1, -1, -1, 1, 1, 1, 1, -2, -2, -2, -2, -2, -2, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -3, -1, -1, -1, -1, -1, -5, 3, -1, 1, 1, 1, 1, -1, -1, -1, -2, -2, -2, -1, 1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 0, 0, 0, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+      [1, 1, 1, -1, -1, -1, 0, 1, 1, 1, 2, 2, 2, 3, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, -1, -1, -1, 3, 3, -1, -1, -1, 1, -1, 3, -1, 3, -1, -1, -1, -1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+      [-1, 0, 0, 1, 0, 0, 1, -2, -1, -1, -1, -1, 0, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 2, 2, 2, 0, -2, -2, 0, 0, 0, -2, -2, 2, -2, 2, 2, 2, 2, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, -1, 1, 0, 1, -1, 0, 0, -1, 1, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, -1, -1, 0, 1, 1, 1, -1, -2, -2, -1, -1, -2, -6, -4, -4, -4, -4, -4, -4, -4, -4, -2, -2, -2, -2, 2, 2, 2, 0, -2, 0, -2, -2, 0, 0, -4, 4, -4, 2, 2, 2, 2, -1, -1, -1, -1, -2, -2, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0],
+      [1, 0, 0, -1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 4, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 2, 2, -2, 2, 0, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -5, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 3, -1, 1, 1, 1, 1, -1, -1, -1, -2, -2, -2, -1, 0, -1, -1, -1, -1, 0, -1, -1, -1, -1, 0, 0, 0, -1, -1, -1],
+      [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, -2, 2, -2, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, 0, 0, 0],
+      [0, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, -2, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 1, 1, 1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
+      [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, -1, -1, -1, 3, 3, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 0, 1, 1, -1, 0, -1, 0, 0, 0, 1, 0, 1, 1, -1, 0, 1, 1, -1, 0, 0],
+      [0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1],
+      [0, 0, 0, 0, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -3, -3, -3, -3, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 1, -1, -1, 1, -1, -1, 0, -1, 0, 0, -1, -1, -1, 0, 0, -1, -1, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, -1],
+      [0, 0, 0, -1, 0, 0, -1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 1, 0, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, -1, -1, 0, -1, 0, 0, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, -1, -1, -1],
+      [0, 0, 0, 0, 0, 0, 1, -1, -1, -1, 0, 0, 0, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 0, 0, 0, 0, -1, 1, 1, 1, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 1, 1, 1, 0, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
+      [0, 0, 0, 0, 0, 0, -1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -3, -1, -1, 1, 1, 1, 0, 1, 1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1],
+      [0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, -2, -2, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, -1],
+      [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 0, 1, 0, 0, 1, 1, 0, -1, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, 1, 0, 0],
+      [1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, -1, -1, -1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 2, -2, 2, -2, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1],
+      [0, 0, 0, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 1, -1, 1, -1, -1, -1, 0, 0, -1, -1, -1, -1, 0, 1, -1, -1, -1, 0, 0, -1, -1, -1, 0, -1, -1, -1, 0, 0, 0],
+      [1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 3, -3, 3, -3, -1, -1, -1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1],
+      [-1, -1, -1, 1, 1, 1, 2, -2, -2, -2, -2, -2, -2, -6, -4, -4, -4, -4, -4, -4, -4, -4, 0, 0, -2, -2, 2, 2, 2, -2, -2, 0, 0, 0, 0, 0, -6, 4, -4, 0, 0, 2, 2, 0, 0, -2, -2, -1, -1, -2, 1, -2, -1, -1, -2, -1, -2, -1, -1, 0, 0, 1, 1, -1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0],
+      [-1, -1, -1, 1, 1, 1, 2, -2, -2, -2, -2, -2, -2, -5, -3, -3, -3, -3, -3, -3, -3, -3, -1, -3, -1, -1, 1, 1, 1, -1, -3, -1, -1, -1, -1, -1, -5, 5, -5, 1, 3, 1, 1, 0, 0, -1, -1, -2, -2, -2, 0, -1, -2, -2, -2, 0, -1, -2, -2, -1, 1, 0, 0, 0, -1, -1],
+      [-1, 0, 0, 0, 0, 0, 0, -1, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, -1, -1, 0, 0, 0, 0, -1, -1],
+      [0, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0],
+      [0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, -2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, 0, -1, -1, 1, 0, -1, -1, 0, 0, 0],
+      [-1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 0, -1, -1, 0, 0, 0, 0, -1, 1, 1, -1, -1, -1, 0, 0, 0, -1, 1, 1, -1, 1, 1],
+      [1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -3, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 0, 1, 0, 0, -1, 0, 1, 0, 0, -1, 1, 1, 1, 1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, -1, -1, 0, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, -1, -1, -1],
+      [1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, 1, 0, -1, -1, -1, -1, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0],
+      [0, -1, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, -1, 0, 0, 0, -1, 0, -1],
+      [0, 0, 0, 0, 1, 0, 0, 0, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0],
+      [0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, -2, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, -2, 0, -2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, -1, 0, -1, 1, -1, 0, -1, 0, 0, 0],
+      [0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 0, -1, 0, -1, 0, 0, 0, 1, -1, 1, -1, -1, 0, -1, 0, 0, 1, -1, 1, 1, -1, 1],
+      [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, 0, 0, 1, 1, 1, 0, 0, 1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 1, -1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, 0, -2, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, 0, -1],
+      [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 0, 1, 1, 0, -1, 1, 0, 1, -1, -1, -1, 0, 1, -1, 0, 1, 1, 0, 1, 1, 0],
+      [0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, -1, 0, 0, -1, 0, 0, 0, -1, 0, -1, -1, 0, -1, 0, 0, 0, -1, -1, 0],
+      [0, 0, 0, 0, 0, 1, 0, 0, 0, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1],
+      [0, 0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, -2, -2, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, -1, -1, 0, 1, -1, -1, 0, 0, 0, 0],
+      [0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 0, -1, 0, 0, -1, 0, 0, 1, 1, -1, -1, -1, 0, 0, -1, 0, 1, 1, -1, 1, 1, -1],
+      [0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, 0, 0, 1, 1, 1, 0, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 1, 0, -1, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, -1, -1, 0, -1, -1],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, -2, 0, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, 0],
+      [1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 3, 3, 1, 1, 1, 1, 3, 3, 3, 3, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 3, -3, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1],
+      [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 3, -1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 3, -3, 1, -1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, -1, 1, 1, 1, 0, 1, 1, 1, 1, -1, 1, 1, 1, 0, 0, 0],
+      [-1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -3, -1, -1, -1, -1, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -3, 1, -3, 3, 1, 1, 1, 0, 0, -1, -1, -1, -1, 0, 0, -1, -1, -1, 0, 0, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1],
+      [1, 0, 0, -1, 0, 0, -2, 2, 2, 2, 2, 2, 2, 6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 2, 2, 0, 0, -2, 2, 2, 0, 0, 0, 0, 0, 6, -4, 4, 0, 0, -2, -2, 0, 0, 2, 2, 2, 2, 2, -1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 0, -1, -1, 1, 0, 0],
+      [0, 1, -1, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 1, -1, 0, 0, 1, -1, 0, 1, -1],
+      [1, 0, 0, 0, 0, 0, 1, 0, -1, -1, 0, 0, 0, -2, -2, -2, -2, -2, 2, -2, 0, 0, 2, -2, 0, 0, 2, 2, 0, 0, -2, 0, 0, 0, 2, -2, 0, 2, 0, -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0],
+      [0, 1, -1, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, -2, 2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 1, -1, 0, 0, 1, -1, 0, 1, -1],
+      [0, 0, 0, -1, 0, 0, -1, 0, 1, 1, 0, 0, 0, 0, 0, 2, 0, 0, -2, 0, 0, 0, 0, 2, 0, 0, -2, -2, 0, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, -1, 0, -1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, -2, 0, 0, 0, 0, 0, 2, 0, -2, 0, -2, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, -1, -1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 2, 0, -2, -2, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0]
+    ],
+    "rows": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 68, 69, 114, 122, 130]
+  },
+  "dual_normalizer": -4,
+  "dual_vector": [-1, 0, 1, 0, 1, 0, 1, 0],
+  "eligible_optimal_ports": [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 77, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
+  "nuisance_witnesses": [
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 44
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 45
+    },
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 48
+    },
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [-1, 1, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 49
+    },
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [-1, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 50
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 51
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 1, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 52
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 53
+    },
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [0, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 54
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 55
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 56
+    },
+    {
+      "coordinate_value": -1,
+      "kernel_vector": [0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 58
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 59
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 60
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 61
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [1, -1, -1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 62
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 63
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 64
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 1, 1, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 65
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [0, 0, 2, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 66
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, -1, -1, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 67
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, 0, -2, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+      "port": 68
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, 0, -1, -1, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+      "port": 69
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+      "port": 70
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      "port": 71
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-1, 0, 1, -1, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+      "port": 72
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+      "port": 73
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+      "port": 74
+    },
+    {
+      "coordinate_value": 1,
+      "kernel_vector": [-2, 1, 1, -1, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+      "port": 75
+    }
+  ],
+  "optimal_omissions": [6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 77, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91],
+  "optimal_read_set_count": 45,
+  "ordinary_dimension": 96,
+  "original_attaining_read_set": [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
+  "owner_evaluations": 17,
+  "registered_nonzero_routes": 896,
+  "rejecting_controls": [
+    "singular defect minor",
+    "wrong determinant",
+    "identity owner substituted for whole array",
+    "identity substituted as stage-one route",
+    "one attaining port omitted",
+    "wrong f2 decoder sign",
+    "65 scalar queries claimed enough",
+    "C coordinate declared constant on invisible kernel",
+    "unique optimal set claimed",
+    "zero relation coefficient used for exchange",
+    "JSON Boolean substituted for integer"
+  ],
+  "schema": "qq16-adaptive-coordinate-reads-v1",
+  "source_hashes": {
+    "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754",
+    "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7",
+    "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75",
+    "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4"
+  },
+  "status": "PASS_QQ16_ADAPTIVE_READS",
+  "unread_axis2_group": [44, 45, 48, 49, 50, 51, 52, 53, 54, 55, 56, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 77]
+}
diff --git a/research/qq16-adaptive-coordinate-reads/SOURCES.json b/research/qq16-adaptive-coordinate-reads/SOURCES.json
new file mode 100644
index 0000000000..30b80ff300
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/SOURCES.json
@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "research/community-frontier1042-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b",
+      "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754"
+    },
+    {
+      "path": "research/joint-query/certificate.json.gz",
+      "usage": "input",
+      "git_blob": "c6e876d8b48d768214deee265ade428f8983b566",
+      "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7"
+    },
+    {
+      "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+      "usage": "input",
+      "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179",
+      "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75"
+    },
+    {
+      "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json",
+      "usage": "input",
+      "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f",
+      "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4"
+    }
+  ]
+}
diff --git a/research/qq16-adaptive-coordinate-reads/TASK.json b/research/qq16-adaptive-coordinate-reads/TASK.json
new file mode 100644
index 0000000000..b6375a4994
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/TASK.json
@@ -0,0 +1,136 @@
+{
+  "schema_version": 1,
+  "task_id": "joint-query-controller",
+  "priority_revision": 4,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "original_card": {
+    "id": "joint-query-controller",
+    "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?",
+    "starting_points": [
+      "research/joint-query/README.md",
+      "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md",
+      "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+      "docs/research/community-efficient1000-review.md"
+    ],
+    "methods": [
+      "Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.",
+      "Change the first local pair or retained state, then test the existing lost-observation witness and price all new operations."
+    ],
+    "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read the fixed-first-pair QQ16 witness before designing a controller. The checked #1969 local words do not evade that witness or supply global placement.",
+      "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission."
+    },
+    "first_experiment": "Apply the existing witness to one proposed extra observation or changed first pair. If it still loses the required record, stop. Otherwise derive one ordered two-call identity and charge the added read, chart maps and restoration before extending to more stages.",
+    "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.",
+    "allowed_variations": [
+      "One paid query, one changed first pair, or one precisely specified affine helper state.",
+      "A counterexample or lower bound for that exact proposed repair."
+    ],
+    "scope_change_triggers": [
+      "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.",
+      "Treating cover-map counts as zero-cost physical address operations."
+    ],
+    "overlap_terms": [
+      "QQ16",
+      "joint-query",
+      "changing-chart controller",
+      "selected observation",
+      "1969"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Exact adaptive coordinate-oracle recovery on the PR2354 rational QQ16 common-first-axis family: sharp 66 distinct reads on every input, zero-error randomized extension, and classification of all 45 optimal terminal read sets.",
+  "scope_change_reason": "Take the live central coordinate-access boundary in PR2354, which explicitly excludes adaptivity. This is a scoped lower bound for that repair, not a completed controller or native-cost construction.",
+  "bottleneck_link": "The QQ16 controller loses selected input information. Adaptive choices of ordinary reads are a possible interface change; this proof excludes fewer than 66 ports on the credited family even with free reads, computation and retention, and lists the family-optimal sets to screen before native pricing.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after the quantified transcript-fiber proof, exact source-bound finite premises and complete optimal-set classification. No search for a full controller, new family, or supplier bill.",
+  "outcome": "completed",
+  "evidence": "README.md contains the scoped proof. RESULT.json contains a 66x66 integer minor with determinant 174085318024506601157689344, 29 kernel-coordinate witnesses, all 67 candidate read-set ranks (45 of rank 66), all 44 exchange decoders, 11968 owner/basis equalities, 11 rejecting controls and exhaustive finite adaptive-tree controls. VERIFY.json registers normal, optimized and artifact-integrity replays.",
+  "author": "commdata2338",
+  "ai_assistance": "Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. OpenAI Codex did the derivation, implementation, checking and writing. No independent human review is claimed.",
+  "open_questions": [
+    {
+      "question": "Which of the 45 family-optimal sets survives other hidden-input families and has a favorable complete native access bill?",
+      "why_it_matters": "Family decoding alone cannot restore an arbitrary QQ16 input; the classification makes the remaining fixed-set choices explicit.",
+      "first_step": "All 45 sets omit C minus {77}. First test a different hidden-input witness supported on those same 29 ports against the complete ordered observations; a successful witness would screen all optimal sets at once.",
+      "blocked_by": "No full controller injectivity or native implementation is established here; complementary second-axis work tests the original set."
+    },
+    {
+      "question": "What distributional lower bound holds for bounded-error adaptive readers?",
+      "why_it_matters": "The zero-error countability proof does not apply to algorithms permitted a positive failure probability.",
+      "first_step": "Specify a finite rational input distribution and exact-output success criterion, then prove a decision-tree success bound.",
+      "blocked_by": "There is no uniform distribution on all rational inputs; the input and error model must be explicit."
+    }
+  ],
+  "scope_key": "22e535909f1d243e7553",
+  "refined_scope_key": "QQ16/PR2354-first-axis-family/adaptive-coordinate-decision-trees/exact-recovery",
+  "selection": {
+    "mode": "central-interface-followup override",
+    "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/2354",
+    "reason": "The predecessor explicitly excludes adaptive coordinate choices; the dense old-chart and full dispatch handoffs are already active. This takes a distinct QQ16 access-contract question.",
+    "task_retrieval_nonce": "68a7f11a97c2e55fc020480ffc2b66fd",
+    "track": "recursive-interfaces",
+    "scope_key": "22e535909f1d243e7553"
+  },
+  "predecessors": [
+    {
+      "pr": 2354,
+      "head": "308ebc7405303bb7ed91b012bb705949c6091a16",
+      "author": "kyzer1023",
+      "use": "Fixed-set threshold, whole-owner rank and 17-owner lower-certificate construction; source read, no executable imported."
+    },
+    {
+      "pr": 2326,
+      "head": "fb7d64cd4a51c49bc56920305b0aca64011a420c",
+      "author": "commdata2338",
+      "use": "Coordinate-access contract and hidden-family trajectory."
+    },
+    {
+      "pr": 2093,
+      "head": "8b21a900eb520e4f11ea177b310f66316f8e8983",
+      "author": "Adam Gall",
+      "use": "Common-axis bit-function family and cancellation argument."
+    }
+  ],
+  "coordination": {
+    "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942816",
+    "nearest_parallel": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942783",
+    "difference": "The parallel investigation changes the first-axis family to a second-axis witness against the original fixed attaining set. This package retains the first-axis family, changes the query rule to adaptive, and classifies all optimal terminal sets."
+  },
+  "refresh_checkpoint": {
+    "utc": "2026-10-15T07:03:27Z",
+    "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+    "priority_revision": 4,
+    "changes_from_base": "none; main, guidance, selected record and retained source inputs unchanged",
+    "decision": "continue on frozen base; exact PR2354 and PR2326 heads re-fetched unchanged"
+  },
+  "overlap": {
+    "entry_open_prs_fetched_at": "2026-10-15T06:28:56.749233+00:00",
+    "entry_discussions_fetched_at": "2026-10-15T06:31:18.032505+00:00",
+    "final_open_prs_fetched_at": "2026-10-15T06:55:23.240869+00:00",
+    "final_discussions_fetched_at": "2026-10-15T06:57:32.010338+00:00",
+    "final_open_prs": 583,
+    "final_discussion_records": 1111,
+    "complete_pagination": true,
+    "queries": [
+      "QQ16 adaptive",
+      "adaptive coordinate",
+      "adaptive tap",
+      "optimal read set",
+      "66-port"
+    ],
+    "limits": "Cached metadata coverage; excludes arbitrary code diffs. Exact predecessor heads checked separately. No novelty guarantee.",
+    "nearest_distinct_new_result": {
+      "pr": 2368,
+      "head": "e5d4d78dcfdd55d323fcbc60df477b9f25c7abff",
+      "scope": "Different full ordered kernel after the shear plus one dense old-chart record; context only, no proof dependency."
+    }
+  }
+}
diff --git a/research/qq16-adaptive-coordinate-reads/VERIFY.json b/research/qq16-adaptive-coordinate-reads/VERIFY.json
new file mode 100644
index 0000000000..f06ec1cf7b
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/VERIFY.json
@@ -0,0 +1,45 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-frontier1042-audit/selected-replay.tar.gz",
+    "research/joint-query/certificate.json.gz",
+    "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+    "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact rational/integer source premises, all optimal read sets, decoder identities, semantic controls and whole receipt equality."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "The identical acceptance boundary with Python assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/test_artifacts.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Relocated read-only positive replay; corrupt optimal-set receipt, source bytes and missing source pin reject under optimized Python."
+    }
+  ]
+}
diff --git a/research/qq16-adaptive-coordinate-reads/test_artifacts.py b/research/qq16-adaptive-coordinate-reads/test_artifacts.py
new file mode 100644
index 0000000000..34228395b9
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/test_artifacts.py
@@ -0,0 +1,83 @@
+"""Artifact-level positive and rejecting controls, with frozen inputs untouched."""
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+class ArtifactTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.temp = tempfile.TemporaryDirectory(prefix="qq16-adaptive-")
+        cls.root = Path(cls.temp.name)
+        cls.package = cls.root / "research" / HERE.name
+        shutil.copytree(HERE, cls.package, ignore=shutil.ignore_patterns("__pycache__"))
+        source = json.loads((HERE / "SOURCES.json").read_text())
+        for row in source["files"]:
+            if row["usage"] == "input":
+                target = cls.root / row["path"]
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(ROOT / row["path"], target)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.temp.cleanup()
+
+    def invoke(self):
+        return subprocess.run([sys.executable, "-I", "-O", "-B", str(self.package / "verify.py")],
+                              cwd=self.root, capture_output=True, text=True, timeout=120)
+
+    def test_1_relocated_positive_is_read_only(self):
+        before = {p.relative_to(self.root): p.read_bytes() for p in self.root.rglob("*") if p.is_file()}
+        result = self.invoke()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertIn("optimal_sets=45", result.stdout)
+        after = {p.relative_to(self.root): p.read_bytes() for p in self.root.rglob("*") if p.is_file()}
+        self.assertEqual(before, after)
+
+    def test_2_corrupted_optimal_set_is_rejected(self):
+        path = self.package / "RESULT.json"
+        original = path.read_bytes()
+        data = json.loads(original)
+        data["optimal_omissions"][0] = 1  # A port required by every optimal set.
+        path.write_text(json.dumps(data))
+        try:
+            result = self.invoke()
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("complete receipt equality", result.stderr)
+        finally:
+            path.write_bytes(original)
+
+    def test_3_changed_source_is_rejected(self):
+        path = self.root / "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md"
+        original = path.read_bytes()
+        path.write_bytes(original + b"\nchanged source\n")
+        try:
+            result = self.invoke()
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("source hash", result.stderr)
+        finally:
+            path.write_bytes(original)
+
+    def test_4_dropped_input_pin_is_rejected(self):
+        path = self.package / "SOURCES.json"
+        original = path.read_bytes()
+        data = json.loads(original)
+        data["files"] = [r for r in data["files"] if r["path"] != "research/joint-query/certificate.json.gz"]
+        path.write_text(json.dumps(data))
+        try:
+            result = self.invoke()
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("complete declared source set", result.stderr)
+        finally:
+            path.write_bytes(original)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/research/qq16-adaptive-coordinate-reads/verify.py b/research/qq16-adaptive-coordinate-reads/verify.py
new file mode 100644
index 0000000000..7bee2c5eeb
--- /dev/null
+++ b/research/qq16-adaptive-coordinate-reads/verify.py
@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Exact premises for the QQ16 adaptive-coordinate theorem.
+
+Prepared for commdata2338 with substantial OpenAI Codex assistance.
+Apache-2.0. No predecessor executable is imported. Checks survive Python -O.
+"""
+import argparse
+from collections import defaultdict
+from fractions import Fraction
+from functools import lru_cache
+from hashlib import sha256
+import gzip
+import json
+from math import gcd, lcm
+from pathlib import Path
+import tarfile
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ARCHIVE = "research/community-frontier1042-audit/selected-replay.tar.gz"
+PACKET = "research/joint-query/certificate.json.gz"
+DATA_MEMBER = "t16/global/base/work/complex-nine-native/DATA-PHASES.json"
+DATA_SHA = "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa"
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def canonical(x):
+    return json.dumps(x, sort_keys=True, separators=(",", ":"))
+
+
+def digest(x):
+    return sha256(canonical(x).encode()).hexdigest()
+
+
+def rref(rows):
+    a = [list(map(Fraction, row)) for row in rows]
+    need(a and a[0] and all(len(r) == len(a[0]) for r in a), "matrix dimensions")
+    pivots = []
+    for col in range(len(a[0])):
+        k = len(pivots)
+        choice = next((i for i in range(k, len(a)) if a[i][col]), None)
+        if choice is None:
+            continue
+        a[k], a[choice] = a[choice], a[k]
+        v = a[k][col]
+        a[k] = [x / v for x in a[k]]
+        for i in range(len(a)):
+            if i != k and a[i][col]:
+                v = a[i][col]
+                a[i] = [x - v * y for x, y in zip(a[i], a[k])]
+        pivots.append(col)
+        if len(pivots) == len(a):
+            break
+    return a, pivots
+
+
+def rank(rows):
+    return len(rref(rows)[1])
+
+
+def nullspace(rows):
+    """Primitive integer vectors forming a basis of a rational kernel."""
+    a, pivots = rref(rows)
+    result = []
+    for j in range(len(a[0])):
+        if j in pivots:
+            continue
+        v = [Fraction(0) for _ in a[0]]
+        v[j] = 1
+        for i, p in enumerate(pivots):
+            v[p] = -a[i][j]
+        multiple = lcm(*(x.denominator for x in v))
+        integers = [int(x * multiple) for x in v]
+        divisor = gcd(*integers)
+        result.append([x // divisor for x in integers])
+    return result
+
+
+def dot(a, b):
+    return sum(x * y for x, y in zip(a, b))
+
+
+def determinant(rows):
+    """Fraction-free determinant with checked exact divisions."""
+    a = [r[:] for r in rows]
+    n = len(a)
+    need(n and all(len(r) == n for r in a), "square determinant")
+    previous, sign = 1, 1
+    for k in range(n - 1):
+        i = next((i for i in range(k, n) if a[i][k]), None)
+        if i is None:
+            return 0
+        if i != k:
+            a[k], a[i] = a[i], a[k]
+            sign = -sign
+        pivot = a[k][k]
+        for i in range(k + 1, n):
+            for j in range(k + 1, n):
+                value, rem = divmod(a[i][j] * pivot - a[i][k] * a[k][j], previous)
+                need(rem == 0, "nonexact determinant division")
+                a[i][j] = value
+            a[i][k] = 0
+        previous = pivot
+    return sign * a[-1][-1]
+
+
+def certify_nonzero_minor(matrix, claimed):
+    actual = determinant(matrix)
+    need(actual != 0 and actual == claimed, "nonzero exact minor")
+
+
+def act(columns, v):
+    answer = 0
+    for i, column in enumerate(columns):
+        if v >> i & 1:
+            answer ^= column
+    return answer
+
+
+def swap_axes(basis, stage, v):
+    """Simultaneous orthogonal swaps, evaluated on the original vector."""
+    result = v
+    for i, b in enumerate(basis):
+        difference = b ^ (1 << (9 + 8 * (stage - 1) + i))
+        if (v & difference).bit_count() % 2:
+            result ^= difference
+    return result
+
+
+def load():
+    sources = json.loads((HERE / "SOURCES.json").read_text())
+    pins = {r["path"]: r["sha256"] for r in sources["files"] if r["usage"] == "input"}
+    need(set(pins) == {ARCHIVE, PACKET,
+        "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+        "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json"}, "complete declared source set")
+    for path, expected in pins.items():
+        need(sha256((ROOT / path).read_bytes()).hexdigest() == expected, "source hash: " + path)
+    with tarfile.open(ROOT / ARCHIVE) as archive:
+        members = [m for m in archive.getmembers() if m.name == DATA_MEMBER]
+        need(len(members) == 1 and members[0].isfile(), "unique data member")
+        raw = archive.extractfile(members[0]).read()
+        need(sha256(raw).hexdigest() == DATA_SHA, "data member hash")
+        data = json.loads(raw)
+    packet = json.loads(gzip.decompress((ROOT / PACKET).read_bytes()))
+    return packet, data, pins
+
+
+def decision_tree_controls():
+    """Enumerate every adaptive choice on finite, exact oracle problems."""
+    inputs = tuple(range(16))
+    queries = tuple(tuple((x >> i) & 1 for x in inputs) for i in range(4))
+    queries += (tuple(x.bit_count() % 2 for x in inputs),)
+    target = tuple(((x & 1) ^ ((x >> 1) & 1),
+                    ((x >> 2) & 1) ^ ((x >> 3) & 1)) for x in inputs)
+
+    def solve(qs, labels):
+        @lru_cache(None)
+        def rec(cell):
+            if len({labels[x] for x in cell}) == 1:
+                return (0, Fraction(0))
+            candidates = []
+            for q in qs:
+                parts = defaultdict(list)
+                for x in cell:
+                    parts[q[x]].append(x)
+                if len(parts) == 1:
+                    continue
+                children = [(len(v), rec(tuple(v))) for v in parts.values()]
+                worst = 1 + max(cost[0] for _, cost in children)
+                mean = 1 + sum(Fraction(n, len(cell)) * cost[1] for n, cost in children)
+                candidates.append((worst, mean))
+            need(candidates, "oracle cannot distinguish target")
+            return min(c[0] for c in candidates), min(c[1] for c in candidates)
+        result = rec(inputs)
+        return result, rec.cache_info().currsize
+
+    exact, states = solve(queries, target)
+    need(exact == (3, Fraction(3)), "adaptive parity oracle optimum")
+    dense, _ = solve(queries + (target,), target)
+    need(dense == (1, Fraction(1)), "one dense vector query escapes scalar count")
+    nonlinear = tuple((x & 1) or ((x >> 1) & 1) for x in inputs)
+    nonlin, _ = solve(queries[:4], nonlinear)
+    need(nonlin == (2, Fraction(3, 2)), "nonlinear target permits early leaves")
+    cell = [x for x in inputs if queries[0][x] == queries[1][x] == 0]
+    need(len({target[x] for x in cell}) > 1, "false two-query decoder refuted")
+    return {"domain": "F2^4, five scalar linear queries", "states": states,
+            "optimal_worst_queries": exact[0], "optimal_mean_queries": str(exact[1]),
+            "dense_vector_query_optimum": dense[0],
+            "nonlinear_OR_mean_queries": str(nonlin[1])}
+
+
+def build():
+    packet, data, pins = load()
+    U, A = packet["U_ports"], packet["A_ports"]
+    need(len(U) == 96 and len(set(U)) == 96 and len(A) == 8, "port partition")
+    R = [[Fraction(row.get(str(p), "0")) for p in range(112)] for row in packet["R_rows"]]
+    need(len(R) == 8 and all(x.denominator == 1 for row in R for x in row), "integer R")
+    R = [[int(x) for x in row] for row in R]
+    RU = [[r[p] for p in U] for r in R]
+    RA = [[r[p] for p in A] for r in R]
+    need([[dot(x, y) for y in RU] for x in RU] ==
+         [[48 * int(i == j) for j in range(8)] for i in range(8)], "ordinary Gram")
+    need([[dot(x, y) for y in RA] for x in RA] ==
+         [[4 * int(i == j) for j in range(8)] for i in range(8)], "selected section")
+    basis = [recipe["idle_children"][0]["orthogonal_axes"][:8] for recipe in data["recipes"]]
+    need(len(basis) == 112 and [r["port"] for r in data["recipes"]] == list(range(112)), "chart order")
+    registry = {tuple(m["owner_right_matrix_columns"]) for m in packet["map_registry"].values()}
+    identity = tuple(1 << i for i in range(73))
+    need(identity in registry, "identity registry entry")
+    routes = []
+    for bs in basis:
+        need(all(0 < b < 512 for b in bs), "chart axes in first nine coordinates")
+        need([[(x & y).bit_count() % 2 for y in bs] for x in bs] ==
+             [[int(i == j) for j in range(8)] for i in range(8)], "orthonormal chart")
+        port_routes = []
+        for s in range(1, 9):
+            route = tuple(swap_axes(bs, s, v) for v in identity)
+            need(route in registry, "registered route")
+            need([act(route, b) for b in bs] == [1 << (9 + 8 * (s - 1) + i) for i in range(8)], "common axes")
+            port_routes.append(route)
+        routes.append(port_routes)
+    owners = [identity] + [routes[p][0] for p in range(16)]
+    E = [[R[k][p] * (act(owner, basis[p][0]) & 1) for p in U]
+         for owner in owners for k in range(8)]
+    need(all(any(act(owner, basis[p][0]) & 1 for owner in owners) for p in U), "nonzero coordinate functions")
+    groups = defaultdict(list)
+    for p in U:
+        groups[basis[p][0]].append(p)
+    group_ranks = {b: rank([[r[p] for p in ps] for r in R]) for b, ps in groups.items()}
+    C = groups[2]
+    S = [p for p in U if p not in C]
+    need(len(C) == 30 and len(S) == 66 and group_ranks[2] == 8, "30/66 decomposition")
+    need(all(group_ranks[b] == len(ps) for b, ps in groups.items() if b != 2), "outside groups independent")
+    need(sum(group_ranks.values()) == 74, "group upper bound")
+
+    V = nullspace(RU)
+    need(len(V) == 88 and all(dot(r, v) == 0 for r in RU for v in V), "kernel basis")
+    EV = [[dot(row, v) for v in V] for row in E]
+    # A certificate directly on V; the predecessor instead certifies rank
+    # 74 on the full coefficient space. Both describe the same family.
+    row_ids = rref(list(map(list, zip(*EV))))[1]
+    col_ids = rref([EV[i] for i in row_ids])[1]
+    need(len(row_ids) == len(col_ids) == 66, "defect rank")
+    minor = [[EV[i][j] for j in col_ids] for i in row_ids]
+    det = determinant(minor)
+    certify_nonzero_minor(minor, det)
+
+    RC = [[r[p] for p in C] for r in R]
+    K = nullspace(RC)
+    need(len(K) == 22 and all(dot(r, v) == 0 for r in RC for v in K), "invisible kernel")
+    # Exactly one coordinate of C vanishes on ker(H). Classify optimal
+    # leaves instead of presuming that the original attaining set is unique.
+    nuisance = []
+    coloops = []
+    for j, p in enumerate(C):
+        v = next((v for v in K if v[j]), None)
+        deletion_rank = rank([[x for i, x in enumerate(row) if i != j] for row in RC])
+        if v is None:
+            need(deletion_rank == 7, "coloop deletion rank")
+            coloops.append(p)
+        else:
+            need(deletion_rank == 8, "non-coloop deletion rank")
+            nuisance.append({"port": p, "kernel_vector": v, "coordinate_value": v[j]})
+    need(coloops == [77] and len(nuisance) == 29, "exact nuisance/coloop classification")
+    duals = nullspace([[R[k][p] for k in range(8)] for p in C if p != 77])
+    need(len(duals) == 1, "one-dimensional dual space")
+    w = duals[0]
+    beta = dot(w, [r[77] for r in R])
+    need(beta != 0, "coloop dual normalization")
+    alpha = {p: Fraction(dot(w, [r[p] for r in R]), beta) for p in S}
+    eligible = sorted(S + [77])
+    relation = {p: alpha.get(p, Fraction(1)) for p in eligible}
+    need(all(v[U.index(77)] + sum(alpha[p] * v[U.index(p)] for p in S) == 0 for v in V),
+         "coordinate relation on V")
+    optimal_omissions = [p for p in eligible if relation[p] != 0]
+    need(len(optimal_omissions) == 45, "45 candidate optimal sets")
+    candidate_ranks = []
+    for omitted_port in eligible:
+        read = [p for p in eligible if p != omitted_port]
+        QV = [[v[U.index(p)] for v in V] for p in read]
+        actual_rank = rank(QV)
+        remaining = [p for p in U if p not in read]
+        restriction_rank = 66 + rank([[r[p] for p in remaining] for r in R]) - 8
+        need(actual_rank == restriction_rank, "independent coordinate restriction rank")
+        need(actual_rank == (66 if omitted_port in optimal_omissions else 65), "optimal-set classification")
+        candidate_ranks.append({"omitted_port": omitted_port, "rank": actual_rank})
+        if omitted_port != 77 and omitted_port in optimal_omissions:
+            for v in V:
+                recovered = (-v[U.index(77)] - sum(alpha[p] * v[U.index(p)]
+                    for p in S if p != omitted_port)) / alpha[omitted_port]
+                need(recovered == v[U.index(omitted_port)], "exchange decoder")
+    # Explicit all-owner decoder: sum_{p in S} r_p c_p (f_bp - f_2).
+    reconstructed = [[R[k][p] * ((act(owner, basis[p][0]) & 1) - (act(owner, 2) & 1))
+                      if p in S else 0 for p in U]
+                     for owner in owners for k in range(8)]
+    need(all(dot(e, v) == dot(d, v) for e, d in zip(E, reconstructed) for v in V),
+         "attaining decoder on complete kernel basis")
+    # The all-owner identity follows formally from grouping by the first
+    # axis and R_U c=0; no independence of arbitrary bit functions is used.
+    for i, owner in enumerate(owners):
+        for k in range(8):
+            need([x - y for x, y in zip(E[8*i+k], reconstructed[8*i+k])] ==
+                 [(act(owner, 2) & 1) * x for x in RU[k]], "decoder difference factors through R_U")
+
+    rejected = []
+    def reject(label, f):
+        try:
+            f()
+        except ValueError:
+            rejected.append(label)
+        else:
+            raise ValueError("control accepted: " + label)
+    bad = [r[:] for r in minor]
+    bad[-1] = bad[0][:]
+    reject("singular defect minor", lambda: certify_nonzero_minor(bad, det))
+    reject("wrong determinant", lambda: certify_nonzero_minor(minor, det + 1))
+    reject("identity owner substituted for whole array", lambda: need(rank(E[:8]) == 66, "owner rank"))
+    reject("identity substituted as stage-one route", lambda: need(act(identity, basis[1][0]) == 1 << 9, "route"))
+    omitted = [r[:] for r in reconstructed]
+    q = U.index(S[0])
+    for row in omitted:
+        row[q] = 0
+    reject("one attaining port omitted", lambda: need(all(dot(e, v) == dot(d, v)
+        for e, d in zip(E, omitted) for v in V), "65-port decoder"))
+    wrong_sign = [[R[k][p] * ((act(owner, basis[p][0]) & 1) + (act(owner, 2) & 1))
+                   if p in S else 0 for p in U] for owner in owners for k in range(8)]
+    reject("wrong f2 decoder sign", lambda: need(all(dot(e, v) == dot(d, v)
+        for e, d in zip(E, wrong_sign) for v in V), "decoder sign"))
+    reject("65 scalar queries claimed enough", lambda: need(65 >= len(row_ids), "rank budget"))
+    reject("C coordinate declared constant on invisible kernel", lambda: need(all(v[0] == 0 for v in K), "nuisance"))
+    reject("unique optimal set claimed", lambda: need(len(optimal_omissions) == 1, "45 optimal sets"))
+    zero_relation_port = next(p for p in eligible if relation[p] == 0)
+    reject("zero relation coefficient used for exchange", lambda: need(
+        next(row["rank"] for row in candidate_ranks if row["omitted_port"] == zero_relation_port) == 66,
+        "singular exchanged read set"))
+    reject("JSON Boolean substituted for integer", lambda: need(canonical({"rank": True}) == canonical({"rank": 1}), "type"))
+    toy = decision_tree_controls()
+    return {"schema": "qq16-adaptive-coordinate-reads-v1", "status": "PASS_QQ16_ADAPTIVE_READS",
+            "source_hashes": pins, "data_member_sha256": DATA_SHA,
+            "ordinary_dimension": 96, "V_dimension": 88, "H_on_V_rank": 66,
+            "H_kernel_dimension": 22, "axis_groups": len(groups),
+            "registered_nonzero_routes": 896, "owner_evaluations": 17,
+            "V_basis_sha256": digest(V),
+            "defect_minor": {"rows": row_ids, "basis_columns": col_ids,
+                             "determinant": str(det), "matrix": minor},
+            "original_attaining_read_set": S, "unread_axis2_group": C,
+            "eligible_optimal_ports": eligible, "optimal_omissions": optimal_omissions,
+            "optimal_read_set_count": len(optimal_omissions), "candidate_read_ranks": candidate_ranks,
+            "coloop_ports": coloops, "dual_vector": w, "dual_normalizer": beta,
+            "coordinate_relation": {str(p): str(a) for p, a in relation.items()},
+            "nuisance_witnesses": nuisance,
+            "decoder_basis_equalities": len(V) * len(E),
+            "adaptive_tree_control": toy, "rejecting_controls": rejected,
+            "claim": "Exact side-effect-free coordinate-oracle recovery on the credited rational family; not full controller recovery or a physical cost."}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--emit", type=Path, help="Create a new deterministic receipt exclusively")
+    args = parser.parse_args()
+    result = build()
+    if args.emit:
+        with args.emit.open("x") as f:
+            json.dump(result, f, indent=2, sort_keys=True)
+            f.write("\n")
+    else:
+        expected = json.loads((HERE / "RESULT.json").read_text())
+        need(canonical(result) == canonical(expected), "complete receipt equality")
+    print("PASS_QQ16_ADAPTIVE_READS defect=66 optimum=66 optimal_sets=45 "
+          "nuisance_coordinates=29 controls=" + str(len(result["rejecting_controls"])) + " no_new_kappa")
+
+
+if __name__ == "__main__":
+    main()