offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/nested--cce-fortran-pointer-to-type-with-allocatable-scalar-component-typed-transfer.json

@@ -0,0 +1,191 @@
+{
+ "finding": "nested/cce-fortran-pointer-to-type-with-allocatable-scalar-component-typed-transfer.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-33",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "r is mapped by enter data alloc, referenced in the target region where it is already present, and copied back by exit data from. The pointer component nx is null and never referenced; the allocatable component of n1 is unreachable. No race: one target thread. Expected sum 500..507 = 4028 and s=900 follow. The run-time error in compiler A is a defect."
+  },
+  {
+   "run": "run-20261113/batch-45",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "r is mapped with alloc on enter data, modified in a target region where it is present, and copied back with from at exit data. Pointer component nx is null and never dereferenced; its (uninitialized) device value copied back is never used. The allocatable component of n1 is never touched. Expected ha=4028, hs=900. The run-time 'unsupported flags for typed transfer' error is a compiler/runtime defect."
+  },
+  {
+   "run": "run-v2-20261113/batch-108",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The program maps a derived-type variable that has an unallocated allocatable component and a null pointer component with enter data alloc, an implicit map in the target, and exit data from. Section 5.8.3 has no restriction against mapping structures with such components, and 5.2 added support for them. The runtime error of compiler A is therefore not excused by a rule, but the spec does not spell out the exact semantics of unallocated components, so a required result is not certain.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-65",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-13",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Mapping a derived-type variable with an unallocated allocatable component and null pointer component is permitted; the program only touches r%s and r%a. enter data alloc then exit data from gives the expected values. Nothing makes the run-time failure permitted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-02",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "39856d719a9c90b647ea09687862a6bfadaa99adbdf7ac748de19f5fe919ba23",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "One independent reading was uncertain; 2 adjudicating readings that weighed both find the program legal and the result required: The program touches only r%s and r%a. Structure mapping with an unallocated allocatable component and a null pointer component is permitted: the spec treats pointer components as undefined association and allocatable components by allocation status, with no restriction against such a component. The enter data alloc, target and exit data from sequence is well defined and yields 4028 and 900. the runtime error is a compiler defect.",
+ "adjudicators": [
+  {
+   "run": "adj-v2-20261113/batch-05",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The program touches only r%s and r%a. Structure mapping with an unallocated allocatable component and a null pointer component is permitted: the spec treats pointer components as undefined association and allocatable components by allocation status, with no restriction against such a component. The enter data alloc, target and exit data from sequence is well defined and yields 4028 and 900. Reading B is right; the runtime error is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-09",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113/batch-10",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Mapping a derived-type variable with an unallocated allocatable component and a null pointer component is allowed; only r%s and r%a are touched. enter data alloc, implicit present mapping in the target, then exit data from returns the device values 500..507 and 900. Reading A's doubt about unallocated components does not apply because the components are never referenced. The Cray runtime error is not permitted by any rule.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-58",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/nested--cce-fortran-update-to-pointer-root-allocatable-scalar-component-no-accelerator-object.json

@@ -0,0 +1,297 @@
+{
+ "finding": "nested/cce-fortran-update-to-pointer-root-allocatable-scalar-component-no-accelerator-object.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-10",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "r is an associated pointer in map(alloc: r), so its target is implicitly mapped in the same clause; the structure default mapper maps each element, including the allocated component nx. target update to(r) on an associated pointer acts on the pointer target, and allocated subobjects are assigned. The expected sum 996 then follows. The sequence is legal, but the interaction of implicit pointee mapping with alloc and then update through the default mapper is not spelled out for allocatable components, so a required result is not certain."
+  },
+  {
+   "run": "run-20261113/batch-59",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "r is an associated pointer; map(alloc: r) maps its target as if implicitly mapped, including the allocated allocatable component nx via the default mapper. target update to(r) assigns allocated storage. The reduction variable tot is mapped tofrom; the region reads r%a and r%nx%s without changing allocation or association. Expected tot = 8*21 + sum(100..107)=168+828=996. The runtime error indicates a compiler/runtime bug. Mild uncertainty about default-mapper handling of allocatable components in enter data/update."
+  },
+  {
+   "run": "run-v2-20261113/batch-06",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "map(alloc: r) of an associated pointer maps its target, but the allocatable component r%nx is a separate allocation that is not mapped or attached, and target update to(r) cannot transfer it. The device region reads r%nx%s, whose storage is not present in the device data environment, so with separate memory the access is not specified to work. The failure is not shown to be a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-39",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": true,
+     "false_claims": [
+      "The allocatable component r%nx is not mapped by map(alloc: r)",
+      "target update to(r) cannot transfer r%nx"
+     ],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-02",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": true,
+     "false_claims": [
+      "The allocatable component r%nx is a separate allocation that is not mapped by the map of r.",
+      "target update to(r) cannot transfer the component."
+     ],
+     "quotes": {
+      "ok": 5,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 3,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-104",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Only the pointer r is mapped (alloc), which implicitly maps its target. The allocatable component nx is not an explicit list item, so when the later target region maps r again with nx already present, the map clause may treat nx as unallocated. The device access to r%nx%s is then not guaranteed, so the observed failure is permitted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-66",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113c/batch-01",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 4,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "r is an associated Fortran pointer to a derived type with an allocated allocatable component nx. Mapping an associated pointer implicitly maps its target. The predefined default mapper maps each structure element, including the allocated components a and nx (and nx%s via n1's default mapper), so device storage exists. target update to(r) assigns allocated components and the pointer target. The combined construct then finds r present; r is not a scalar, so it is implicitly tofrom with a bumped count. tot=828+168=996. The failure 'no associated accelerator object' is a compiler mapping defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113d/batch-01",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 6,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "ad91ae70ae88199dc81cf2058da98a3f0f1bd1f6edad64f85888988db9af3e00",
+ "instructions": "v2",
+ "verdict": "contested",
+ "why": "An independent adjudicating reading finds the result not required: map(alloc: r) of an associated pointer maps its target as if implicitly mapped. The default-mapper rule for components says an allocatable component that is not an explicit list item may be treated as unallocated if the corresponding component lacks allocated storage. Whether target update to(r) transfers the pointer target and the allocatable component nx is not stated.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113/batch-06",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Program appears conforming: r is an associated pointer, its target is implicitly mapped in the same clause, the predefined default mapper maps each structure element tofrom including allocatable nx, and update assigns only allocated storage. Reading B's chain is plausible, but the text does not clearly say that map(alloc) attaches the device descriptor of an allocatable component to device storage, or that update to(r) through the pointer reaches the component. A required result is not firmly established; Reading A's caution is justified."
+  },
+  {
+   "run": "adj-20261113/batch-07",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The pointer r is associated, so map(alloc: r) maps its target. Reading B overreaches: the pointee rule is stated only for map clauses, and target update to(r) has no stated rule that moves the pointee or its allocatable component nx; it makes the corresponding list item consistent with the original. Whether r%a and r%nx%s reach the device is therefore not specified, and tot==996 is not clearly required. The program itself is conforming."
+  },
+  {
+   "run": "adj-v2-20261113b/batch-04",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "map(alloc: r) of an associated pointer maps its target as if implicitly mapped. The default-mapper rule for components says an allocatable component that is not an explicit list item may be treated as unallocated if the corresponding component lacks allocated storage. Whether target update to(r) transfers the pointer target and the allocatable component nx is not stated. Both readings admit the device access to r%nx%s is not guaranteed to work, so the failure is not shown to be a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-04",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": true,
+     "false_claims": [
+      "The specification does not state whether target update to(r) transfers the pointer target and the allocatable component nx."
+     ],
+     "quotes": {
+      "ok": 3,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-01",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113b/batch-10",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The program is conforming: r is an associated pointer, so its target is implicitly mapped, and the default mapper maps the allocatable component nx. The spec lets a map clause treat an allocated component that is present and not an explicit list item as unallocated only if the corresponding component has no allocated storage. Whether enter data alloc plus update to(r) gives nx allocated device storage with a transferred value, and whether the later implicit map of r keeps nx usable, is not stated precisely enough to require the result. Neither reading shows the failure is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-19",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/nested--gcc-acc-c-exit-data-of-a-pointer-array-element-target-hangs.json

@@ -0,0 +1,204 @@
+{
+ "finding": "nested/gcc-acc-c-exit-data-of-a-pointer-array-element-target-hangs.c",
+ "readers": [
+  {
+   "run": "run-20261113/batch-21",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "Struct members and subarrays of pointer members may appear in data clauses; copyin(r) then copyin(r.nx[0:2]) and r.nx[0][0:1] attach pointers in present device data, and the exit data deletes run in child-before-parent order, so counters reach zero cleanly. The subarray applies to the array element r.nx[0], not to a struct subarray, so the 'members of a subarray' ban does not apply (small ambiguity). The delete clause defines detach and deallocate actions for exactly this; a hang from an unhandled delete kind is a runtime defect, not a permitted outcome."
+  },
+  {
+   "run": "run-20261113/batch-48",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 1
+   },
+   "reasoning": "Struct r copied in, then member sections attached via nested enter data; deletes mirror the enters with dynamic reference counts of one. Present(r) holds. Nothing nonconforming; the hang/unhandled kind is a runtime defect."
+  },
+  {
+   "run": "run-20261113b/batch-01",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "r is copied in, then r.nx[0:2] and r.nx[0][0:1] are copied in with attach of r.nx and r.nx[0]; exit data deletes happen in reverse order. Each delete decrements the attachment counter, detaches at zero, and decrements the dynamic count; any extra decrement leaves the counter at zero. The serial region only uses r.v. All well defined, so a conforming implementation must run it without hanging."
+  },
+  {
+   "run": "run-v2-20261113/batch-103",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Whole struct r is copied in, then r.nx[0:2] and the subarray r.nx[0][0:1] are copied in, which attach the pointer members in turn. Members and subarrays of members may appear in data clauses. Exit deletes in reverse order, so no pointer is detached from freed data. The serial region uses only r.v. The program is conforming and must run with tot=6; the libgomp UNHANDLED kind and hang are an implementation defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-33",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 3,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-33",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Struct members and subarrays of members may appear in data clauses; r.nx[0:2] uses subarray notation on a member whose parent r is not a subarray, and r.nx[0][0:1] selects no member of a subarray. Delete order mirrors the copyin order. The program appears conforming, and a hang with an unhandled map kind in the runtime is a compiler or runtime defect, but attach/detach of nested pointers is not spelled out fully enough to be sure.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-62",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "6d8d656b48251f16a07cc41d5cce8467c3128f6932b8b988322c5f9a561c953b",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "One independent reading was uncertain; 2 adjudicating readings that weighed both find the program legal and the result required: Struct member r.nx with subarray r.nx[0:2] is allowed because the parent r is not a subarray; r.nx[0][0:1] is a subarray of a pointer element, not a member of a subarray. Copying r copies the pointer members without their targets, so the later member copyins attach them. Deletes run in reverse order. The serial region reads only r.v, so tot=6 is required; the UNHANDLED kind hang is a runtime defect.",
+ "adjudicators": [
+  {
+   "run": "adj-v2-20261113/batch-06",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 2,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Struct member r.nx with subarray r.nx[0:2] is allowed because the parent r is not a subarray; r.nx[0][0:1] is a subarray of a pointer element, not a member of a subarray. Copying r copies the pointer members without their targets, so the later member copyins attach them. Deletes run in reverse order. The serial region reads only r.v, so tot=6 is required; the UNHANDLED kind hang is a runtime defect. Reading B's doubt about attach rules does not make the result optional.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-29",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 3,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113/batch-10",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "r is copied in, then r.nx[0:2] attaches the member pointer, then r.nx[0][0:1] copies a section of an element. Subarrays of struct members are allowed and no parent of the member uses subarray notation. The compute region only reads r.v. Deletes run in reverse order. The libgomp unhandled kind is a runtime defect. Reading B's doubt about attach rules is answered by the attach description.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-17",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}