offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/oop/nvhpc-polymorphism-runtime-unsupported.f90

@@ -0,0 +1,94 @@
+! # Finding (fortran-oop): SELECT TYPE, CLASS(*) and finalization in device code: 'runtime function not supported'
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11: managed, separate), nvhpc269 (NVHPC 26.9: managed, separate); -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -O2 (managed: -gpu=mem:managed)
+! - failure: rejected (not_implemented); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `NVFORTRAN-S-1058-Call to Compiler runtime function not supported - pgf90_same_type_as_i8` (SELECT TYPE),
+!   `pgf90_init_unl_poly_desc_i8` (CLASS(*)), `pgf90_finalize_i8` (finalization), NVHPC 25.11 and 26.9, both modes.
+!   oop-assignfinal-final-dealloc fails on the ALLOCATE instead (`pgf90_calloc04a_i8`): not counted here. The claim rests on
+!   NVHPC's own messages; its user guide does not mention these features in device code
+! - expected: compiles; `r1= 10 r2= 100 r3= -1`
+! - rule: Fortran 2018 11.1.11, 7.5.6.3; no OpenMP restriction (section 6)
+! - other families: AFAR correct on all six; CCE takes the wrong SELECT TYPE branch (cce-select-type-guard-not-taken.f90); GCC
+!   rejects SELECT TYPE (gcc-vtab-not-marked-for-offload.f90)
+! - gate and confirmer: 24 cells, 24 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl);
+!   confirmer (results/oop/main/confirm.jsonl): unsupported (R05-unsupported) 24
+! - programs (6): oop-poly-select-type, oop-poly-class-is, oop-unlimited-select-type, oop-unlimited-classify,
+!   oop-assignfinal-final-local, oop-assignfinal-final-assign (offload/engine/oop_gen.py; this file is the first one)
+! - legality: for the nvhpc cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) and a CCE compile (tools/campaigns/oop.py legality,
+!   results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type base_t
+    integer :: a = 0
+  end type base_t
+  type, extends(base_t) :: ext1
+    integer :: u = 0
+  end type ext1
+  type, extends(base_t) :: ext2
+    integer :: v = 0
+  end type ext2
+contains
+  subroutine bump(s)
+    !$omp declare target
+    class(base_t), intent(inout) :: s
+    select type (s)
+      type is (ext1)
+        s%u = s%u + 10
+      type is (ext2)
+        s%v = s%v + 100
+      class default
+        s%a = -1
+    end select
+  end subroutine bump
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2, r3
+  type(ext1) :: e1
+  type(ext2) :: e2
+  type(base_t) :: b0
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  !$omp target map(tofrom: e1, e2, b0)
+  call bump(e1)
+  call bump(e2)
+  call bump(b0)
+  !$omp end target
+  r1 = e1%u
+  r2 = e2%v
+  r3 = b0%a
+  ok = .true.
+  ok = ok .and. (r1 == 10)
+  ok = ok .and. (r2 == 100)
+  ok = ok .and. (r3 == -1)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0)', 'r3= ', r3
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: SELECT TYPE, CLASS(*) and finalization are not supported in device code
+! summary: SELECT TYPE on a CLASS dummy, a CLASS(*) dummy and the finalization of a local object in declare target procedures are
+! + rejected by NVHPC 25.11 and 26.9: the compiler reports the runtime routines they need as not supported on the device (NVHPC's
+! + own message; its guide does not mention these features). AFAR runs all six programs correctly.
+! end site
+! spec (requirement): the base language is Fortran 2003, 2008 and 2018 with only a short list of features of unspecified
+!   behavior (SELECT TYPE, CLASS(*) and finalization are not on it; their semantics are the Fortran standard's, with no OpenMP
+!   text of their own), and a declare target procedure must be executable on a device.
+! "While future versions of the OpenMP specification are expected to address the following features, currently their use may
+!   result in unspecified behavior." (5.2 §1.7 p.36 l.6-8)
+! "Declare target directives apply to procedures and/or variables to ensure that they can be executed or accessed on a device."
+!   (5.2 §7.8 p.204 l.16-17)
+! spec (this program): bump is a declare target subroutine with a CLASS dummy and SELECT TYPE called in a target region; NVHPC
+!   rejects it with 'Call to Compiler runtime function not supported - pgf90_same_type_as_i8', so the procedure cannot be executed
+!   on the device. The same message appears for CLASS(*) and for finalization of a local object.

offload/_root/data/findings/oop/nvhpc-type-bound-call-rejected.f90

@@ -0,0 +1,89 @@
+! # Finding (fortran-oop): type-bound calls in device code rejected: 'Call to type-bound procedures are not allowed on device'
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11: managed, separate), nvhpc269 (NVHPC 26.9: managed, separate); -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -O2 (managed: -gpu=mem:managed)
+! - failure: rejected (diagnostic); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `NVFORTRAN-F-1252-Call to type-bound procedures are not allowed on device - scale_i$tbp`, NVHPC 25.11 and 26.9, both
+!   modes; the other binding calls compile and then fail at run time (linked to
+!   catalog/nvhpc-flang-type-bound-kernel-missing.f90). The claim rests on NVHPC's own message; its user guide does not mention
+!   type-bound procedures in device code
+! - expected: compiles; `r1= 180`
+! - rule: 5.2 §1.2.6 p.19 l.1-3 (type-bound procedures in a target region are allowed when declare target)
+! - other families: AFAR, CCE and GCC 16.2 correct on all three
+! - gate and confirmer: 12 cells, 12 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl);
+!   confirmer (results/oop/main/confirm.jsonl): compiler_bug (R11-compile-rejection) 6, needs_human (R12b-compile-undecided) 6
+! - programs (3): oop-tbp-generic, oop-tbp-loop, oop-assignfinal-tbp-assign (offload/engine/oop_gen.py; this file is the first one)
+! - legality: for the nvhpc cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) and a CCE compile (tools/campaigns/oop.py legality,
+!   results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec3
+    integer :: x = 0, y = 0, z = 0
+  contains
+    procedure :: norm2 => v_norm2
+    procedure, nopass :: twice => v_twice
+    procedure :: scale_i, scale_ij
+    generic :: scale => scale_i, scale_ij
+  end type vec3
+contains
+  integer function v_norm2(s)
+    !$omp declare target
+    class(vec3), intent(in) :: s
+    v_norm2 = s%x * s%x + s%y * s%y + s%z * s%z
+  end function v_norm2
+  integer function v_twice(k)
+    !$omp declare target
+    integer, intent(in) :: k
+    v_twice = 2 * k
+  end function v_twice
+  subroutine scale_i(s, k)
+    !$omp declare target
+    class(vec3), intent(inout) :: s
+    integer, intent(in) :: k
+    s%x = s%x * k
+    s%y = s%y * k
+    s%z = s%z * k
+  end subroutine scale_i
+  subroutine scale_ij(s, a, b)
+    !$omp declare target
+    class(vec3), intent(inout) :: s
+    integer, intent(in) :: a, b
+    s%x = s%x * a * b
+    s%y = s%y * a * b
+    s%z = s%z * a * b
+  end subroutine scale_ij
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(vec3) :: v
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  v%x = 1
+  v%y = 2
+  v%z = 3
+  !$omp target map(tofrom: v)
+  call v%scale(3)
+  call v%scale(2, 5)
+  !$omp end target
+  r1 = v%x + v%y + v%z
+  ok = .true.
+  ok = ok .and. (r1 == 180)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: type-bound procedure calls in device code are rejected
+! summary: Calls of type-bound procedures (a generic binding, a binding in a loop, a type-bound defined assignment) in a target
+! + region are rejected by NVHPC 25.11 and 26.9: 'Call to type-bound procedures are not allowed on device'. Every procedure involved
+! + is declare target. AFAR, CCE and GCC compile and run them correctly.
+! end site

offload/_root/data/findings/oop/nvhpc-udr-derived-type-rejected.f90

@@ -0,0 +1,67 @@
+! # Finding (fortran-oop): declare reduction on a derived type: 'Unimplemented feature - DECLARE REDUCTION'
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11: managed, separate), nvhpc269 (NVHPC 26.9: managed, separate); -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -O2 (managed: -gpu=mem:managed)
+! - failure: rejected (diagnostic); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `NVFORTRAN-W-0155-Unimplemented feature - DECLARE REDUCTION` and then `NVFORTRAN-S-0155-The reduction intrinsic must
+!   be MAX, MIN, ...`, NVHPC 25.11 and 26.9
+! - expected: compiles; `r1= 2080 r2= 4160`
+! - rule: 5.2 §5.5.11 p.139-140; NVHPC documents the gap by omission: the NVIDIA HPC Compilers User's Guide §7.4 "OpenMP Subset"
+!   (the OpenMP 5.0 features the compilers support) does not list declare reduction
+! - other families: AFAR and GCC 16.2 correct; CCE rejects them (cce-udr-derived-type-unsupported.f90)
+! - gate and confirmer: 24 cells, 24 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl);
+!   confirmer (results/oop/main/confirm.jsonl): compiler_bug (R11-compile-rejection) 12, needs_human (R12b-compile-undecided) 12
+! - programs (6): oop-dreduce-function, oop-dreduce-subroutine, oop-dreduce-operator, oop-dreduce-default-init,
+!   oop-dreduce-argmax, oop-dreduce-nested (offload/engine/oop_gen.py; this file is the first one)
+! - legality: for the nvhpc cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) (tools/campaigns/oop.py legality, results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type v2
+    integer :: x = 0, y = 0
+  end type v2
+contains
+  function vadd(a, b) result(c)
+    !$omp declare target
+    type(v2), intent(in) :: a, b
+    type(v2) :: c
+    c%x = a%x + b%x
+    c%y = a%y + b%y
+  end function vadd
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(v2) :: acc
+  integer :: i
+  !$omp declare reduction(vsum: v2: omp_out = vadd(omp_out, omp_in)) initializer(omp_priv = v2(0, 0))
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  acc = v2(0, 0)
+  !$omp target teams distribute parallel do reduction(vsum: acc)
+  do i = 1, n
+    acc = vadd(acc, v2(i, 2 * i))
+  end do
+  r1 = acc%x
+  r2 = acc%y
+  ok = .true.
+  ok = ok .and. (r1 == 2080)
+  ok = ok .and. (r2 == 4160)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: declare reduction on a derived type is not implemented
+! summary: A user-defined reduction (declare reduction) on a derived type, used on a target teams distribute parallel do, is
+! + rejected by NVHPC 25.11 and 26.9 ('Unimplemented feature - DECLARE REDUCTION'); the NVHPC user guide's OpenMP subset does not
+! + list declare reduction. AFAR and GCC run all six forms correctly.
+! end site

offload/_root/data/findings/reviews/afar-c-error-directive-in-target-link.json

@@ -0,0 +1,217 @@
+{
+ "finding": "afar-c-error-directive-in-target-link.c",
+ "readers": [
+  {
+   "run": "run-20261113/batch-26",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The error directive with at(compilation) is pure and the spec permits it; severity(warning) requires only that an implementation-defined message is displayed, with no abort. The observed output is exactly such a warning. Whether the compile was then refused is not shown, so a required-result failure is not established."
+  },
+  {
+   "run": "run-20261113/batch-55",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "An error directive with at(compilation) severity(warning) is a utility directive allowed in a target region. The specification requires only that an implementation-defined message be displayed and nothing abortive happens for warning severity. The observed output is that warning, which is the specified action, so no compiler error is evident."
+  },
+  {
+   "run": "run-v2-20261113/batch-12",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The error directive with at(compilation) and severity(warning) is a utility directive; the spec only requires an implementation-defined message to be displayed and compilation aborts only for fatal. The observed output is exactly a warning with a successful compile, which is the specified error action, so no failure occurred. Nothing restricts the directive inside a target region.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-08",
+     "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": "run-v2-20261113/batch-83",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The error directive with at(compilation) and severity(warning) must display an implementation-defined message at compile time; compilation continues for a warning. The observed output is exactly such a warning, so the compiler did what the specification requires. No restriction forbids the directive in a target region. No refusal occurred.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-25",
+     "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
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "a6505cb66ed3e3210a0014eba0decf3f40be152d7f18ee783ed422ee42a56803",
+ "instructions": "v2",
+ "verdict": "contested",
+ "why": "An independent adjudicating reading finds the result not required: Both readings hold. The error directive with at(compilation) and severity(warning) displays an implementation-defined message; only fatal aborts compilation. The observed output is a warning, which is the specified action, and nothing restricts the directive inside a target region (it is pure when at is compilation). The observed result is permitted.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113/batch-01",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The error directive with at(compilation) is pure, so it is allowed in the target region. With severity(warning) the implementation takes no action besides displaying the message, so compilation must continue. The observed output is a warning, and the failure kind is a refusal; a conforming compiler must accept and compile. Reading B's no fails because a refusal contradicts the warning semantics; Reading A's doubt is only about the evidence, not the spec."
+  },
+  {
+   "run": "adj-20261113/batch-07",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The error directive is a pure utility directive when at(compilation). With severity(warning) the action only displays an implementation-defined message and is not abortive. The observed output is exactly that warning; no refusal or wrong result is shown, so there is no required-result failure. Reading B is right; Reading A is right that legality holds."
+  },
+  {
+   "run": "adj-v2-20261113b/batch-06",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Both readings hold. The error directive with at(compilation) and severity(warning) displays an implementation-defined message; only fatal aborts compilation. The observed output is a warning, which is the specified action, and nothing restricts the directive inside a target region (it is pure when at is compilation). The observed result is permitted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-14",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113b/batch-09",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Both readings hold. The error directive with severity(warning) only displays a message and takes no further action, so the observed warning is the specified behaviour. Nothing in the text bars a pure at(compilation) utility directive inside a target region, and the output shows no refusal, so no compiler error against a requirement is shown.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-01",
+     "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
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/afar-c-lastprivate-distribute-parallel-for-small-type.json

@@ -0,0 +1,113 @@
+{
+ "finding": "afar-c-lastprivate-distribute-parallel-for-small-type.c",
+ "readers": [
+  {
+   "run": "run-20261112/batch-13",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "lastprivate(lp) applies to the distribute and parallel-for leaves; the map(tofrom: lp) goes to target, so lp is mapped and the final value reaches the original item on the device and then the host. The value of the sequentially last iteration (i=64, 192) is assigned. No race: each iteration writes its own private copy. Expected lp=192 is required; 0 or garbage is a compiler error."
+  },
+  {
+   "run": "run-20261112/batch-25",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "lastprivate on the combined target teams distribute parallel for applies to the leaves that allow it (distribute, for); lp is also mapped tofrom on target. Each iteration writes only its private copy, and only the sequentially last iteration assigns to the original, so no race. The value 192 must reach lp and be mapped back. Result 0 or garbage for 4-byte items is a compiler defect. Slight uncertainty on nested lastprivate leaf semantics."
+  },
+  {
+   "run": "run-v2-20261113/batch-114",
+   "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": "lastprivate on the combined construct applies to all leaf constructs that permit it (distribute, for); lp is explicitly mapped tofrom on target, so the value of the sequentially last iteration (3*64=192) is assigned to the original list item and returned to the host. Each iteration writes its own private copy, so no race. Result lp=0 is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-21",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-22",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "lp is explicitly mapped tofrom on the target leaf, so the implicit lastprivate map does not apply. lastprivate applies to the leaf constructs that permit it (distribute and for), with shared on teams and parallel. The value from the sequentially last iteration (i=64, lp=192) is assigned to the original item, which the map brings back to the host. Each iteration writes its own private copy, so there is no race. Printing 0 is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-23",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "e48c4556201e842b33d7385e9aa609f521bf452f9cf87f67d78aac9d8c358eca",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}