MS0V3 mlir-stage-04-v1 passing 824/1000

MLIR passage 4: Graph bodies exclude calls and nested callables

Test report

1000generated samples

100.0%input coverage

100.0%output coverage

+0lines added

+1branches added

Not estimatedconfidence

824/824checker passes

Code coverage details

Baseline tests: Every tracked test file with a RUN line invoking loom-raise-opt (77 files); other executables and native unit tests excluded

Source file	Baseline coverage	Baseline + input	Contributing input
`…/lib/Dataflow/IR/DataflowGraphValidation.cpp`MS0V	1033/1540lines67.1% 571/1056branches54.1%	1033/1540lines67.1%+0 572/1056branches54.2%+1	+1 branchseed 6 · 52 → 30 linesOpen PBT Review PR
1 newly covered branch 740 `return argument && argument.getOwner() == &graph.getBody().front() &&`741 `argument.getArgNumber() != 0 &&`742 `graph.getInputPortKind(argument.getArgNumber() - 1) ==`false branch743 `dataflow::GraphPortKind::Stream;`744 `}`745

Files without added coverage

`…/loom/include/Common/Artifact.h`MS0V	13/37lines35.1% 3/18branches16.7%	13/37lines35.1%+0 3/18branches16.7%+0	Open PBT
`…/include/Frontend/Lowering/StreamLoopAttrs.h`MS0V	31/41lines75.6% 10/14branches71.4%	31/41lines75.6%+0 10/14branches71.4%+0	Open PBT
`…/loom/lib/Common/DiagnosticVerbosity.cpp`MS0V	12/41lines29.3% 1/28branches3.6%	12/41lines29.3%+0 1/28branches3.6%+0	Open PBT
`…/loom/lib/Common/IndexWidth.cpp`MS0V	63/84lines75.0% 28/42branches66.7%	63/84lines75.0%+0 28/42branches66.7%+0	Open PBT
`…/loom/lib/Common/InvocationDiagnosticLog.cpp`MS0V	6/100lines6.0% 1/70branches1.4%	6/100lines6.0%+0 1/70branches1.4%+0	Open PBT
`…/lib/Dataflow/IR/DataflowActorSemantics.cpp`MS0V	1089/1621lines67.2% 747/1330branches56.2%	1089/1621lines67.2%+0 747/1330branches56.2%+0	Open PBT
`…/lib/Dataflow/IR/DataflowChannelOps.cpp`MS0V	59/88lines67.0% 13/38branches34.2%	59/88lines67.0%+0 13/38branches34.2%+0	Open PBT
`…/lib/Dataflow/IR/DataflowDialect.cpp`MS0V	22/32lines68.8% 4/10branches40.0%	22/32lines68.8%+0 4/10branches40.0%+0	Open PBT
`…/lib/Dataflow/IR/DataflowFunctionLikeOps.cpp`MS0V	693/1097lines63.2% 264/592branches44.6%	693/1097lines63.2%+0 264/592branches44.6%+0	Open PBT
`…/lib/Dataflow/IR/DataflowGraphCausality.cpp`MS0V	169/189lines89.4% 79/98branches80.6%	169/189lines89.4%+0 79/98branches80.6%+0	Open PBT
`…/lib/Dataflow/IR/DataflowMemoryContracts.cpp`MS0V	198/371lines53.4% 98/218branches45.0%	198/371lines53.4%+0 98/218branches45.0%+0	Open PBT
`…/lib/Dataflow/IR/DataflowOps.cpp`MS0V	270/410lines65.9% 103/228branches45.2%	270/410lines65.9%+0 103/228branches45.2%+0	Open PBT
`…/lib/Dataflow/IR/DataflowProgramValidation.cpp`MS0V	367/502lines73.1% 156/276branches56.5%	367/502lines73.1%+0 156/276branches56.5%+0	Open PBT
`…/lib/Dataflow/IR/DataflowThreadCompletion.cpp`MS0V	288/361lines79.8% 148/218branches67.9%	288/361lines79.8%+0 148/218branches67.9%+0	Open PBT
`…/lib/Dataflow/IR/DataflowVectorSemantics.cpp`MS0V	81/121lines66.9% 53/106branches50.0%	81/121lines66.9%+0 53/106branches50.0%+0	Open PBT
`…/lib/Dataflow/IR/OperationSchema.cpp`MS0V	274/716lines38.3% 127/350branches36.3%	274/716lines38.3%+0 127/350branches36.3%+0	Open PBT
`…/lib/Dataflow/IR/OperationSchemaCodecInternal.h`MS0V	28/120lines23.3% 4/44branches9.1%	28/120lines23.3%+0 4/44branches9.1%+0	Open PBT
`…/lib/Dataflow/IR/OperationSchemaTypeCodec.cpp`MS0V	85/516lines16.5% 55/374branches14.7%	85/516lines16.5%+0 55/374branches14.7%+0	Open PBT
`…/lib/Dataflow/Transforms/DataflowRewritePass.cpp`MS0V	338/559lines60.5% 172/340branches50.6%	338/559lines60.5%+0 172/340branches50.6%+0	Open PBT
`…/lib/Frontend/IR/LoomDialect.cpp`MS0V	6/6lines100.0% branchesnot measured	6/6lines100.0%+0 branchesnot measured	Open PBT
`…/lib/Frontend/IR/LoomOps.cpp`MS0V	120/184lines65.2% 71/112branches63.4%	120/184lines65.2%+0 71/112branches63.4%+0	Open PBT
`…/lib/Frontend/Lowering/ExactMemRefLayout.cpp`MS0V	61/143lines42.7% 26/80branches32.5%	61/143lines42.7%+0 26/80branches32.5%+0	Open PBT
`…/lib/Frontend/Lowering/ExpandGraphMemrefCopyPass.cpp`MS0V	79/90lines87.8% 20/22branches90.9%	79/90lines87.8%+0 20/22branches90.9%+0	Open PBT
`…/lib/Frontend/Lowering/GraphIndexLowering.cpp`MS0V	260/288lines90.3% 129/168branches76.8%	260/288lines90.3%+0 129/168branches76.8%+0	Open PBT
`…/lib/Frontend/Lowering/GraphParallelLowering.cpp`MS0V	651/1243lines52.4% 284/786branches36.1%	651/1243lines52.4%+0 284/786branches36.1%+0	Open PBT
`…/lib/Frontend/Lowering/GraphRegionAdmission.cpp`MS0V	58/110lines52.7% 29/92branches31.5%	58/110lines52.7%+0 29/92branches31.5%+0	Open PBT
`…/lib/Frontend/Lowering/GraphRegionLowering.cpp`MS0V	1416/1626lines87.1% 532/680branches78.2%	1416/1626lines87.1%+0 532/680branches78.2%+0	Open PBT
`…/lib/Frontend/Lowering/GraphStreamBoundaryLowering.cpp`MS0V	934/1072lines87.1% 299/432branches69.2%	934/1072lines87.1%+0 299/432branches69.2%+0	Open PBT
`…/lib/Frontend/Lowering/GraphStreamBoundaryLowering.h`MS0V	4/4lines100.0% 4/4branches100.0%	4/4lines100.0%+0 4/4branches100.0%+0	Open PBT
`…/lib/Frontend/Lowering/LowerForToGraphPass.cpp`MS0V	1033/1240lines83.3% 374/540branches69.3%	1033/1240lines83.3%+0 374/540branches69.3%+0	Open PBT
`…/lib/Frontend/Lowering/LowerForallToThreadPass.cpp`MS0V	30/34lines88.2% 2/4branches50.0%	30/34lines88.2%+0 2/4branches50.0%+0	Open PBT
`…/lib/Frontend/Lowering/LowerGraphConstantsPass.cpp`MS0V	80/83lines96.4% 18/24branches75.0%	80/83lines96.4%+0 18/24branches75.0%+0	Open PBT
`…/lib/Frontend/Lowering/LowerGraphMemoryPass.cpp`MS0V	525/841lines62.4% 208/400branches52.0%	525/841lines62.4%+0 208/400branches52.0%+0	Open PBT
`…/lib/Frontend/Lowering/Pipeline.cpp`MS0V	18/21lines85.7% branchesnot measured	18/21lines85.7%+0 branchesnot measured	Open PBT
`…/lib/Frontend/Lowering/RankedMemRefLowering.cpp`MS0V	60/133lines45.1% 27/94branches28.7%	60/133lines45.1%+0 27/94branches28.7%+0	Open PBT
`…/lib/Frontend/Raising/DeduplicateSCFWhileStatePass.cpp`MS0V	13/135lines9.6% 0/60branches0.0%	13/135lines9.6%+0 0/60branches0.0%+0	Open PBT
`…/lib/Frontend/Raising/LLVMArithToArithPass.cpp`MS0V	300/319lines94.0% 94/116branches81.0%	300/319lines94.0%+0 94/116branches81.0%+0	Open PBT
`…/lib/Frontend/Raising/LLVMCfToCfPass.cpp`MS0V	77/80lines96.2% 8/8branches100.0%	77/80lines96.2%+0 8/8branches100.0%+0	Open PBT
`…/lib/Frontend/Raising/LiftCFToSCFPass.cpp`MS0V	616/694lines88.8% 293/386branches75.9%	616/694lines88.8%+0 293/386branches75.9%+0	Open PBT
`…/lib/Frontend/Raising/MaterializeFMulAddPass.cpp`MS0V	70/106lines66.0% 11/26branches42.3%	70/106lines66.0%+0 11/26branches42.3%+0	Open PBT
`…/lib/Frontend/Raising/NormalizeLiftedSCFExitPass.cpp`MS0V	232/250lines92.8% 120/182branches65.9%	232/250lines92.8%+0 120/182branches65.9%+0	Open PBT
`…/lib/Frontend/Raising/Pipeline.cpp`MS0V	10/19lines52.6% branchesnot measured	10/19lines52.6%+0 branchesnot measured	Open PBT
`…/lib/Frontend/Raising/SCFForToForallPass.cpp`MS0V	494/738lines66.9% 241/458branches52.6%	494/738lines66.9%+0 241/458branches52.6%+0	Open PBT
`…/lib/Frontend/Raising/SCFWhileToForPass.cpp`MS0V	164/176lines93.2% 70/94branches74.5%	164/176lines93.2%+0 70/94branches74.5%+0	Open PBT
`…/loom/tools/loom-raise-opt/loom-raise-opt.cpp`MS0V	12/12lines100.0% branchesnot measured	12/12lines100.0%+0 branchesnot measured	Open PBT

Contributing inputReduction budget

Review PR: Regression test from seed 6

Source passages for this PBT

dataflow.graph is the SpatialCore leaf DFG definition (Symbol-bearing, module-scope, function-like). Its body cannot contain callable definitions, llvm.call, func.call, dataflow.thread.launch, dataflow.graph.launch, or another dataflow.graph definition.

docs/spec-compiler-part-3-dfg.md lines 483–487

Minimized conforming example

30lines−22lines removed

Review regression test PR

Minimized passing input

module {
func.func @helper_double(%a: i32) -> i32 {
  %d = arith.addi %a, %a : i32
  return %d : i32
}


func.func @host_container(%target: memref<4xi32>, %value: i32) {
  return
}

dataflow.thread private @thread_0 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
    %r0 = "loom.spatial_region"(%val, %flag)
        <{operandSegmentSizes = array<i32: 2, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32, %c: i1):
        %sel = scf.if %c -> (i32) {
          %t = arith.addi %a, %a : i32
          scf.yield %t : i32
        } else {
          %e = arith.muli %a, %a : i32
          scf.yield %e : i32
        }
        "loom.spatial_yield"(%sel)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_0", source_maps = []} : (i32, i1) -> i32
  dataflow.thread.yield
}

}

Conditions

input conditions — what generated inputs satisfy

Conforming input

module {
func.func @helper_double(%a: i32) -> i32 {
  %d = arith.addi %a, %a : i32
  return %d : i32
}

llvm.func @extern_scale(i32) -> i32

func.func @host_container(%target: memref<4xi32>, %value: i32) {
  %hz = arith.constant 0 : index
  %hn = arith.constant 4 : index
  %hs = arith.constant 1 : index
  scf.for %hi = %hz to %hn step %hs {
    memref.store %value, %target[%hi] : memref<4xi32>
  }
  return
}

dataflow.thread private @thread_0 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
  %lo = arith.constant 0 : index
  %hi = arith.constant 2 : index
  %stp = arith.constant 1 : index
  %icall = func.call @helper_double(%val) : (i32) -> i32
    %r0 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %stable = llvm.freeze %a : i32
        "loom.spatial_yield"(%stable)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_0", source_maps = []} : (i32) -> i32
    %r1 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %z = arith.constant 0 : index
        %n = arith.constant 2 : index
        %o = arith.constant 1 : index
        %acc = scf.for %i = %z to %n step %o iter_args(%carry = %a) -> (i32) {
          %next = arith.addi %carry, %a : i32
          scf.yield %next : i32
        }
        "loom.spatial_yield"(%acc)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_1", source_maps = []} : (i32) -> i32
  dataflow.thread.yield
}

dataflow.thread private @thread_1 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
  %lo = arith.constant 0 : index
  %hi = arith.constant 2 : index
  %stp = arith.constant 1 : index
  %icall = func.call @helper_double(%val) : (i32) -> i32
    %r2 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %z = arith.constant 0 : index
        %n = arith.constant 2 : index
        %o = arith.constant 1 : index
        %acc = scf.for %i = %z to %n step %o iter_args(%carry = %a) -> (i32) {
          %next = arith.addi %carry, %a : i32
          scf.yield %next : i32
        }
        "loom.spatial_yield"(%acc)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_2", source_maps = []} : (i32) -> i32
  dataflow.thread.yield
}

}

2 linked-input-36 · linked input 36

One binding denotes one ordered dynamic event sequence. A fixed structured scope may contain multiple sequential or structured mutually exclusive sites.

docs/spec-compiler-part-3-dfg.md lines 578–582

3 linked-input-55 · linked input 55

Branches may have unequal or empty site sets, and a later branch selector may depend on an earlier input event. Enclosing loops repeatedly activate the same schedule, so one or several static body sites may each fire dynamically.

docs/spec-compiler-part-3-dfg.md lines 591–598

4 linked-input-90 · linked input 90

Current publication supports nested scf.if completion propagation.

docs/spec-compiler-part-3-dfg.md lines 573–574

5 linked-input-140 · linked input 140

An llvm.call or func.call inside a dataflow.thread definition's body is an InstructionCore call. If the callee contains code that must become a dataflow.graph definition, Part 3 must inline or specialize that callee into the active thread definition before graph extraction.

docs/spec-compiler-part-3-dfg.md lines 499–506

6 linked-input-150 · linked input 150

loom.spatial_region is the temporary publication boundary inside an existing dataflow.thread. Its operands are normalized as value inputs, stream input channels, memory inputs, and stream output channels; its results are value outputs followed by memory outputs.

docs/spec-compiler-part-3-dfg.md lines 564–569

7 linked-input-162 · linked input 162

Part 3 consumes each explicit loom.spatial_region inside its owning dataflow.thread and publishes the corresponding graph definition and launch only after complete conversion and native finalization succeed.

docs/spec-compiler-part-3-dfg.md lines 23–26

8 linked-input-179 · linked input 179

loom.spatial_region is temporary compiler IR inside a dataflow.thread. It owns one structured graph candidate with normalized value, stream-channel, and memory boundary segments.

docs/spec-compiler-part-3-dfg.md lines 462–465

9 linked-input-180 · linked input 180

Endpoint sites nested under scf.parallel or scf.forall have no inferred traversal order and fail before publication. Unselected or non-fixed graph-owned parallel forms also fail closed.

docs/spec-compiler-part-3-dfg.md lines 598–601

10 linked-input-204 · linked input 204

loom.spatial_region is a transparent structured boundary. A blocking receive inside that region cannot be justified by a send that follows the region in the same stored-program strand merely because the published graph launch becomes asynchronous.

docs/spec-compiler-part-3-dfg.md lines 1413–1419

Generator grammar · candidate.pg

// Inputs for --loom-lower-for-to-graph: modules whose dataflow.thread
// definitions own explicit loom.spatial_region publication boundaries.

start: {new NTHREADS = random.randint(1, 2); new TID = 0; new GID = 0}
       'module {\n'
       helper_callables
       host_container
       threads
       '}\n';

helper_callables:
    'func.func @helper_double(%a: i32) -> i32 {\n'
    '  %d = arith.addi %a, %a : i32\n'
    '  return %d : i32\n'
    '}\n\n'
    'llvm.func @extern_scale(i32) -> i32\n\n';

host_container:
    'func.func @host_container(%target: memref<4xi32>, %value: i32) {\n'
    '  %hz = arith.constant 0 : index\n'
    '  %hn = arith.constant 4 : index\n'
    '  %hs = arith.constant 1 : index\n'
    '  scf.for %hi = %hz to %hn step %hs {\n'
    '    memref.store %value, %target[%hi] : memref<4xi32>\n'
    '  }\n'
    '  return\n'
    '}\n\n';

threads: (TID < NTHREADS) thread_def {TID += 1} threads
       | (TID == NTHREADS) '';

thread_def:
    'dataflow.thread private @thread_' [str(TID)]
    ' domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {\n'
    '  %lo = arith.constant 0 : index\n'
    '  %hi = arith.constant 2 : index\n'
    '  %stp = arith.constant 1 : index\n'
    {new NSITES = random.randint(1, 2); new SID = 0; new ICALL = random.choice([0, 1])}
    instruction_core_call
    sites
    '  dataflow.thread.yield\n'
    '}\n\n';

// A non-inlined InstructionCore call whose callee body is graph-free may
// remain in the thread body next to the publication boundary.
instruction_core_call:
      (ICALL == 0) ''
    | (ICALL == 1) '  %icall = func.call @helper_double(%val) : (i32) -> i32\n';

sites: (SID < NSITES) site {SID += 1} sites
     | (SID == NSITES) '';

site: {new NEST = random.choice([0, 0, 1, 2])} nested_site;

nested_site:
      (NEST == 0) region_site
    | (NEST == 1) '  scf.if %flag {\n' region_site '  }\n'
    | (NEST == 2) '  scf.for %iv = %lo to %hi step %stp {\n' region_site '  }\n';

// The selected-into-candidate call forms make the whole publication
// transaction fail closed, so they are sampled at a lower rate than the
// publishable forms.
region_site: {new FORM = random.choice([0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4])} region_form {GID += 1};

region_form:
      (FORM == 0) region_value
    | (FORM == 1) region_memory
    | (FORM == 2) region_branch
    | (FORM == 3) region_freeze
    | (FORM == 4) region_loop
    | (FORM == 5) region_call;

// Value-in / value-out candidate: pure arithmetic actors.
region_value:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32):\n'
    '        %s = arith.addi %a, %a : i32\n'
    '        %p = arith.muli %s, %a : i32\n'
    '        "loom.spatial_yield"(%p)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32) -> i32\n';

// Value input plus memory input, storing into the imported memref.
region_memory:
    '    "loom.spatial_region"(%val, %mem)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 1, 0>,\n'
    '          resultSegmentSizes = array<i32: 0, 0>}> ({\n'
    '      ^bb0(%payload: i32, %memory: memref<4xi32>):\n'
    '        %z = arith.constant 0 : index\n'
    '        memref.store %payload, %memory[%z] : memref<4xi32>\n'
    '        "loom.spatial_yield"()\n'
    '            <{operandSegmentSizes = array<i32: 0, 0>}> : () -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32, memref<4xi32>) -> ()\n';

// Structured mutually exclusive sites inside one candidate.
region_branch:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val, %flag)\n'
    '        <{operandSegmentSizes = array<i32: 2, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32, %c: i1):\n'
    '        %sel = scf.if %c -> (i32) {\n'
    '          %t = arith.addi %a, %a : i32\n'
    '          scf.yield %t : i32\n'
    '        } else {\n'
    '          %e = arith.muli %a, %a : i32\n'
    '          scf.yield %e : i32\n'
    '        }\n'
    '        "loom.spatial_yield"(%sel)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32, i1) -> i32\n';

region_freeze:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32):\n'
    '        %stable = llvm.freeze %a : i32\n'
    '        "loom.spatial_yield"(%stable)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32) -> i32\n';

// Enclosing loop inside the candidate repeatedly activates the same schedule.
region_loop:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32):\n'
    '        %z = arith.constant 0 : index\n'
    '        %n = arith.constant 2 : index\n'
    '        %o = arith.constant 1 : index\n'
    '        %acc = scf.for %i = %z to %n step %o iter_args(%carry = %a) -> (i32) {\n'
    '          %next = arith.addi %carry, %a : i32\n'
    '          scf.yield %next : i32\n'
    '        }\n'
    '        "loom.spatial_yield"(%acc)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32) -> i32\n';

// Adversarial candidate: an InstructionCore call selected into the candidate.
region_call: {new CALLEE = random.choice([0, 1])} region_call_body;

region_call_body:
      (CALLEE == 0) region_func_call
    | (CALLEE == 1) region_llvm_call;

region_func_call:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32):\n'
    '        %called = func.call @helper_double(%a) : (i32) -> i32\n'
    '        "loom.spatial_yield"(%called)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32) -> i32\n';

region_llvm_call:
    '    %r' [str(GID)] ' = "loom.spatial_region"(%val)\n'
    '        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n'
    '          resultSegmentSizes = array<i32: 1, 0>}> ({\n'
    '      ^bb0(%a: i32):\n'
    '        %called = llvm.call @extern_scale(%a) : (i32) -> i32\n'
    '        "loom.spatial_yield"(%called)\n'
    '            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n'
    '    }) {graph_name = "graph_' [str(GID)] '", source_maps = []} : (i32) -> i32\n';

output condition — what every compiled pair must satisfy

dataflow_graph_body_is_leaf · 6 assertion sites

derived from 1 passage: 1selected-output

dataflow.graph is the SpatialCore leaf DFG definition (Symbol-bearing, module-scope, function-like). Its body cannot contain callable definitions, llvm.call, func.call, dataflow.thread.launch, dataflow.graph.launch, or another dataflow.graph definition.

Executable output condition · candidate.spct

postcondition dataflow_graph_body_is_leaf {
  language v0;
  vocabulary mlir = mlir.generic@1;

  metadata {
    project = "PolyArch/loom";
    revision = "48615bc5925ef4b9db8b4550b5d4322933cf4b7b";
    source = "docs/spec-compiler-part-3-dfg.md:L483-L487";
  }

  constraints {
    let graphs = seq { op | op in output.operations where op.name == "dataflow.graph" };

    forall g in graphs {
      assert no_callable_definition_in_body:
        none op in mlir::descendants(g)
        where op.name == "func.func"
           or op.name == "llvm.func"
           or op.name == "dataflow.thread"
           or op.name == "dataflow.graph";

      assert no_llvm_call_in_body:
        none op in mlir::descendants(g) where op.name == "llvm.call";

      assert no_func_call_in_body:
        none op in mlir::descendants(g) where op.name == "func.call";

      assert no_thread_launch_in_body:
        none op in mlir::descendants(g) where op.name == "dataflow.thread.launch";

      assert no_graph_launch_in_body:
        none op in mlir::descendants(g) where op.name == "dataflow.graph.launch";

      assert no_nested_graph_definition_in_body:
        none op in mlir::descendants(g) where op.name == "dataflow.graph";
    }
  }
}

Minimized passing input

module {
func.func @helper_double(%a: i32) -> i32 {
  %d = arith.addi %a, %a : i32
  return %d : i32
}


func.func @host_container(%target: memref<4xi32>, %value: i32) {
  return
}

dataflow.thread private @thread_0 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
    %r0 = "loom.spatial_region"(%val, %flag)
        <{operandSegmentSizes = array<i32: 2, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32, %c: i1):
        %sel = scf.if %c -> (i32) {
          %t = arith.addi %a, %a : i32
          scf.yield %t : i32
        } else {
          %e = arith.muli %a, %a : i32
          scf.yield %e : i32
        }
        "loom.spatial_yield"(%sel)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_0", source_maps = []} : (i32, i1) -> i32
  dataflow.thread.yield
}

}

Evidence

runs: 20260911-035521 · 20260911-042218

run20260911-042218started2026-09-11T04:22:18Zsubjectloom-raise-optsubject revision48615bc5925e

run results

1000saved inputs

824accepted

176rejected

output condition verdicts

824pass

Additional trace diagnostics

raw trace evidence

824accepted trace samples

57distinct trace classes

9classes seen once

sample pair · seed 0

generated input

module {
func.func @helper_double(%a: i32) -> i32 {
  %d = arith.addi %a, %a : i32
  return %d : i32
}

llvm.func @extern_scale(i32) -> i32

func.func @host_container(%target: memref<4xi32>, %value: i32) {
  %hz = arith.constant 0 : index
  %hn = arith.constant 4 : index
  %hs = arith.constant 1 : index
  scf.for %hi = %hz to %hn step %hs {
    memref.store %value, %target[%hi] : memref<4xi32>
  }
  return
}

dataflow.thread private @thread_0 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
  %lo = arith.constant 0 : index
  %hi = arith.constant 2 : index
  %stp = arith.constant 1 : index
  %icall = func.call @helper_double(%val) : (i32) -> i32
    %r0 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %stable = llvm.freeze %a : i32
        "loom.spatial_yield"(%stable)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_0", source_maps = []} : (i32) -> i32
    %r1 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %z = arith.constant 0 : index
        %n = arith.constant 2 : index
        %o = arith.constant 1 : index
        %acc = scf.for %i = %z to %n step %o iter_args(%carry = %a) -> (i32) {
          %next = arith.addi %carry, %a : i32
          scf.yield %next : i32
        }
        "loom.spatial_yield"(%acc)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_1", source_maps = []} : (i32) -> i32
  dataflow.thread.yield
}

dataflow.thread private @thread_1 domain(#dataflow.thread_domain<dense>)(%mem: memref<4xi32>, %val: i32, %flag: i1) ctrl (%start: none) {
  %lo = arith.constant 0 : index
  %hi = arith.constant 2 : index
  %stp = arith.constant 1 : index
  %icall = func.call @helper_double(%val) : (i32) -> i32
    %r2 = "loom.spatial_region"(%val)
        <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,
          resultSegmentSizes = array<i32: 1, 0>}> ({
      ^bb0(%a: i32):
        %z = arith.constant 0 : index
        %n = arith.constant 2 : index
        %o = arith.constant 1 : index
        %acc = scf.for %i = %z to %n step %o iter_args(%carry = %a) -> (i32) {
          %next = arith.addi %carry, %a : i32
          scf.yield %next : i32
        }
        "loom.spatial_yield"(%acc)
            <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()
    }) {graph_name = "graph_2", source_maps = []} : (i32) -> i32
  dataflow.thread.yield
}

}

observed generic output

"builtin.module"() ({
  "func.func"() <{function_type = (i32) -> i32, sym_name = "helper_double"}> ({
  ^bb0(%arg17: i32):
    %56 = "arith.addi"(%arg17, %arg17) <{overflowFlags = #arith.overflow<none>}> : (i32, i32) -> i32
    "func.return"(%56) : (i32) -> ()
  }) : () -> ()
  "llvm.func"() <{CConv = #llvm.cconv<ccc>, function_type = !llvm.func<i32 (i32)>, linkage = #llvm.linkage<external>, sym_name = "extern_scale", unnamed_addr = 0 : i64, visibility_ = 0 : i64}> ({
  }) : () -> ()
  "func.func"() <{function_type = (memref<4xi32>, i32) -> (), sym_name = "host_container"}> ({
  ^bb0(%arg14: memref<4xi32>, %arg15: i32):
    %53 = "arith.constant"() <{value = 0 : index}> : () -> index
    %54 = "arith.constant"() <{value = 4 : index}> : () -> index
    %55 = "arith.constant"() <{value = 1 : index}> : () -> index
    "scf.for"(%53, %54, %55) ({
    ^bb0(%arg16: index):
      "memref.store"(%arg15, %arg14, %arg16) : (i32, memref<4xi32>, index) -> ()
      "scf.yield"() : () -> ()
    }) : (index, index, index) -> ()
    "func.return"() : () -> ()
  }) : () -> ()
  "dataflow.thread"() <{domain = #dataflow.thread_domain<dense>, function_type = (memref<4xi32>, i32, i1) -> (), sym_name = "thread_0", sym_visibility = "private"}> ({
  ^bb0(%arg10: memref<4xi32>, %arg11: i32, %arg12: i1, %arg13: none):
    %47 = "arith.constant"() <{value = 0 : index}> : () -> index
    %48 = "arith.constant"() <{value = 2 : index}> : () -> index
    %49 = "arith.constant"() <{value = 1 : index}> : () -> index
    %50 = "func.call"(%arg11) <{callee = @helper_double}> : (i32) -> i32
    %51:2 = "dataflow.graph.launch"(%arg13, %arg11) <{callee = @graph_0, operandSegmentSizes = array<i32: 1, 1, 0, 0, 0>, resultSegmentSizes = array<i32: 1, 0, 1>, source_maps = []}> : (none, i32) -> (i32, none)
    %52:2 = "dataflow.graph.launch"(%arg13, %arg11) <{callee = @graph_1, operandSegmentSizes = array<i32: 1, 1, 0, 0, 0>, resultSegmentSizes = array<i32: 1, 0, 1>, source_maps = []}> : (none, i32) -> (i32, none)
    "dataflow.thread.yield"(%51#1, %52#1) : (none, none) -> ()
  }) : () -> ()
  "dataflow.thread"() <{domain = #dataflow.thread_domain<dense>, function_type = (memref<4xi32>, i32, i1) -> (), sym_name = "thread_1", sym_visibility = "private"}> ({
  ^bb0(%arg6: memref<4xi32>, %arg7: i32, %arg8: i1, %arg9: none):
    %42 = "arith.constant"() <{value = 0 : index}> : () -> index
    %43 = "arith.constant"() <{value = 2 : index}> : () -> index
    %44 = "arith.constant"() <{value = 1 : index}> : () -> index
    %45 = "func.call"(%arg7) <{callee = @helper_double}> : (i32) -> i32
    %46:2 = "dataflow.graph.launch"(%arg9, %arg7) <{callee = @graph_2, operandSegmentSizes = array<i32: 1, 1, 0, 0, 0>, resultSegmentSizes = array<i32: 1, 0, 1>, source_maps = []}> : (none, i32) -> (i32, none)
    "dataflow.thread.yield"(%46#1) : (none) -> ()
  }) : () -> ()
  "dataflow.graph"() <{function_type = (i32) -> i32, input_segments = array<i32: 1, 0, 0>, result_segments = array<i32: 1, 0, 0>, sym_name = "graph_0", sym_visibility = "private"}> ({
  ^bb0(%arg4: none, %arg5: i32):
    %40 = "llvm.freeze"(%arg5) : (i32) -> i32
    %41:2 = "dataflow.sync"(%arg4, %40) : (none, i32) -> (none, i32)
    "dataflow.graph.return"(%41#1, %41#0) <{operandSegmentSizes = array<i32: 1, 0, 0, 1>}> : (i32, none) -> ()
  }) : () -> ()
  "dataflow.graph"() <{function_type = (i32) -> i32, input_segments = array<i32: 1, 0, 0>, result_segments = array<i32: 1, 0, 0>, sym_name = "graph_1", sym_visibility = "private"}> ({
  ^bb0(%arg2: none, %arg3: i32):
    %20 = "dataflow.constant"(%arg2) <{const_value = 0 : index}> : (none) -> index
    %21 = "dataflow.constant"(%arg2) <{const_value = 2 : index}> : (none) -> index
    %22 = "dataflow.constant"(%arg2) <{const_value = 1 : index}> : (none) -> index
    %23 = "arith.index_cast"(%20) : (index) -> i32
    %24 = "arith.index_cast"(%21) : (index) -> i32
    %25 = "arith.index_cast"(%22) : (index) -> i32
    %26:2 = "dataflow.stream"(%23, %24, %25) <{predicate = 2 : i64, step_kind = 0 : i32}> : (i32, i32, i32) -> (i32, i1)
    %27 = "dataflow.carry"(%26#1, %arg2, %28#1) : (i1, none, none) -> none
    %28:2 = "dataflow.demux"(%26#1, %27) : (i1, none) -> (none, none)
    %29 = "dataflow.carry"(%26#1, %arg3, %34) : (i1, i32, i32) -> i32
    %30:2 = "dataflow.demux"(%26#1, %29) : (i1, i32) -> (i32, i32)
    %31 = "dataflow.invariant"(%26#1, %arg3) : (i1, i32) -> i32
    %32:2 = "dataflow.gate"(%26#1, %31) : (i1, i32) -> (i1, i32)
    %33:2 = "dataflow.demux"(%32#0, %32#1) : (i1, i32) -> (i32, i32)
    %34 = "arith.addi"(%30#1, %32#1) <{overflowFlags = #arith.overflow<none>}> : (i32, i32) -> i32
    %35 = "arith.cmpi"(%23, %24) <{predicate = 2 : i64}> : (i32, i32) -> i1
    %36:2 = "dataflow.demux"(%35, %28#0) : (i1, none) -> (none, none)
    %37:2 = "dataflow.sync"(%36#1, %33#0) : (none, i32) -> (none, i32)
    %38 = "dataflow.mux"(%35, %36#0, %37#0) : (i1, none, none) -> none
    %39:2 = "dataflow.sync"(%38, %30#0) : (none, i32) -> (none, i32)
    "dataflow.graph.return"(%39#1, %39#0) <{operandSegmentSizes = array<i32: 1, 0, 0, 1>}> : (i32, none) -> ()
  }) : () -> ()
  "dataflow.graph"() <{function_type = (i32) -> i32, input_segments = array<i32: 1, 0, 0>, result_segments = array<i32: 1, 0, 0>, sym_name = "graph_2", sym_visibility = "private"}> ({
  ^bb0(%arg0: none, %arg1: i32):
    %0 = "dataflow.constant"(%arg0) <{const_value = 0 : index}> : (none) -> index
    %1 = "dataflow.constant"(%arg0) <{const_value = 2 : index}> : (none) -> index
    %2 = "dataflow.constant"(%arg0) <{const_value = 1 : index}> : (none) -> index
    %3 = "arith.index_cast"(%0) : (index) -> i32
    %4 = "arith.index_cast"(%1) : (index) -> i32
    %5 = "arith.index_cast"(%2) : (index) -> i32
    %6:2 = "dataflow.stream"(%3, %4, %5) <{predicate = 2 : i64, step_kind = 0 : i32}> : (i32, i32, i32) -> (i32, i1)
    %7 = "dataflow.carry"(%6#1, %arg0, %8#1) : (i1, none, none) -> none
    %8:2 = "dataflow.demux"(%6#1, %7) : (i1, none) -> (none, none)
    %9 = "dataflow.carry"(%6#1, %arg1, %14) : (i1, i32, i32) -> i32
    %10:2 = "dataflow.demux"(%6#1, %9) : (i1, i32) -> (i32, i32)
    %11 = "dataflow.invariant"(%6#1, %arg1) : (i1, i32) -> i32
    %12:2 = "dataflow.gate"(%6#1, %11) : (i1, i32) -> (i1, i32)
    %13:2 = "dataflow.demux"(%12#0, %12#1) : (i1, i32) -> (i32, i32)
    %14 = "arith.addi"(%10#1, %12#1) <{overflowFlags = #arith.overflow<none>}> : (i32, i32) -> i32
    %15 = "arith.cmpi"(%3, %4) <{predicate = 2 : i64}> : (i32, i32) -> i1
    %16:2 = "dataflow.demux"(%15, %8#0) : (i1, none) -> (none, none)
    %17:2 = "dataflow.sync"(%16#1, %13#0) : (none, i32) -> (none, i32)
    %18 = "dataflow.mux"(%15, %16#0, %17#0) : (i1, none, none) -> none
    %19:2 = "dataflow.sync"(%18, %10#0) : (none, i32) -> (none, i32)
    "dataflow.graph.return"(%19#1, %19#0) <{operandSegmentSizes = array<i32: 1, 0, 0, 1>}> : (i32, none) -> ()
  }) : () -> ()
}) : () -> ()

per-seed evidence (1000 seeds)

seed	subject	verdict	artifacts
`0`	accepted exit 0 · 0.5899739850010519s	PASS	input · generic input · output · check report
`1`	accepted exit 0 · 0.601540728001055s	PASS	input · generic input · output · check report
`2`	rejected exit 1 · 0.6066123969994806s	—	input · stderr <stdin>:42:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:42:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`3`	accepted exit 0 · 0.5841227219989378s	PASS	input · generic input · output · check report
`4`	rejected exit 1 · 0.5968763299988495s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`5`	accepted exit 0 · 0.5573773909982265s	PASS	input · generic input · output · check report
`6`	accepted exit 0 · 0.5624887049998506s	PASS	input · generic input · output · check report
`7`	accepted exit 0 · 0.5548640050001268s	PASS	input · generic input · output · check report
`8`	accepted exit 0 · 0.5793740129993239s	PASS	input · generic input · output · check report
`9`	accepted exit 0 · 0.5722868440007005s	PASS	input · generic input · output · check report
`10`	accepted exit 0 · 0.5690739620004024s	PASS	input · generic input · output · check report
`11`	accepted exit 0 · 0.5758440400004474s	PASS	input · generic input · output · check report
`12`	accepted exit 0 · 0.56154043099923s	PASS	input · generic input · output · check report
`13`	accepted exit 0 · 0.5740357720005704s	PASS	input · generic input · output · check report
`14`	rejected exit 1 · 0.6148396050011797s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`15`	accepted exit 0 · 0.5715718999999808s	PASS	input · generic input · output · check report
`16`	accepted exit 0 · 0.5779800670006807s	PASS	input · generic input · output · check report
`17`	rejected exit 1 · 0.5866107990004821s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`18`	accepted exit 0 · 0.5791621719999966s	PASS	input · generic input · output · check report
`19`	accepted exit 0 · 0.5927143019998766s	PASS	input · generic input · output · check report
`20`	accepted exit 0 · 0.5662156970010983s	PASS	input · generic input · output · check report
`21`	accepted exit 0 · 0.5527153010007169s	PASS	input · generic input · output · check report
`22`	accepted exit 0 · 0.5538952720016823s	PASS	input · generic input · output · check report
`23`	rejected exit 1 · 0.5953210860006948s	—	input · stderr <stdin>:38:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:38:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`24`	accepted exit 0 · 0.5353841500000271s	PASS	input · generic input · output · check report
`25`	accepted exit 0 · 0.5579392349991394s	PASS	input · generic input · output · check report
`26`	accepted exit 0 · 0.5711367379990406s	PASS	input · generic input · output · check report
`27`	accepted exit 0 · 0.595208871000068s	PASS	input · generic input · output · check report
`28`	accepted exit 0 · 0.5677212440004951s	PASS	input · generic input · output · check report
`29`	accepted exit 0 · 0.5589960710003652s	PASS	input · generic input · output · check report
`30`	accepted exit 0 · 0.6269643899995572s	PASS	input · generic input · output · check report
`31`	accepted exit 0 · 0.6108091149999382s	PASS	input · generic input · output · check report
`32`	accepted exit 0 · 0.5891200679998292s	PASS	input · generic input · output · check report
`33`	accepted exit 0 · 0.5582863500003441s	PASS	input · generic input · output · check report
`34`	accepted exit 0 · 0.609262748999754s	PASS	input · generic input · output · check report
`35`	accepted exit 0 · 0.5620226340015506s	PASS	input · generic input · output · check report
`36`	accepted exit 0 · 0.5574933930001862s	PASS	input · generic input · output · check report
`37`	accepted exit 0 · 0.5673464470000908s	PASS	input · generic input · output · check report
`38`	accepted exit 0 · 0.6005478520000906s	PASS	input · generic input · output · check report
`39`	rejected exit 1 · 0.6143170309987909s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`40`	accepted exit 0 · 0.5830285880001611s	PASS	input · generic input · output · check report
`41`	accepted exit 0 · 0.5682951010003308s	PASS	input · generic input · output · check report
`42`	accepted exit 0 · 0.5633777189996181s	PASS	input · generic input · output · check report
`43`	accepted exit 0 · 0.6048904850013059s	PASS	input · generic input · output · check report
`44`	accepted exit 0 · 0.5660198429995944s	PASS	input · generic input · output · check report
`45`	rejected exit 1 · 0.5940891519985598s	—	input · stderr <stdin>:51:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:51:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`46`	accepted exit 0 · 0.5482255110000551s	PASS	input · generic input · output · check report
`47`	rejected exit 1 · 0.6003490190014418s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`48`	accepted exit 0 · 0.5762718260011752s	PASS	input · generic input · output · check report
`49`	rejected exit 1 · 0.6053146390004258s	—	input · stderr <stdin>:53:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:53:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`50`	rejected exit 1 · 0.581901306999498s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`51`	accepted exit 0 · 0.5828486299997166s	PASS	input · generic input · output · check report
`52`	accepted exit 0 · 0.5547514760000922s	PASS	input · generic input · output · check report
`53`	rejected exit 1 · 0.599734689001707s	—	input · stderr <stdin>:38:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:38:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`54`	accepted exit 0 · 0.5443249310010287s	PASS	input · generic input · output · check report
`55`	accepted exit 0 · 0.6224938069990458s	PASS	input · generic input · output · check report
`56`	accepted exit 0 · 0.610177891998319s	PASS	input · generic input · output · check report
`57`	accepted exit 0 · 0.5781724190001114s	PASS	input · generic input · output · check report
`58`	accepted exit 0 · 0.5761777309999161s	PASS	input · generic input · output · check report
`59`	accepted exit 0 · 0.5829232530013542s	PASS	input · generic input · output · check report
`60`	accepted exit 0 · 0.6390718610000476s	PASS	input · generic input · output · check report
`61`	accepted exit 0 · 0.6278091109998059s	PASS	input · generic input · output · check report
`62`	rejected exit 1 · 0.6252150340005755s	—	input · stderr <stdin>:36:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:36:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`63`	accepted exit 0 · 0.5504825490006624s	PASS	input · generic input · output · check report
`64`	accepted exit 0 · 0.5808965229989553s	PASS	input · generic input · output · check report
`65`	accepted exit 0 · 0.5668527249999897s	PASS	input · generic input · output · check report
`66`	rejected exit 1 · 0.6203620320011396s	—	input · stderr <stdin>:46:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:46:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`67`	accepted exit 0 · 0.6158511970006657s	PASS	input · generic input · output · check report
`68`	accepted exit 0 · 0.5688579790003132s	PASS	input · generic input · output · check report
`69`	accepted exit 0 · 0.6191096910006308s	PASS	input · generic input · output · check report
`70`	accepted exit 0 · 0.572753554000883s	PASS	input · generic input · output · check report
`71`	accepted exit 0 · 0.5715384839986655s	PASS	input · generic input · output · check report
`72`	accepted exit 0 · 0.5683467340004427s	PASS	input · generic input · output · check report
`73`	accepted exit 0 · 0.5953375400004006s	PASS	input · generic input · output · check report
`74`	accepted exit 0 · 0.5764500019995467s	PASS	input · generic input · output · check report
`75`	accepted exit 0 · 0.6384493759996985s	PASS	input · generic input · output · check report
`76`	accepted exit 0 · 0.6048315269999875s	PASS	input · generic input · output · check report
`77`	accepted exit 0 · 0.5703960490009194s	PASS	input · generic input · output · check report
`78`	accepted exit 0 · 0.5708330010002101s	PASS	input · generic input · output · check report
`79`	rejected exit 1 · 0.6138680120002391s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`80`	rejected exit 1 · 0.5838184039985208s	—	input · stderr <stdin>:41:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:41:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`81`	accepted exit 0 · 0.570699608000723s	PASS	input · generic input · output · check report
`82`	accepted exit 0 · 0.5734160730007716s	PASS	input · generic input · output · check report
`83`	accepted exit 0 · 0.5892503810009657s	PASS	input · generic input · output · check report
`84`	accepted exit 0 · 0.5849732259994198s	PASS	input · generic input · output · check report
`85`	accepted exit 0 · 0.5671586869993916s	PASS	input · generic input · output · check report
`86`	accepted exit 0 · 0.5612003959995491s	PASS	input · generic input · output · check report
`87`	accepted exit 0 · 0.5661833890007983s	PASS	input · generic input · output · check report
`88`	accepted exit 0 · 0.5703914729983808s	PASS	input · generic input · output · check report
`89`	accepted exit 0 · 0.5658025209995685s	PASS	input · generic input · output · check report
`90`	accepted exit 0 · 0.5907791849986097s	PASS	input · generic input · output · check report
`91`	accepted exit 0 · 0.5854404000001523s	PASS	input · generic input · output · check report
`92`	accepted exit 0 · 0.550869638000222s	PASS	input · generic input · output · check report
`93`	accepted exit 0 · 0.6095671029997902s	PASS	input · generic input · output · check report
`94`	rejected exit 1 · 0.6000253040001553s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`95`	accepted exit 0 · 0.5980153180007619s	PASS	input · generic input · output · check report
`96`	accepted exit 0 · 0.5753045909987122s	PASS	input · generic input · output · check report
`97`	accepted exit 0 · 0.5695004389999667s	PASS	input · generic input · output · check report
`98`	accepted exit 0 · 0.60206892899987s	PASS	input · generic input · output · check report
`99`	accepted exit 0 · 0.5650175459995808s	PASS	input · generic input · output · check report
`100`	accepted exit 0 · 0.38578805499992086s	PASS	input · generic input · output · check report
`101`	accepted exit 0 · 0.5126358039999559s	PASS	input · generic input · output · check report
`102`	accepted exit 0 · 0.5279205919998731s	PASS	input · generic input · output · check report
`103`	accepted exit 0 · 0.4021868329998597s	PASS	input · generic input · output · check report
`104`	accepted exit 0 · 0.4002432370000406s	PASS	input · generic input · output · check report
`105`	accepted exit 0 · 0.4490204270000504s	PASS	input · generic input · output · check report
`106`	accepted exit 0 · 0.39270641400003115s	PASS	input · generic input · output · check report
`107`	accepted exit 0 · 0.37408277300005466s	PASS	input · generic input · output · check report
`108`	accepted exit 0 · 0.34450504500000534s	PASS	input · generic input · output · check report
`109`	accepted exit 0 · 0.33923521600013373s	PASS	input · generic input · output · check report
`110`	rejected exit 1 · 0.41065316399999574s	—	input · stderr <stdin>:66:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:66:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`111`	accepted exit 0 · 0.3649593499999355s	PASS	input · generic input · output · check report
`112`	accepted exit 0 · 0.4071921869999642s	PASS	input · generic input · output · check report
`113`	accepted exit 0 · 0.37648004100014987s	PASS	input · generic input · output · check report
`114`	accepted exit 0 · 0.3816878380000617s	PASS	input · generic input · output · check report
`115`	accepted exit 0 · 0.3717866659999345s	PASS	input · generic input · output · check report
`116`	rejected exit 1 · 0.40264807100015787s	—	input · stderr <stdin>:42:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:42:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`117`	accepted exit 0 · 0.41622222900014094s	PASS	input · generic input · output · check report
`118`	accepted exit 0 · 0.3852393919999031s	PASS	input · generic input · output · check report
`119`	accepted exit 0 · 0.5499557059999916s	PASS	input · generic input · output · check report
`120`	accepted exit 0 · 0.3895531989999199s	PASS	input · generic input · output · check report
`121`	accepted exit 0 · 0.4029534999999669s	PASS	input · generic input · output · check report
`122`	accepted exit 0 · 0.37915613799987113s	PASS	input · generic input · output · check report
`123`	accepted exit 0 · 0.41574662499988335s	PASS	input · generic input · output · check report
`124`	accepted exit 0 · 0.4137487160001001s	PASS	input · generic input · output · check report
`125`	accepted exit 0 · 0.37264784800004236s	PASS	input · generic input · output · check report
`126`	accepted exit 0 · 0.3863340679999965s	PASS	input · generic input · output · check report
`127`	rejected exit 1 · 0.425618907000171s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`128`	rejected exit 1 · 0.3847547459999987s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`129`	accepted exit 0 · 0.4349473190000026s	PASS	input · generic input · output · check report
`130`	accepted exit 0 · 0.4444624139998723s	PASS	input · generic input · output · check report
`131`	accepted exit 0 · 0.43656675200008976s	PASS	input · generic input · output · check report
`132`	rejected exit 1 · 0.433940148000147s	—	input · stderr <stdin>:43:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:43:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`133`	rejected exit 1 · 0.4206400460000168s	—	input · stderr <stdin>:45:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:45:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`134`	accepted exit 0 · 0.3891462239998873s	PASS	input · generic input · output · check report
`135`	accepted exit 0 · 0.36558340900000985s	PASS	input · generic input · output · check report
`136`	accepted exit 0 · 0.3597125689998393s	PASS	input · generic input · output · check report
`137`	rejected exit 1 · 0.4341486119999445s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`138`	accepted exit 0 · 0.34969992699984687s	PASS	input · generic input · output · check report
`139`	accepted exit 0 · 0.41980850400000236s	PASS	input · generic input · output · check report
`140`	accepted exit 0 · 0.4721228999999312s	PASS	input · generic input · output · check report
`141`	accepted exit 0 · 0.4241377159999047s	PASS	input · generic input · output · check report
`142`	rejected exit 1 · 0.4771025439999903s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`143`	accepted exit 0 · 0.3766496759999427s	PASS	input · generic input · output · check report
`144`	accepted exit 0 · 0.4605265950001467s	PASS	input · generic input · output · check report
`145`	accepted exit 0 · 0.4200098789999629s	PASS	input · generic input · output · check report
`146`	rejected exit 1 · 0.4893720600000506s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`147`	rejected exit 1 · 0.4543125739999141s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`148`	accepted exit 0 · 0.45776192700009233s	PASS	input · generic input · output · check report
`149`	rejected exit 1 · 0.43573042799994255s	—	input · stderr <stdin>:52:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:52:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`150`	accepted exit 0 · 0.41881702299997414s	PASS	input · generic input · output · check report
`151`	accepted exit 0 · 0.4762414740000622s	PASS	input · generic input · output · check report
`152`	accepted exit 0 · 0.42058029200006786s	PASS	input · generic input · output · check report
`153`	accepted exit 0 · 0.4808282189999318s	PASS	input · generic input · output · check report
`154`	accepted exit 0 · 0.414804790000062s	PASS	input · generic input · output · check report
`155`	accepted exit 0 · 0.40276257800019266s	PASS	input · generic input · output · check report
`156`	accepted exit 0 · 0.40804189000004953s	PASS	input · generic input · output · check report
`157`	accepted exit 0 · 0.40729058700003407s	PASS	input · generic input · output · check report
`158`	accepted exit 0 · 0.37517396899988853s	PASS	input · generic input · output · check report
`159`	accepted exit 0 · 0.402240928999845s	PASS	input · generic input · output · check report
`160`	accepted exit 0 · 0.40400243399994906s	PASS	input · generic input · output · check report
`161`	accepted exit 0 · 0.4128519509999933s	PASS	input · generic input · output · check report
`162`	accepted exit 0 · 0.38006583899982616s	PASS	input · generic input · output · check report
`163`	rejected exit 1 · 0.4478601339999386s	—	input · stderr <stdin>:45:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:45:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`164`	accepted exit 0 · 0.39254748400003336s	PASS	input · generic input · output · check report
`165`	accepted exit 0 · 0.4134820080000736s	PASS	input · generic input · output · check report
`166`	accepted exit 0 · 0.4003001060000315s	PASS	input · generic input · output · check report
`167`	accepted exit 0 · 0.3664196339998398s	PASS	input · generic input · output · check report
`168`	rejected exit 1 · 0.41609361199994055s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`169`	accepted exit 0 · 0.3977324930001487s	PASS	input · generic input · output · check report
`170`	accepted exit 0 · 0.36930735199985065s	PASS	input · generic input · output · check report
`171`	accepted exit 0 · 0.39454474900003333s	PASS	input · generic input · output · check report
`172`	accepted exit 0 · 0.4292568799999117s	PASS	input · generic input · output · check report
`173`	rejected exit 1 · 0.4462793509999301s	—	input · stderr <stdin>:52:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:52:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`174`	accepted exit 0 · 0.3915322109999124s	PASS	input · generic input · output · check report
`175`	accepted exit 0 · 0.4028064460001133s	PASS	input · generic input · output · check report
`176`	rejected exit 1 · 0.44674803899988547s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`177`	rejected exit 1 · 0.4522256830000515s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`178`	accepted exit 0 · 0.3863796129999173s	PASS	input · generic input · output · check report
`179`	accepted exit 0 · 0.423130429999901s	PASS	input · generic input · output · check report
`180`	accepted exit 0 · 0.3455748029998631s	PASS	input · generic input · output · check report
`181`	accepted exit 0 · 0.3683793359998617s	PASS	input · generic input · output · check report
`182`	accepted exit 0 · 0.3357149290000052s	PASS	input · generic input · output · check report
`183`	accepted exit 0 · 0.337703466999983s	PASS	input · generic input · output · check report
`184`	accepted exit 0 · 0.32318012800010365s	PASS	input · generic input · output · check report
`185`	accepted exit 0 · 0.33494923600005677s	PASS	input · generic input · output · check report
`186`	accepted exit 0 · 0.35409154800004217s	PASS	input · generic input · output · check report
`187`	rejected exit 1 · 0.40445885400004045s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`188`	accepted exit 0 · 0.3443938849998176s	PASS	input · generic input · output · check report
`189`	accepted exit 0 · 0.3711315809998723s	PASS	input · generic input · output · check report
`190`	accepted exit 0 · 0.381580650999922s	PASS	input · generic input · output · check report
`191`	accepted exit 0 · 0.38127091100000143s	PASS	input · generic input · output · check report
`192`	accepted exit 0 · 0.3440850469999077s	PASS	input · generic input · output · check report
`193`	accepted exit 0 · 0.4129001190001418s	PASS	input · generic input · output · check report
`194`	accepted exit 0 · 0.37539143799995145s	PASS	input · generic input · output · check report
`195`	accepted exit 0 · 0.42871194899998954s	PASS	input · generic input · output · check report
`196`	accepted exit 0 · 0.3494605030000457s	PASS	input · generic input · output · check report
`197`	accepted exit 0 · 0.35217316500006746s	PASS	input · generic input · output · check report
`198`	accepted exit 0 · 0.3764811609999015s	PASS	input · generic input · output · check report
`199`	rejected exit 1 · 0.384602416000007s	—	input · stderr <stdin>:45:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:45:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`200`	accepted exit 0 · 0.3650378030001775s	PASS	input · generic input · output · check report
`201`	accepted exit 0 · 0.3175267399999484s	PASS	input · generic input · output · check report
`202`	accepted exit 0 · 0.34312151599988283s	PASS	input · generic input · output · check report
`203`	accepted exit 0 · 0.4054756969999289s	PASS	input · generic input · output · check report
`204`	rejected exit 1 · 0.36635797799999636s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`205`	accepted exit 0 · 0.4027904030001537s	PASS	input · generic input · output · check report
`206`	accepted exit 0 · 0.3700115100000403s	PASS	input · generic input · output · check report
`207`	accepted exit 0 · 0.3631543240001065s	PASS	input · generic input · output · check report
`208`	accepted exit 0 · 0.37940909400003875s	PASS	input · generic input · output · check report
`209`	accepted exit 0 · 0.4038150010001118s	PASS	input · generic input · output · check report
`210`	accepted exit 0 · 0.41309958600004393s	PASS	input · generic input · output · check report
`211`	accepted exit 0 · 0.4294928950000667s	PASS	input · generic input · output · check report
`212`	accepted exit 0 · 0.42523680599992986s	PASS	input · generic input · output · check report
`213`	accepted exit 0 · 0.4353501419998338s	PASS	input · generic input · output · check report
`214`	accepted exit 0 · 0.45015970899999047s	PASS	input · generic input · output · check report
`215`	accepted exit 0 · 0.40944449799985705s	PASS	input · generic input · output · check report
`216`	accepted exit 0 · 0.42428793899989614s	PASS	input · generic input · output · check report
`217`	accepted exit 0 · 0.4064360750001015s	PASS	input · generic input · output · check report
`218`	accepted exit 0 · 0.4025905710000188s	PASS	input · generic input · output · check report
`219`	rejected exit 1 · 0.4469414239999878s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`220`	accepted exit 0 · 0.4395582029999332s	PASS	input · generic input · output · check report
`221`	accepted exit 0 · 0.3913180269998975s	PASS	input · generic input · output · check report
`222`	accepted exit 0 · 0.4171816549999221s	PASS	input · generic input · output · check report
`223`	rejected exit 1 · 0.4432504680000875s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`224`	rejected exit 1 · 0.4702178669999739s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`225`	accepted exit 0 · 0.41190524500007086s	PASS	input · generic input · output · check report
`226`	rejected exit 1 · 0.38696969600005104s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`227`	accepted exit 0 · 0.35213035699985085s	PASS	input · generic input · output · check report
`228`	accepted exit 0 · 0.4132139590001316s	PASS	input · generic input · output · check report
`229`	accepted exit 0 · 0.36326812699985567s	PASS	input · generic input · output · check report
`230`	accepted exit 0 · 0.3676488009998593s	PASS	input · generic input · output · check report
`231`	accepted exit 0 · 0.3870060780000131s	PASS	input · generic input · output · check report
`232`	accepted exit 0 · 0.385842693000086s	PASS	input · generic input · output · check report
`233`	accepted exit 0 · 0.3921546930000659s	PASS	input · generic input · output · check report
`234`	accepted exit 0 · 0.36386809800001174s	PASS	input · generic input · output · check report
`235`	accepted exit 0 · 0.41537610099999256s	PASS	input · generic input · output · check report
`236`	rejected exit 1 · 0.4384571580001193s	—	input · stderr <stdin>:62:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:62:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`237`	accepted exit 0 · 0.41283320000002277s	PASS	input · generic input · output · check report
`238`	accepted exit 0 · 0.4026654140000119s	PASS	input · generic input · output · check report
`239`	accepted exit 0 · 0.3993045639999764s	PASS	input · generic input · output · check report
`240`	accepted exit 0 · 0.42290084000001116s	PASS	input · generic input · output · check report
`241`	accepted exit 0 · 0.424122867000051s	PASS	input · generic input · output · check report
`242`	accepted exit 0 · 0.4186927509999805s	PASS	input · generic input · output · check report
`243`	accepted exit 0 · 0.4485791279998921s	PASS	input · generic input · output · check report
`244`	rejected exit 1 · 0.44230189799986874s	—	input · stderr <stdin>:43:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:43:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`245`	accepted exit 0 · 0.35172088099989196s	PASS	input · generic input · output · check report
`246`	accepted exit 0 · 0.38468878899993797s	PASS	input · generic input · output · check report
`247`	accepted exit 0 · 0.38921919400013394s	PASS	input · generic input · output · check report
`248`	accepted exit 0 · 0.404989138000019s	PASS	input · generic input · output · check report
`249`	rejected exit 1 · 0.43402240699992944s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`250`	accepted exit 0 · 0.3744863340000393s	PASS	input · generic input · output · check report
`251`	accepted exit 0 · 0.4377969980000671s	PASS	input · generic input · output · check report
`252`	accepted exit 0 · 0.43562305199975526s	PASS	input · generic input · output · check report
`253`	rejected exit 1 · 0.4567899070002568s	—	input · stderr <stdin>:58:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:58:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`254`	accepted exit 0 · 0.4500405479998335s	PASS	input · generic input · output · check report
`255`	accepted exit 0 · 0.3837444380001216s	PASS	input · generic input · output · check report
`256`	accepted exit 0 · 0.42685274899986325s	PASS	input · generic input · output · check report
`257`	accepted exit 0 · 0.4430748589998075s	PASS	input · generic input · output · check report
`258`	accepted exit 0 · 0.4092163749996871s	PASS	input · generic input · output · check report
`259`	accepted exit 0 · 0.41000808200033134s	PASS	input · generic input · output · check report
`260`	accepted exit 0 · 0.4055121269998381s	PASS	input · generic input · output · check report
`261`	accepted exit 0 · 0.43247133700015183s	PASS	input · generic input · output · check report
`262`	rejected exit 1 · 0.46180687300011414s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`263`	rejected exit 1 · 0.48658998299970335s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`264`	accepted exit 0 · 0.43074650400012615s	PASS	input · generic input · output · check report
`265`	accepted exit 0 · 0.42868663099989135s	PASS	input · generic input · output · check report
`266`	accepted exit 0 · 0.4462525169997207s	PASS	input · generic input · output · check report
`267`	rejected exit 1 · 0.5606491029998324s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`268`	accepted exit 0 · 0.4965574979996745s	PASS	input · generic input · output · check report
`269`	rejected exit 1 · 0.539143526999851s	—	input · stderr <stdin>:38:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:38:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`270`	rejected exit 1 · 0.5459633820000818s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`271`	rejected exit 1 · 0.4768107059999238s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`272`	accepted exit 0 · 0.5387380050001411s	PASS	input · generic input · output · check report
`273`	rejected exit 1 · 0.55844821699975s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`274`	accepted exit 0 · 0.4614936959997067s	PASS	input · generic input · output · check report
`275`	accepted exit 0 · 0.4745770790000279s	PASS	input · generic input · output · check report
`276`	rejected exit 1 · 0.4630680099999154s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`277`	accepted exit 0 · 0.4871700150001743s	PASS	input · generic input · output · check report
`278`	accepted exit 0 · 0.47454553600027793s	PASS	input · generic input · output · check report
`279`	accepted exit 0 · 0.4679290710000714s	PASS	input · generic input · output · check report
`280`	accepted exit 0 · 0.44468167700006234s	PASS	input · generic input · output · check report
`281`	accepted exit 0 · 0.43436050399986925s	PASS	input · generic input · output · check report
`282`	accepted exit 0 · 0.3787364780000644s	PASS	input · generic input · output · check report
`283`	accepted exit 0 · 0.4426507709999896s	PASS	input · generic input · output · check report
`284`	rejected exit 1 · 0.5115160380000816s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`285`	accepted exit 0 · 0.3837726299998394s	PASS	input · generic input · output · check report
`286`	accepted exit 0 · 0.43688493299987385s	PASS	input · generic input · output · check report
`287`	accepted exit 0 · 0.4192616000000271s	PASS	input · generic input · output · check report
`288`	rejected exit 1 · 0.47020108200013055s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`289`	accepted exit 0 · 0.42629189000035694s	PASS	input · generic input · output · check report
`290`	rejected exit 1 · 0.4950267879999046s	—	input · stderr <stdin>:80:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:80:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`291`	accepted exit 0 · 0.40545623100024386s	PASS	input · generic input · output · check report
`292`	accepted exit 0 · 0.4082956649999687s	PASS	input · generic input · output · check report
`293`	accepted exit 0 · 0.35514090100014073s	PASS	input · generic input · output · check report
`294`	rejected exit 1 · 0.4080289759999687s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`295`	accepted exit 0 · 0.3604843640000581s	PASS	input · generic input · output · check report
`296`	accepted exit 0 · 0.36348845000020447s	PASS	input · generic input · output · check report
`297`	accepted exit 0 · 0.39442603699990286s	PASS	input · generic input · output · check report
`298`	accepted exit 0 · 0.3601931980001609s	PASS	input · generic input · output · check report
`299`	accepted exit 0 · 0.43079700199996296s	PASS	input · generic input · output · check report
`300`	accepted exit 0 · 0.380751539999892s	PASS	input · generic input · output · check report
`301`	accepted exit 0 · 0.30793528200001674s	PASS	input · generic input · output · check report
`302`	accepted exit 0 · 0.3097441569998409s	PASS	input · generic input · output · check report
`303`	accepted exit 0 · 0.3574538200000461s	PASS	input · generic input · output · check report
`304`	accepted exit 0 · 0.36160954400020273s	PASS	input · generic input · output · check report
`305`	accepted exit 0 · 0.3914695839998785s	PASS	input · generic input · output · check report
`306`	accepted exit 0 · 0.36429329400016286s	PASS	input · generic input · output · check report
`307`	accepted exit 0 · 0.3584889859998839s	PASS	input · generic input · output · check report
`308`	rejected exit 1 · 0.43134047500007s	—	input · stderr <stdin>:66:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:66:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`309`	accepted exit 0 · 0.42643965400020534s	PASS	input · generic input · output · check report
`310`	accepted exit 0 · 0.3629340479997154s	PASS	input · generic input · output · check report
`311`	accepted exit 0 · 0.4256893189999573s	PASS	input · generic input · output · check report
`312`	accepted exit 0 · 0.46000256700017417s	PASS	input · generic input · output · check report
`313`	accepted exit 0 · 0.39042825599972275s	PASS	input · generic input · output · check report
`314`	accepted exit 0 · 0.36561914799995066s	PASS	input · generic input · output · check report
`315`	rejected exit 1 · 0.5131048279999959s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`316`	accepted exit 0 · 0.3437834199999088s	PASS	input · generic input · output · check report
`317`	accepted exit 0 · 0.41970633399978396s	PASS	input · generic input · output · check report
`318`	accepted exit 0 · 0.43559783399996377s	PASS	input · generic input · output · check report
`319`	accepted exit 0 · 0.3766035210001064s	PASS	input · generic input · output · check report
`320`	accepted exit 0 · 0.39133347899996807s	PASS	input · generic input · output · check report
`321`	accepted exit 0 · 0.37718934099984835s	PASS	input · generic input · output · check report
`322`	rejected exit 1 · 0.4424865409996528s	—	input · stderr <stdin>:59:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:59:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`323`	accepted exit 0 · 0.4175680889998148s	PASS	input · generic input · output · check report
`324`	accepted exit 0 · 0.43909283099992535s	PASS	input · generic input · output · check report
`325`	accepted exit 0 · 0.4071427120002227s	PASS	input · generic input · output · check report
`326`	accepted exit 0 · 0.3987865869999041s	PASS	input · generic input · output · check report
`327`	accepted exit 0 · 0.4494206659996962s	PASS	input · generic input · output · check report
`328`	accepted exit 0 · 0.5595752459998948s	PASS	input · generic input · output · check report
`329`	accepted exit 0 · 0.4192003250000198s	PASS	input · generic input · output · check report
`330`	accepted exit 0 · 0.415645843999755s	PASS	input · generic input · output · check report
`331`	accepted exit 0 · 0.48966020599982585s	PASS	input · generic input · output · check report
`332`	accepted exit 0 · 0.4069242559999111s	PASS	input · generic input · output · check report
`333`	accepted exit 0 · 0.3808619430001272s	PASS	input · generic input · output · check report
`334`	accepted exit 0 · 0.44005624700002954s	PASS	input · generic input · output · check report
`335`	rejected exit 1 · 0.44516239000040514s	—	input · stderr <stdin>:47:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:47:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`336`	accepted exit 0 · 0.4131568210000296s	PASS	input · generic input · output · check report
`337`	accepted exit 0 · 0.4231430099998761s	PASS	input · generic input · output · check report
`338`	rejected exit 1 · 0.4485808689996702s	—	input · stderr <stdin>:52:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:52:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`339`	accepted exit 0 · 0.42335333899973193s	PASS	input · generic input · output · check report
`340`	accepted exit 0 · 0.387294342000132s	PASS	input · generic input · output · check report
`341`	accepted exit 0 · 0.4408942330001082s	PASS	input · generic input · output · check report
`342`	accepted exit 0 · 0.36316934700016645s	PASS	input · generic input · output · check report
`343`	accepted exit 0 · 0.39769086700016487s	PASS	input · generic input · output · check report
`344`	rejected exit 1 · 0.40515276699989045s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`345`	rejected exit 1 · 0.42931434599995555s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`346`	accepted exit 0 · 0.4232741780001561s	PASS	input · generic input · output · check report
`347`	rejected exit 1 · 0.40541298300013295s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`348`	accepted exit 0 · 0.40643648800005394s	PASS	input · generic input · output · check report
`349`	accepted exit 0 · 0.48127221799995823s	PASS	input · generic input · output · check report
`350`	rejected exit 1 · 0.4307347609997123s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`351`	rejected exit 1 · 0.4789481580000938s	—	input · stderr <stdin>:68:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:68:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`352`	accepted exit 0 · 0.412868767999953s	PASS	input · generic input · output · check report
`353`	accepted exit 0 · 0.4644693619998179s	PASS	input · generic input · output · check report
`354`	accepted exit 0 · 0.4380620110000564s	PASS	input · generic input · output · check report
`355`	accepted exit 0 · 0.3911153409999315s	PASS	input · generic input · output · check report
`356`	rejected exit 1 · 0.41014223299998775s	—	input · stderr <stdin>:65:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:65:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`357`	rejected exit 1 · 0.4764144989999295s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`358`	accepted exit 0 · 0.39978189699968425s	PASS	input · generic input · output · check report
`359`	rejected exit 1 · 0.4436250559997461s	—	input · stderr <stdin>:45:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:45:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`360`	accepted exit 0 · 0.3848344520001774s	PASS	input · generic input · output · check report
`361`	accepted exit 0 · 0.34157777600012196s	PASS	input · generic input · output · check report
`362`	accepted exit 0 · 0.35365855300005933s	PASS	input · generic input · output · check report
`363`	rejected exit 1 · 0.4056585600001199s	—	input · stderr <stdin>:39:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:39:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`364`	accepted exit 0 · 0.3368697490000159s	PASS	input · generic input · output · check report
`365`	accepted exit 0 · 0.3969099449996065s	PASS	input · generic input · output · check report
`366`	accepted exit 0 · 0.39941218399962963s	PASS	input · generic input · output · check report
`367`	accepted exit 0 · 0.34866611500001454s	PASS	input · generic input · output · check report
`368`	accepted exit 0 · 0.4217441390001113s	PASS	input · generic input · output · check report
`369`	accepted exit 0 · 0.4171837140002026s	PASS	input · generic input · output · check report
`370`	rejected exit 1 · 0.4635388899996542s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`371`	accepted exit 0 · 0.41146531200001846s	PASS	input · generic input · output · check report
`372`	accepted exit 0 · 0.421885170999758s	PASS	input · generic input · output · check report
`373`	accepted exit 0 · 0.41823328800001036s	PASS	input · generic input · output · check report
`374`	accepted exit 0 · 0.4058388969997395s	PASS	input · generic input · output · check report
`375`	accepted exit 0 · 0.4828143260001525s	PASS	input · generic input · output · check report
`376`	accepted exit 0 · 0.4925131979998696s	PASS	input · generic input · output · check report
`377`	accepted exit 0 · 0.5028588650002348s	PASS	input · generic input · output · check report
`378`	accepted exit 0 · 0.4497989179999422s	PASS	input · generic input · output · check report
`379`	rejected exit 1 · 0.4704856530001962s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`380`	accepted exit 0 · 0.5280057360000683s	PASS	input · generic input · output · check report
`381`	accepted exit 0 · 0.5700504999999794s	PASS	input · generic input · output · check report
`382`	accepted exit 0 · 0.3834453569998004s	PASS	input · generic input · output · check report
`383`	rejected exit 1 · 0.44793892000006963s	—	input · stderr <stdin>:39:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:39:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`384`	accepted exit 0 · 0.3984485940000013s	PASS	input · generic input · output · check report
`385`	accepted exit 0 · 0.41994305500020346s	PASS	input · generic input · output · check report
`386`	accepted exit 0 · 0.40527420899979916s	PASS	input · generic input · output · check report
`387`	accepted exit 0 · 0.43846869199978755s	PASS	input · generic input · output · check report
`388`	rejected exit 1 · 0.4373995930000092s	—	input · stderr <stdin>:42:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:42:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`389`	rejected exit 1 · 0.4978699990001587s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`390`	accepted exit 0 · 0.4226756029997887s	PASS	input · generic input · output · check report
`391`	accepted exit 0 · 0.4095177109998076s	PASS	input · generic input · output · check report
`392`	rejected exit 1 · 0.4084049060002144s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`393`	accepted exit 0 · 0.4560214629996153s	PASS	input · generic input · output · check report
`394`	rejected exit 1 · 0.5637550030000966s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`395`	accepted exit 0 · 0.5867837230002806s	PASS	input · generic input · output · check report
`396`	rejected exit 1 · 0.521382191000157s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`397`	accepted exit 0 · 0.425462669999888s	PASS	input · generic input · output · check report
`398`	accepted exit 0 · 0.3942699129997891s	PASS	input · generic input · output · check report
`399`	accepted exit 0 · 0.41166244200030633s	PASS	input · generic input · output · check report
`400`	accepted exit 0 · 0.4055815389997406s	PASS	input · generic input · output · check report
`401`	accepted exit 0 · 0.5700751670001409s	PASS	input · generic input · output · check report
`402`	accepted exit 0 · 0.44352971599982993s	PASS	input · generic input · output · check report
`403`	rejected exit 1 · 0.49128322599972307s	—	input · stderr <stdin>:54:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:54:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`404`	accepted exit 0 · 0.43025822299978245s	PASS	input · generic input · output · check report
`405`	accepted exit 0 · 0.5313815139998042s	PASS	input · generic input · output · check report
`406`	accepted exit 0 · 0.5212310189999698s	PASS	input · generic input · output · check report
`407`	accepted exit 0 · 0.43846852700016825s	PASS	input · generic input · output · check report
`408`	accepted exit 0 · 0.3819729599999846s	PASS	input · generic input · output · check report
`409`	accepted exit 0 · 0.41155360500033566s	PASS	input · generic input · output · check report
`410`	accepted exit 0 · 0.3995076250002967s	PASS	input · generic input · output · check report
`411`	rejected exit 1 · 0.41508846100032315s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`412`	accepted exit 0 · 0.45506063500033633s	PASS	input · generic input · output · check report
`413`	accepted exit 0 · 0.3793872100000044s	PASS	input · generic input · output · check report
`414`	accepted exit 0 · 0.607584597999903s	PASS	input · generic input · output · check report
`415`	accepted exit 0 · 0.38629720300014014s	PASS	input · generic input · output · check report
`416`	accepted exit 0 · 0.43229450199987696s	PASS	input · generic input · output · check report
`417`	accepted exit 0 · 0.42892857000015283s	PASS	input · generic input · output · check report
`418`	accepted exit 0 · 0.5053346459999375s	PASS	input · generic input · output · check report
`419`	accepted exit 0 · 0.6508229740002207s	PASS	input · generic input · output · check report
`420`	accepted exit 0 · 0.7127621319996251s	PASS	input · generic input · output · check report
`421`	accepted exit 0 · 0.4168505319998985s	PASS	input · generic input · output · check report
`422`	accepted exit 0 · 0.49098445900017396s	PASS	input · generic input · output · check report
`423`	accepted exit 0 · 0.4118104630001653s	PASS	input · generic input · output · check report
`424`	accepted exit 0 · 0.4563901769997756s	PASS	input · generic input · output · check report
`425`	accepted exit 0 · 0.40181217100007416s	PASS	input · generic input · output · check report
`426`	accepted exit 0 · 0.4510434419999001s	PASS	input · generic input · output · check report
`427`	accepted exit 0 · 0.3883012799997232s	PASS	input · generic input · output · check report
`428`	accepted exit 0 · 0.41121930100007376s	PASS	input · generic input · output · check report
`429`	accepted exit 0 · 0.37610255200024767s	PASS	input · generic input · output · check report
`430`	accepted exit 0 · 0.42731921600034184s	PASS	input · generic input · output · check report
`431`	accepted exit 0 · 0.4634245900001588s	PASS	input · generic input · output · check report
`432`	accepted exit 0 · 0.4475191950000408s	PASS	input · generic input · output · check report
`433`	accepted exit 0 · 0.4472335899999962s	PASS	input · generic input · output · check report
`434`	accepted exit 0 · 0.4220230759997321s	PASS	input · generic input · output · check report
`435`	accepted exit 0 · 0.45503957100027037s	PASS	input · generic input · output · check report
`436`	accepted exit 0 · 0.5186723749998237s	PASS	input · generic input · output · check report
`437`	accepted exit 0 · 0.49538561499957723s	PASS	input · generic input · output · check report
`438`	accepted exit 0 · 0.48547286600023654s	PASS	input · generic input · output · check report
`439`	accepted exit 0 · 0.5195082979998915s	PASS	input · generic input · output · check report
`440`	accepted exit 0 · 0.526009742000042s	PASS	input · generic input · output · check report
`441`	rejected exit 1 · 0.5008445309999843s	—	input · stderr <stdin>:61:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:61:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`442`	accepted exit 0 · 0.5265024420000373s	PASS	input · generic input · output · check report
`443`	accepted exit 0 · 0.45548265299976265s	PASS	input · generic input · output · check report
`444`	accepted exit 0 · 0.46160958100017524s	PASS	input · generic input · output · check report
`445`	accepted exit 0 · 0.07049724099988453s	PASS	input · generic input · output · check report
`446`	accepted exit 0 · 0.0797242680000636s	PASS	input · generic input · output · check report
`447`	accepted exit 0 · 0.04847476499980985s	PASS	input · generic input · output · check report
`448`	accepted exit 0 · 0.057247667999945406s	PASS	input · generic input · output · check report
`449`	accepted exit 0 · 0.06177233900007195s	PASS	input · generic input · output · check report
`450`	accepted exit 0 · 0.05073845100014296s	PASS	input · generic input · output · check report
`451`	accepted exit 0 · 0.06678458899978068s	PASS	input · generic input · output · check report
`452`	rejected exit 1 · 0.06804787400005807s	—	input · stderr <stdin>:38:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:38:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`453`	accepted exit 0 · 0.10535676900008184s	PASS	input · generic input · output · check report
`454`	accepted exit 0 · 0.13893630999973539s	PASS	input · generic input · output · check report
`455`	accepted exit 0 · 0.06105094199983796s	PASS	input · generic input · output · check report
`456`	accepted exit 0 · 0.054432819000339805s	PASS	input · generic input · output · check report
`457`	accepted exit 0 · 0.1664603399999578s	PASS	input · generic input · output · check report
`458`	accepted exit 0 · 0.10375315600003887s	PASS	input · generic input · output · check report
`459`	accepted exit 0 · 0.051919118000114395s	PASS	input · generic input · output · check report
`460`	accepted exit 0 · 0.05638488000022335s	PASS	input · generic input · output · check report
`461`	accepted exit 0 · 0.040825605999998515s	PASS	input · generic input · output · check report
`462`	accepted exit 0 · 0.055365345000154775s	PASS	input · generic input · output · check report
`463`	rejected exit 1 · 0.14841776299999765s	—	input · stderr <stdin>:48:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:48:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`464`	accepted exit 0 · 0.0652504399999998s	PASS	input · generic input · output · check report
`465`	accepted exit 0 · 0.05339314100001502s	PASS	input · generic input · output · check report
`466`	accepted exit 0 · 0.06757250399959958s	PASS	input · generic input · output · check report
`467`	accepted exit 0 · 0.06220685300013429s	PASS	input · generic input · output · check report
`468`	accepted exit 0 · 0.07102503299984164s	PASS	input · generic input · output · check report
`469`	accepted exit 0 · 0.047727518000101554s	PASS	input · generic input · output · check report
`470`	rejected exit 1 · 0.046774637999988045s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`471`	accepted exit 0 · 0.06099614100003237s	PASS	input · generic input · output · check report
`472`	rejected exit 1 · 0.07942317500010176s	—	input · stderr <stdin>:41:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:41:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`473`	accepted exit 0 · 0.04769256400004451s	PASS	input · generic input · output · check report
`474`	accepted exit 0 · 0.04707588599967494s	PASS	input · generic input · output · check report
`475`	rejected exit 1 · 0.09333800300009898s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`476`	accepted exit 0 · 0.05053445500016096s	PASS	input · generic input · output · check report
`477`	accepted exit 0 · 0.05180123599984654s	PASS	input · generic input · output · check report
`478`	accepted exit 0 · 0.05245734900017851s	PASS	input · generic input · output · check report
`479`	accepted exit 0 · 0.04927277599972513s	PASS	input · generic input · output · check report
`480`	accepted exit 0 · 0.04708026600019366s	PASS	input · generic input · output · check report
`481`	accepted exit 0 · 0.08568241300008594s	PASS	input · generic input · output · check report
`482`	accepted exit 0 · 0.13724668699978793s	PASS	input · generic input · output · check report
`483`	accepted exit 0 · 0.11634949100016456s	PASS	input · generic input · output · check report
`484`	accepted exit 0 · 0.05472012500013079s	PASS	input · generic input · output · check report
`485`	accepted exit 0 · 0.05485833500006265s	PASS	input · generic input · output · check report
`486`	rejected exit 1 · 0.09038898200014955s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`487`	accepted exit 0 · 0.048132506999991165s	PASS	input · generic input · output · check report
`488`	accepted exit 0 · 0.04796477200034133s	PASS	input · generic input · output · check report
`489`	accepted exit 0 · 0.052323023000099056s	PASS	input · generic input · output · check report
`490`	accepted exit 0 · 0.09497338000028321s	PASS	input · generic input · output · check report
`491`	accepted exit 0 · 0.05098364800005584s	PASS	input · generic input · output · check report
`492`	rejected exit 1 · 0.1274158900000657s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`493`	accepted exit 0 · 0.09754536700029348s	PASS	input · generic input · output · check report
`494`	accepted exit 0 · 0.08112022299974342s	PASS	input · generic input · output · check report
`495`	accepted exit 0 · 0.05344566800022221s	PASS	input · generic input · output · check report
`496`	accepted exit 0 · 0.05134373900000355s	PASS	input · generic input · output · check report
`497`	accepted exit 0 · 0.06225288999985423s	PASS	input · generic input · output · check report
`498`	accepted exit 0 · 0.05436740200002532s	PASS	input · generic input · output · check report
`499`	accepted exit 0 · 0.09628385599989997s	PASS	input · generic input · output · check report
`500`	rejected exit 1 · 0.08928923099983876s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`501`	accepted exit 0 · 0.057322268999996595s	PASS	input · generic input · output · check report
`502`	accepted exit 0 · 0.059305346999735775s	PASS	input · generic input · output · check report
`503`	rejected exit 1 · 0.0692644159998963s	—	input · stderr <stdin>:48:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:48:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`504`	accepted exit 0 · 0.04722213600007308s	PASS	input · generic input · output · check report
`505`	accepted exit 0 · 0.0509532810001474s	PASS	input · generic input · output · check report
`506`	accepted exit 0 · 0.05116292499997144s	PASS	input · generic input · output · check report
`507`	accepted exit 0 · 0.15871646300001885s	PASS	input · generic input · output · check report
`508`	rejected exit 1 · 0.09161992999997892s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`509`	rejected exit 1 · 0.09191934300042703s	—	input · stderr <stdin>:56:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:56:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`510`	accepted exit 0 · 0.04828585900031612s	PASS	input · generic input · output · check report
`511`	accepted exit 0 · 0.06680645099959293s	PASS	input · generic input · output · check report
`512`	rejected exit 1 · 0.0875900979999642s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`513`	accepted exit 0 · 0.05452941599969563s	PASS	input · generic input · output · check report
`514`	accepted exit 0 · 0.05582412000012482s	PASS	input · generic input · output · check report
`515`	accepted exit 0 · 0.07148289399992791s	PASS	input · generic input · output · check report
`516`	accepted exit 0 · 0.05344606099970406s	PASS	input · generic input · output · check report
`517`	rejected exit 1 · 0.08824360099970363s	—	input · stderr <stdin>:68:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:68:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`518`	accepted exit 0 · 0.04761998999993011s	PASS	input · generic input · output · check report
`519`	accepted exit 0 · 0.07062732799977312s	PASS	input · generic input · output · check report
`520`	accepted exit 0 · 0.05467410099981862s	PASS	input · generic input · output · check report
`521`	accepted exit 0 · 0.054610974000297574s	PASS	input · generic input · output · check report
`522`	accepted exit 0 · 0.06364619799978755s	PASS	input · generic input · output · check report
`523`	accepted exit 0 · 0.06352909899987935s	PASS	input · generic input · output · check report
`524`	accepted exit 0 · 0.04911873099990771s	PASS	input · generic input · output · check report
`525`	accepted exit 0 · 0.0468320540003333s	PASS	input · generic input · output · check report
`526`	accepted exit 0 · 0.06686820799995985s	PASS	input · generic input · output · check report
`527`	rejected exit 1 · 0.0912791460000335s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`528`	accepted exit 0 · 0.06786332000001494s	PASS	input · generic input · output · check report
`529`	accepted exit 0 · 0.04942802499999743s	PASS	input · generic input · output · check report
`530`	accepted exit 0 · 0.05213639700014028s	PASS	input · generic input · output · check report
`531`	accepted exit 0 · 0.05840984999986176s	PASS	input · generic input · output · check report
`532`	accepted exit 0 · 0.05762460400001146s	PASS	input · generic input · output · check report
`533`	accepted exit 0 · 0.081800320000184s	PASS	input · generic input · output · check report
`534`	accepted exit 0 · 0.08918876899997485s	PASS	input · generic input · output · check report
`535`	accepted exit 0 · 0.08055740400004652s	PASS	input · generic input · output · check report
`536`	rejected exit 1 · 0.10698947299988504s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`537`	accepted exit 0 · 0.06220454399999653s	PASS	input · generic input · output · check report
`538`	accepted exit 0 · 0.06430374999990818s	PASS	input · generic input · output · check report
`539`	accepted exit 0 · 0.06364245799977652s	PASS	input · generic input · output · check report
`540`	accepted exit 0 · 0.0618270750001102s	PASS	input · generic input · output · check report
`541`	accepted exit 0 · 0.0853839279998283s	PASS	input · generic input · output · check report
`542`	accepted exit 0 · 0.05862708999984534s	PASS	input · generic input · output · check report
`543`	accepted exit 0 · 0.08129691600015576s	PASS	input · generic input · output · check report
`544`	accepted exit 0 · 0.06142664299977696s	PASS	input · generic input · output · check report
`545`	accepted exit 0 · 0.06062959399969259s	PASS	input · generic input · output · check report
`546`	accepted exit 0 · 0.057785046999924816s	PASS	input · generic input · output · check report
`547`	accepted exit 0 · 0.07495417399968574s	PASS	input · generic input · output · check report
`548`	rejected exit 1 · 0.10182382499988307s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`549`	accepted exit 0 · 0.061923788000058266s	PASS	input · generic input · output · check report
`550`	accepted exit 0 · 0.04647789199998442s	PASS	input · generic input · output · check report
`551`	accepted exit 0 · 0.05367016299987881s	PASS	input · generic input · output · check report
`552`	rejected exit 1 · 0.09380330799967851s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`553`	accepted exit 0 · 0.06176357699996515s	PASS	input · generic input · output · check report
`554`	accepted exit 0 · 0.05437760300037553s	PASS	input · generic input · output · check report
`555`	accepted exit 0 · 0.05122548700001062s	PASS	input · generic input · output · check report
`556`	accepted exit 0 · 0.05410152400008883s	PASS	input · generic input · output · check report
`557`	accepted exit 0 · 0.05863747100011096s	PASS	input · generic input · output · check report
`558`	accepted exit 0 · 0.11106816499977867s	PASS	input · generic input · output · check report
`559`	rejected exit 1 · 0.10692131899986634s	—	input · stderr <stdin>:43:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:43:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`560`	accepted exit 0 · 0.053108897999663895s	PASS	input · generic input · output · check report
`561`	accepted exit 0 · 0.056588017999729345s	PASS	input · generic input · output · check report
`562`	accepted exit 0 · 0.050234895999892615s	PASS	input · generic input · output · check report
`563`	accepted exit 0 · 0.061906566999823553s	PASS	input · generic input · output · check report
`564`	accepted exit 0 · 0.06035538100013582s	PASS	input · generic input · output · check report
`565`	accepted exit 0 · 0.04826927100020839s	PASS	input · generic input · output · check report
`566`	accepted exit 0 · 0.06243994999977076s	PASS	input · generic input · output · check report
`567`	accepted exit 0 · 0.0830382730000565s	PASS	input · generic input · output · check report
`568`	accepted exit 0 · 0.06161848600004305s	PASS	input · generic input · output · check report
`569`	accepted exit 0 · 0.05038035999996282s	PASS	input · generic input · output · check report
`570`	accepted exit 0 · 0.05088449799995942s	PASS	input · generic input · output · check report
`571`	accepted exit 0 · 0.049119360000076995s	PASS	input · generic input · output · check report
`572`	accepted exit 0 · 0.06157127799997397s	PASS	input · generic input · output · check report
`573`	rejected exit 1 · 0.08921502599969244s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`574`	accepted exit 0 · 0.06785817599984512s	PASS	input · generic input · output · check report
`575`	accepted exit 0 · 0.04867142800003421s	PASS	input · generic input · output · check report
`576`	accepted exit 0 · 0.0669152440000289s	PASS	input · generic input · output · check report
`577`	accepted exit 0 · 0.06490705900023386s	PASS	input · generic input · output · check report
`578`	accepted exit 0 · 0.05762529999992694s	PASS	input · generic input · output · check report
`579`	accepted exit 0 · 0.09435921799968128s	PASS	input · generic input · output · check report
`580`	accepted exit 0 · 0.06093423099991924s	PASS	input · generic input · output · check report
`581`	accepted exit 0 · 0.05894615499983047s	PASS	input · generic input · output · check report
`582`	accepted exit 0 · 0.06251516299971627s	PASS	input · generic input · output · check report
`583`	accepted exit 0 · 0.05332344400039801s	PASS	input · generic input · output · check report
`584`	accepted exit 0 · 0.06191713000043819s	PASS	input · generic input · output · check report
`585`	accepted exit 0 · 0.05830208399993353s	PASS	input · generic input · output · check report
`586`	accepted exit 0 · 0.07641034600010244s	PASS	input · generic input · output · check report
`587`	accepted exit 0 · 0.05077253999979803s	PASS	input · generic input · output · check report
`588`	accepted exit 0 · 0.09489542799974515s	PASS	input · generic input · output · check report
`589`	accepted exit 0 · 0.05837538299965672s	PASS	input · generic input · output · check report
`590`	accepted exit 0 · 0.056719920999967144s	PASS	input · generic input · output · check report
`591`	rejected exit 1 · 0.10181136099981813s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`592`	accepted exit 0 · 0.055783209999844985s	PASS	input · generic input · output · check report
`593`	accepted exit 0 · 0.07060496499980218s	PASS	input · generic input · output · check report
`594`	accepted exit 0 · 0.06758767299970714s	PASS	input · generic input · output · check report
`595`	rejected exit 1 · 0.10832396600017091s	—	input · stderr <stdin>:45:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:45:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`596`	accepted exit 0 · 0.12720831700016788s	PASS	input · generic input · output · check report
`597`	accepted exit 0 · 0.06790239499969175s	PASS	input · generic input · output · check report
`598`	rejected exit 1 · 0.11320951200013951s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`599`	rejected exit 1 · 0.12750523699969563s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`600`	rejected exit 1 · 0.09158231000037631s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`601`	accepted exit 0 · 0.04773071900035575s	PASS	input · generic input · output · check report
`602`	accepted exit 0 · 0.04722037499959697s	PASS	input · generic input · output · check report
`603`	accepted exit 0 · 0.0521212089997789s	PASS	input · generic input · output · check report
`604`	rejected exit 1 · 0.09243831100047828s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`605`	rejected exit 1 · 0.056423091999931785s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`606`	accepted exit 0 · 0.06392567100010638s	PASS	input · generic input · output · check report
`607`	accepted exit 0 · 0.06557361999966815s	PASS	input · generic input · output · check report
`608`	accepted exit 0 · 0.09430579500076419s	PASS	input · generic input · output · check report
`609`	accepted exit 0 · 0.05677138900045975s	PASS	input · generic input · output · check report
`610`	accepted exit 0 · 0.05691680299969448s	PASS	input · generic input · output · check report
`611`	accepted exit 0 · 0.05426894199990784s	PASS	input · generic input · output · check report
`612`	accepted exit 0 · 0.05269463300010102s	PASS	input · generic input · output · check report
`613`	accepted exit 0 · 0.05432462899989332s	PASS	input · generic input · output · check report
`614`	accepted exit 0 · 0.11348844900021504s	PASS	input · generic input · output · check report
`615`	accepted exit 0 · 0.056035276999864436s	PASS	input · generic input · output · check report
`616`	accepted exit 0 · 0.05597990500064043s	PASS	input · generic input · output · check report
`617`	accepted exit 0 · 0.0559216670008027s	PASS	input · generic input · output · check report
`618`	accepted exit 0 · 0.06026126100005058s	PASS	input · generic input · output · check report
`619`	rejected exit 1 · 0.1005828150000525s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`620`	accepted exit 0 · 0.06404064600064885s	PASS	input · generic input · output · check report
`621`	accepted exit 0 · 0.05801070599954983s	PASS	input · generic input · output · check report
`622`	accepted exit 0 · 0.05266890599978069s	PASS	input · generic input · output · check report
`623`	accepted exit 0 · 0.05557104699983029s	PASS	input · generic input · output · check report
`624`	accepted exit 0 · 0.04989524999928108s	PASS	input · generic input · output · check report
`625`	accepted exit 0 · 0.08091780700033269s	PASS	input · generic input · output · check report
`626`	accepted exit 0 · 0.05323668499931955s	PASS	input · generic input · output · check report
`627`	accepted exit 0 · 0.05456637899987982s	PASS	input · generic input · output · check report
`628`	accepted exit 0 · 0.06363764199977595s	PASS	input · generic input · output · check report
`629`	accepted exit 0 · 0.09299062499940192s	PASS	input · generic input · output · check report
`630`	accepted exit 0 · 0.055359058000249206s	PASS	input · generic input · output · check report
`631`	accepted exit 0 · 0.04977388999941468s	PASS	input · generic input · output · check report
`632`	accepted exit 0 · 0.08323157700033335s	PASS	input · generic input · output · check report
`633`	accepted exit 0 · 0.0522880950002218s	PASS	input · generic input · output · check report
`634`	rejected exit 1 · 0.08528445899992221s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`635`	accepted exit 0 · 0.09052301900010207s	PASS	input · generic input · output · check report
`636`	accepted exit 0 · 0.05054627200024697s	PASS	input · generic input · output · check report
`637`	accepted exit 0 · 0.05579326899987791s	PASS	input · generic input · output · check report
`638`	accepted exit 0 · 0.04990756699953636s	PASS	input · generic input · output · check report
`639`	rejected exit 1 · 0.09092888799932553s	—	input · stderr <stdin>:51:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:51:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`640`	rejected exit 1 · 0.0999694450001698s	—	input · stderr <stdin>:56:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:56:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`641`	accepted exit 0 · 0.05513948600037111s	PASS	input · generic input · output · check report
`642`	accepted exit 0 · 0.05462485200041556s	PASS	input · generic input · output · check report
`643`	accepted exit 0 · 0.05528560199945787s	PASS	input · generic input · output · check report
`644`	rejected exit 1 · 0.09621633599999768s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`645`	rejected exit 1 · 0.11581241200019576s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`646`	accepted exit 0 · 0.06333079599971825s	PASS	input · generic input · output · check report
`647`	accepted exit 0 · 0.05392500400012068s	PASS	input · generic input · output · check report
`648`	accepted exit 0 · 0.052651297000011255s	PASS	input · generic input · output · check report
`649`	accepted exit 0 · 0.052796220000345784s	PASS	input · generic input · output · check report
`650`	accepted exit 0 · 0.058508570000412874s	PASS	input · generic input · output · check report
`651`	accepted exit 0 · 0.06119226299961156s	PASS	input · generic input · output · check report
`652`	accepted exit 0 · 0.0531583120000505s	PASS	input · generic input · output · check report
`653`	accepted exit 0 · 0.06818194900006347s	PASS	input · generic input · output · check report
`654`	accepted exit 0 · 0.0676642799999172s	PASS	input · generic input · output · check report
`655`	accepted exit 0 · 0.05344630400031747s	PASS	input · generic input · output · check report
`656`	accepted exit 0 · 0.052205678999598604s	PASS	input · generic input · output · check report
`657`	accepted exit 0 · 0.06083063099958963s	PASS	input · generic input · output · check report
`658`	accepted exit 0 · 0.06781985599991458s	PASS	input · generic input · output · check report
`659`	accepted exit 0 · 0.062156478999895626s	PASS	input · generic input · output · check report
`660`	accepted exit 0 · 0.06362907300081133s	PASS	input · generic input · output · check report
`661`	accepted exit 0 · 0.04806076299973938s	PASS	input · generic input · output · check report
`662`	accepted exit 0 · 0.0528104089999033s	PASS	input · generic input · output · check report
`663`	accepted exit 0 · 0.055189771999721415s	PASS	input · generic input · output · check report
`664`	rejected exit 1 · 0.09263148700028978s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`665`	accepted exit 0 · 0.05454774899953918s	PASS	input · generic input · output · check report
`666`	accepted exit 0 · 0.054393079999499605s	PASS	input · generic input · output · check report
`667`	accepted exit 0 · 0.06920798999999533s	PASS	input · generic input · output · check report
`668`	accepted exit 0 · 0.05112808000012592s	PASS	input · generic input · output · check report
`669`	rejected exit 1 · 0.09356094699978712s	—	input · stderr <stdin>:48:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:48:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`670`	accepted exit 0 · 0.0480348099999901s	PASS	input · generic input · output · check report
`671`	accepted exit 0 · 0.03887217999999848s	PASS	input · generic input · output · check report
`672`	rejected exit 1 · 0.08732079800029169s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`673`	accepted exit 0 · 0.06654026299929683s	PASS	input · generic input · output · check report
`674`	accepted exit 0 · 0.05390846699992835s	PASS	input · generic input · output · check report
`675`	accepted exit 0 · 0.04904939599964564s	PASS	input · generic input · output · check report
`676`	rejected exit 1 · 0.09121244099969772s	—	input · stderr <stdin>:74:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:74:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`677`	accepted exit 0 · 0.048883747000218136s	PASS	input · generic input · output · check report
`678`	accepted exit 0 · 0.08296865500051354s	PASS	input · generic input · output · check report
`679`	rejected exit 1 · 0.11058175700054562s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`680`	accepted exit 0 · 0.08737509900038276s	PASS	input · generic input · output · check report
`681`	accepted exit 0 · 0.05334642799971334s	PASS	input · generic input · output · check report
`682`	accepted exit 0 · 0.05126806200041756s	PASS	input · generic input · output · check report
`683`	accepted exit 0 · 0.05822374700073851s	PASS	input · generic input · output · check report
`684`	rejected exit 1 · 0.09993874500014499s	—	input · stderr <stdin>:40:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:40:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`685`	rejected exit 1 · 0.1090960189994803s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`686`	accepted exit 0 · 0.054219728999669314s	PASS	input · generic input · output · check report
`687`	accepted exit 0 · 0.053144181999414286s	PASS	input · generic input · output · check report
`688`	rejected exit 1 · 0.09735358100078884s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`689`	accepted exit 0 · 0.083256074000019s	PASS	input · generic input · output · check report
`690`	accepted exit 0 · 0.05334589300036896s	PASS	input · generic input · output · check report
`691`	accepted exit 0 · 0.05777667299935274s	PASS	input · generic input · output · check report
`692`	accepted exit 0 · 0.06213266400027351s	PASS	input · generic input · output · check report
`693`	accepted exit 0 · 0.06090323900025396s	PASS	input · generic input · output · check report
`694`	accepted exit 0 · 0.05453422499977023s	PASS	input · generic input · output · check report
`695`	accepted exit 0 · 0.048372299000220664s	PASS	input · generic input · output · check report
`696`	accepted exit 0 · 0.059289245000400115s	PASS	input · generic input · output · check report
`697`	accepted exit 0 · 0.09100178300013795s	PASS	input · generic input · output · check report
`698`	accepted exit 0 · 0.11389374800000951s	PASS	input · generic input · output · check report
`699`	accepted exit 0 · 0.08099833399955969s	PASS	input · generic input · output · check report
`700`	accepted exit 0 · 0.06084230299984483s	PASS	input · generic input · output · check report
`701`	rejected exit 1 · 0.09576370199920348s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`702`	accepted exit 0 · 0.052729506000105175s	PASS	input · generic input · output · check report
`703`	accepted exit 0 · 0.05359287800001766s	PASS	input · generic input · output · check report
`704`	accepted exit 0 · 0.06010645199967257s	PASS	input · generic input · output · check report
`705`	accepted exit 0 · 0.06381314400005067s	PASS	input · generic input · output · check report
`706`	accepted exit 0 · 0.05653831200015702s	PASS	input · generic input · output · check report
`707`	rejected exit 1 · 0.1104870099998152s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`708`	accepted exit 0 · 0.058525643999928434s	PASS	input · generic input · output · check report
`709`	accepted exit 0 · 0.06759669199982454s	PASS	input · generic input · output · check report
`710`	accepted exit 0 · 0.05810225999994145s	PASS	input · generic input · output · check report
`711`	accepted exit 0 · 0.06538437800008978s	PASS	input · generic input · output · check report
`712`	rejected exit 1 · 0.11264017699977558s	—	input · stderr <stdin>:56:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:56:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`713`	accepted exit 0 · 0.0552908710005795s	PASS	input · generic input · output · check report
`714`	accepted exit 0 · 0.048533678999774565s	PASS	input · generic input · output · check report
`715`	accepted exit 0 · 0.0604164389997095s	PASS	input · generic input · output · check report
`716`	accepted exit 0 · 0.05213385200022458s	PASS	input · generic input · output · check report
`717`	accepted exit 0 · 0.0575632999998561s	PASS	input · generic input · output · check report
`718`	accepted exit 0 · 0.06312989700018079s	PASS	input · generic input · output · check report
`719`	accepted exit 0 · 0.0576902800003154s	PASS	input · generic input · output · check report
`720`	accepted exit 0 · 0.06876141599968832s	PASS	input · generic input · output · check report
`721`	accepted exit 0 · 0.05226121400028205s	PASS	input · generic input · output · check report
`722`	accepted exit 0 · 0.06427121300021099s	PASS	input · generic input · output · check report
`723`	accepted exit 0 · 0.08313002700015204s	PASS	input · generic input · output · check report
`724`	accepted exit 0 · 0.06586178199995629s	PASS	input · generic input · output · check report
`725`	accepted exit 0 · 0.07157850000021426s	PASS	input · generic input · output · check report
`726`	accepted exit 0 · 0.13351781599976675s	PASS	input · generic input · output · check report
`727`	accepted exit 0 · 0.08165877500050556s	PASS	input · generic input · output · check report
`728`	accepted exit 0 · 0.07023460799973691s	PASS	input · generic input · output · check report
`729`	accepted exit 0 · 0.05912095199983014s	PASS	input · generic input · output · check report
`730`	rejected exit 1 · 0.10508939899955294s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`731`	accepted exit 0 · 0.0626575349997438s	PASS	input · generic input · output · check report
`732`	accepted exit 0 · 0.059866583999792056s	PASS	input · generic input · output · check report
`733`	accepted exit 0 · 0.08112428399999772s	PASS	input · generic input · output · check report
`734`	accepted exit 0 · 0.06658458299989434s	PASS	input · generic input · output · check report
`735`	accepted exit 0 · 0.06121100100062904s	PASS	input · generic input · output · check report
`736`	accepted exit 0 · 0.07050273499953619s	PASS	input · generic input · output · check report
`737`	accepted exit 0 · 0.06586787899959745s	PASS	input · generic input · output · check report
`738`	accepted exit 0 · 0.07331460700061143s	PASS	input · generic input · output · check report
`739`	accepted exit 0 · 0.07038235000072746s	PASS	input · generic input · output · check report
`740`	accepted exit 0 · 0.06634654899971792s	PASS	input · generic input · output · check report
`741`	accepted exit 0 · 0.06257849200028431s	PASS	input · generic input · output · check report
`742`	accepted exit 0 · 0.06118522499946266s	PASS	input · generic input · output · check report
`743`	accepted exit 0 · 0.058842645000368066s	PASS	input · generic input · output · check report
`744`	accepted exit 0 · 0.06404272399959154s	PASS	input · generic input · output · check report
`745`	accepted exit 0 · 0.05923867999990762s	PASS	input · generic input · output · check report
`746`	accepted exit 0 · 0.06627844400009053s	PASS	input · generic input · output · check report
`747`	accepted exit 0 · 0.0764642290005213s	PASS	input · generic input · output · check report
`748`	rejected exit 1 · 0.10600700699978916s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`749`	rejected exit 1 · 0.1257038769999781s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`750`	accepted exit 0 · 0.055700775000332214s	PASS	input · generic input · output · check report
`751`	accepted exit 0 · 0.07654637499945238s	PASS	input · generic input · output · check report
`752`	accepted exit 0 · 0.0595422120004514s	PASS	input · generic input · output · check report
`753`	accepted exit 0 · 0.06050574300024891s	PASS	input · generic input · output · check report
`754`	accepted exit 0 · 0.08735637399968255s	PASS	input · generic input · output · check report
`755`	rejected exit 1 · 0.1026837669996894s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`756`	accepted exit 0 · 0.08581436700023914s	PASS	input · generic input · output · check report
`757`	accepted exit 0 · 0.06748385300033988s	PASS	input · generic input · output · check report
`758`	accepted exit 0 · 0.0677609639997172s	PASS	input · generic input · output · check report
`759`	accepted exit 0 · 0.05411427800027013s	PASS	input · generic input · output · check report
`760`	accepted exit 0 · 0.07377482199990482s	PASS	input · generic input · output · check report
`761`	accepted exit 0 · 0.058920907999890915s	PASS	input · generic input · output · check report
`762`	accepted exit 0 · 0.06072829400000046s	PASS	input · generic input · output · check report
`763`	accepted exit 0 · 0.06380202800028201s	PASS	input · generic input · output · check report
`764`	accepted exit 0 · 0.06810762700024497s	PASS	input · generic input · output · check report
`765`	accepted exit 0 · 0.07815998200021568s	PASS	input · generic input · output · check report
`766`	accepted exit 0 · 0.05214606199933769s	PASS	input · generic input · output · check report
`767`	accepted exit 0 · 0.05971818800026085s	PASS	input · generic input · output · check report
`768`	accepted exit 0 · 0.053039170000374725s	PASS	input · generic input · output · check report
`769`	accepted exit 0 · 0.05720849400040606s	PASS	input · generic input · output · check report
`770`	accepted exit 0 · 0.07274773700009973s	PASS	input · generic input · output · check report
`771`	accepted exit 0 · 0.06332660800035228s	PASS	input · generic input · output · check report
`772`	accepted exit 0 · 0.0592829619999975s	PASS	input · generic input · output · check report
`773`	accepted exit 0 · 0.06785473599938996s	PASS	input · generic input · output · check report
`774`	accepted exit 0 · 0.07966036499965412s	PASS	input · generic input · output · check report
`775`	accepted exit 0 · 0.06190149299982295s	PASS	input · generic input · output · check report
`776`	accepted exit 0 · 0.06415084800028126s	PASS	input · generic input · output · check report
`777`	accepted exit 0 · 0.07639784700040764s	PASS	input · generic input · output · check report
`778`	accepted exit 0 · 0.06137321099959081s	PASS	input · generic input · output · check report
`779`	accepted exit 0 · 0.09669769400079531s	PASS	input · generic input · output · check report
`780`	rejected exit 1 · 0.09791019300064363s	—	input · stderr <stdin>:58:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:58:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`781`	accepted exit 0 · 0.06110247300057381s	PASS	input · generic input · output · check report
`782`	accepted exit 0 · 0.06586385799982963s	PASS	input · generic input · output · check report
`783`	accepted exit 0 · 0.0672909390004861s	PASS	input · generic input · output · check report
`784`	rejected exit 1 · 0.0947497460001614s	—	input · stderr <stdin>:38:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:38:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`785`	accepted exit 0 · 0.0632781510003042s	PASS	input · generic input · output · check report
`786`	accepted exit 0 · 0.05809946099998342s	PASS	input · generic input · output · check report
`787`	accepted exit 0 · 0.058836847999373276s	PASS	input · generic input · output · check report
`788`	accepted exit 0 · 0.05587283899967588s	PASS	input · generic input · output · check report
`789`	accepted exit 0 · 0.06447730499985482s	PASS	input · generic input · output · check report
`790`	accepted exit 0 · 0.061296488999687426s	PASS	input · generic input · output · check report
`791`	accepted exit 0 · 0.058183721999739646s	PASS	input · generic input · output · check report
`792`	rejected exit 1 · 0.09327011900040816s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`793`	accepted exit 0 · 0.13425544999972772s	PASS	input · generic input · output · check report
`794`	accepted exit 0 · 0.06243162200007646s	PASS	input · generic input · output · check report
`795`	accepted exit 0 · 0.08136216799994145s	PASS	input · generic input · output · check report
`796`	rejected exit 1 · 0.11324566999974195s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`797`	rejected exit 1 · 0.11615312200046901s	—	input · stderr <stdin>:39:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:39:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`798`	rejected exit 1 · 0.11066382900025928s	—	input · stderr <stdin>:54:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:54:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`799`	accepted exit 0 · 0.055524096000226564s	PASS	input · generic input · output · check report
`800`	accepted exit 0 · 0.06514448400048423s	PASS	input · generic input · output · check report
`801`	accepted exit 0 · 0.06387487799929659s	PASS	input · generic input · output · check report
`802`	accepted exit 0 · 0.06067678700037504s	PASS	input · generic input · output · check report
`803`	accepted exit 0 · 0.05480036300014035s	PASS	input · generic input · output · check report
`804`	accepted exit 0 · 0.062357066000004124s	PASS	input · generic input · output · check report
`805`	accepted exit 0 · 0.06611595100002887s	PASS	input · generic input · output · check report
`806`	accepted exit 0 · 0.10199789799935388s	PASS	input · generic input · output · check report
`807`	accepted exit 0 · 0.09843367000030412s	PASS	input · generic input · output · check report
`808`	rejected exit 1 · 0.10275848800029053s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`809`	accepted exit 0 · 0.08723683700009133s	PASS	input · generic input · output · check report
`810`	rejected exit 1 · 0.1025332850003906s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`811`	accepted exit 0 · 0.06110847000036301s	PASS	input · generic input · output · check report
`812`	rejected exit 1 · 0.12974990699967748s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`813`	accepted exit 0 · 0.05987145499966573s	PASS	input · generic input · output · check report
`814`	accepted exit 0 · 0.06884270600039599s	PASS	input · generic input · output · check report
`815`	accepted exit 0 · 0.06121277599959285s	PASS	input · generic input · output · check report
`816`	accepted exit 0 · 0.06011918100011826s	PASS	input · generic input · output · check report
`817`	accepted exit 0 · 0.08363918499981082s	PASS	input · generic input · output · check report
`818`	accepted exit 0 · 0.059631414000250516s	PASS	input · generic input · output · check report
`819`	accepted exit 0 · 0.06242081700020208s	PASS	input · generic input · output · check report
`820`	accepted exit 0 · 0.06123541899978591s	PASS	input · generic input · output · check report
`821`	accepted exit 0 · 0.05870892999973876s	PASS	input · generic input · output · check report
`822`	accepted exit 0 · 0.058903334999740764s	PASS	input · generic input · output · check report
`823`	accepted exit 0 · 0.06794040000022505s	PASS	input · generic input · output · check report
`824`	accepted exit 0 · 0.06477615400035575s	PASS	input · generic input · output · check report
`825`	accepted exit 0 · 0.06516196800021135s	PASS	input · generic input · output · check report
`826`	rejected exit 1 · 0.09790061000057904s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`827`	accepted exit 0 · 0.05209049099994445s	PASS	input · generic input · output · check report
`828`	rejected exit 1 · 0.09208095100075298s	—	input · stderr <stdin>:37:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:37:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`829`	accepted exit 0 · 0.058207779000440496s	PASS	input · generic input · output · check report
`830`	accepted exit 0 · 0.05123209900011716s	PASS	input · generic input · output · check report
`831`	accepted exit 0 · 0.05672106499969232s	PASS	input · generic input · output · check report
`832`	accepted exit 0 · 0.05989824599964777s	PASS	input · generic input · output · check report
`833`	rejected exit 1 · 0.10192232800000056s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`834`	accepted exit 0 · 0.06239387599998736s	PASS	input · generic input · output · check report
`835`	accepted exit 0 · 0.06669416800014005s	PASS	input · generic input · output · check report
`836`	accepted exit 0 · 0.05903287899946008s	PASS	input · generic input · output · check report
`837`	accepted exit 0 · 0.06089736400008405s	PASS	input · generic input · output · check report
`838`	accepted exit 0 · 0.06380247499964753s	PASS	input · generic input · output · check report
`839`	rejected exit 1 · 0.09951022599943826s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`840`	rejected exit 1 · 0.1311224189994391s	—	input · stderr <stdin>:47:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:47:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`841`	accepted exit 0 · 0.061201114999676065s	PASS	input · generic input · output · check report
`842`	accepted exit 0 · 0.060219599999982165s	PASS	input · generic input · output · check report
`843`	accepted exit 0 · 0.06152141799975652s	PASS	input · generic input · output · check report
`844`	accepted exit 0 · 0.11925276100009796s	PASS	input · generic input · output · check report
`845`	accepted exit 0 · 0.06201025700011087s	PASS	input · generic input · output · check report
`846`	rejected exit 1 · 0.11743899300017802s	—	input · stderr <stdin>:66:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:66:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`847`	accepted exit 0 · 0.059866908000003605s	PASS	input · generic input · output · check report
`848`	accepted exit 0 · 0.07986467299997457s	PASS	input · generic input · output · check report
`849`	accepted exit 0 · 0.05852536600013991s	PASS	input · generic input · output · check report
`850`	accepted exit 0 · 0.06223098099962954s	PASS	input · generic input · output · check report
`851`	accepted exit 0 · 0.05505978299970593s	PASS	input · generic input · output · check report
`852`	accepted exit 0 · 0.062156782000784006s	PASS	input · generic input · output · check report
`853`	rejected exit 1 · 0.09320993500023178s	—	input · stderr <stdin>:51:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:51:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`854`	accepted exit 0 · 0.05436989600002562s	PASS	input · generic input · output · check report
`855`	rejected exit 1 · 0.09843998500036832s	—	input · stderr <stdin>:35:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:35:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`856`	accepted exit 0 · 0.058418755999809946s	PASS	input · generic input · output · check report
`857`	accepted exit 0 · 0.05800841499967646s	PASS	input · generic input · output · check report
`858`	accepted exit 0 · 0.0650625130001572s	PASS	input · generic input · output · check report
`859`	rejected exit 1 · 0.09664740700009133s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`860`	accepted exit 0 · 0.06784206700012874s	PASS	input · generic input · output · check report
`861`	accepted exit 0 · 0.0662729190007667s	PASS	input · generic input · output · check report
`862`	rejected exit 1 · 0.09689344899925345s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`863`	rejected exit 1 · 0.10642077600004995s	—	input · stderr <stdin>:53:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:53:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`864`	accepted exit 0 · 0.06327770900043106s	PASS	input · generic input · output · check report
`865`	accepted exit 0 · 0.07647526400069182s	PASS	input · generic input · output · check report
`866`	rejected exit 1 · 0.10761659300078463s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`867`	rejected exit 1 · 0.1050254629999472s	—	input · stderr <stdin>:42:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:42:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`868`	accepted exit 0 · 0.06681007799943472s	PASS	input · generic input · output · check report
`869`	rejected exit 1 · 0.12283095800012234s	—	input · stderr <stdin>:46:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:46:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`870`	rejected exit 1 · 0.10277165699972102s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`871`	accepted exit 0 · 0.07334689399976924s	PASS	input · generic input · output · check report
`872`	accepted exit 0 · 0.060337904000334674s	PASS	input · generic input · output · check report
`873`	rejected exit 1 · 0.09948348800025997s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`874`	accepted exit 0 · 0.07069735400000354s	PASS	input · generic input · output · check report
`875`	accepted exit 0 · 0.05932640300034109s	PASS	input · generic input · output · check report
`876`	accepted exit 0 · 0.09009196599981806s	PASS	input · generic input · output · check report
`877`	accepted exit 0 · 0.06446153500019136s	PASS	input · generic input · output · check report
`878`	accepted exit 0 · 0.06476642699999502s	PASS	input · generic input · output · check report
`879`	accepted exit 0 · 0.07158195700048964s	PASS	input · generic input · output · check report
`880`	accepted exit 0 · 0.07580820099974517s	PASS	input · generic input · output · check report
`881`	accepted exit 0 · 0.05474986199988052s	PASS	input · generic input · output · check report
`882`	accepted exit 0 · 0.0576439210008175s	PASS	input · generic input · output · check report
`883`	accepted exit 0 · 0.06677488300010737s	PASS	input · generic input · output · check report
`884`	accepted exit 0 · 0.07127556199975515s	PASS	input · generic input · output · check report
`885`	accepted exit 0 · 0.06515553900044324s	PASS	input · generic input · output · check report
`886`	accepted exit 0 · 0.06797639000069466s	PASS	input · generic input · output · check report
`887`	accepted exit 0 · 0.05838691799999651s	PASS	input · generic input · output · check report
`888`	accepted exit 0 · 0.061947580000378366s	PASS	input · generic input · output · check report
`889`	accepted exit 0 · 0.05692496000028768s	PASS	input · generic input · output · check report
`890`	rejected exit 1 · 0.09713671800000157s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`891`	accepted exit 0 · 0.06190188400069019s	PASS	input · generic input · output · check report
`892`	accepted exit 0 · 0.056070925000312855s	PASS	input · generic input · output · check report
`893`	accepted exit 0 · 0.09881810800015955s	PASS	input · generic input · output · check report
`894`	rejected exit 1 · 0.10932538700035366s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`895`	rejected exit 1 · 0.10150221299954865s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`896`	accepted exit 0 · 0.07383497299997543s	PASS	input · generic input · output · check report
`897`	accepted exit 0 · 0.05934986800002662s	PASS	input · generic input · output · check report
`898`	rejected exit 1 · 0.10816490600063844s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`899`	accepted exit 0 · 0.06485874200006947s	PASS	input · generic input · output · check report
`900`	accepted exit 0 · 0.05466554399936285s	PASS	input · generic input · output · check report
`901`	accepted exit 0 · 0.0640123749999475s	PASS	input · generic input · output · check report
`902`	accepted exit 0 · 0.0718904069999553s	PASS	input · generic input · output · check report
`903`	accepted exit 0 · 0.07258605700008047s	PASS	input · generic input · output · check report
`904`	rejected exit 1 · 0.11113689499961765s	—	input · stderr <stdin>:60:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:60:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`905`	rejected exit 1 · 0.0942381459999524s	—	input · stderr <stdin>:43:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:43:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`906`	accepted exit 0 · 0.05552804599938099s	PASS	input · generic input · output · check report
`907`	accepted exit 0 · 0.0628871689996231s	PASS	input · generic input · output · check report
`908`	accepted exit 0 · 0.06420856899967475s	PASS	input · generic input · output · check report
`909`	accepted exit 0 · 0.05704839899954095s	PASS	input · generic input · output · check report
`910`	accepted exit 0 · 0.056985379999787256s	PASS	input · generic input · output · check report
`911`	accepted exit 0 · 0.061011638999843854s	PASS	input · generic input · output · check report
`912`	rejected exit 1 · 0.09904079099942464s	—	input · stderr <stdin>:46:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:46:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`913`	rejected exit 1 · 0.0971359589993881s	—	input · stderr <stdin>:39:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:39:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`914`	rejected exit 1 · 0.09835379499963892s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`915`	accepted exit 0 · 0.059031054000115546s	PASS	input · generic input · output · check report
`916`	accepted exit 0 · 0.060921317000065756s	PASS	input · generic input · output · check report
`917`	accepted exit 0 · 0.0605423819997668s	PASS	input · generic input · output · check report
`918`	rejected exit 1 · 0.09887688600065303s	—	input · stderr <stdin>:55:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:55:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`919`	rejected exit 1 · 0.10485651799990592s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`920`	accepted exit 0 · 0.06325294099951861s	PASS	input · generic input · output · check report
`921`	accepted exit 0 · 0.0656770690002304s	PASS	input · generic input · output · check report
`922`	rejected exit 1 · 0.11048885299987887s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`923`	accepted exit 0 · 0.07255779899969639s	PASS	input · generic input · output · check report
`924`	accepted exit 0 · 0.06329405599990423s	PASS	input · generic input · output · check report
`925`	accepted exit 0 · 0.06995146300050692s	PASS	input · generic input · output · check report
`926`	accepted exit 0 · 0.061105107000003045s	PASS	input · generic input · output · check report
`927`	accepted exit 0 · 0.06216605600002367s	PASS	input · generic input · output · check report
`928`	accepted exit 0 · 0.070667279999725s	PASS	input · generic input · output · check report
`929`	rejected exit 1 · 0.10457189000044309s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`930`	accepted exit 0 · 0.08210299600068538s	PASS	input · generic input · output · check report
`931`	accepted exit 0 · 0.07565217499995924s	PASS	input · generic input · output · check report
`932`	accepted exit 0 · 0.06175193200033391s	PASS	input · generic input · output · check report
`933`	accepted exit 0 · 0.050641098000596685s	PASS	input · generic input · output · check report
`934`	accepted exit 0 · 0.054477308000059566s	PASS	input · generic input · output · check report
`935`	rejected exit 1 · 0.08843935400000191s	—	input · stderr <stdin>:56:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:56:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`936`	accepted exit 0 · 0.053096293999260524s	PASS	input · generic input · output · check report
`937`	accepted exit 0 · 0.05561092300013115s	PASS	input · generic input · output · check report
`938`	accepted exit 0 · 0.0575622000005751s	PASS	input · generic input · output · check report
`939`	accepted exit 0 · 0.06262955100010004s	PASS	input · generic input · output · check report
`940`	accepted exit 0 · 0.052901824000400666s	PASS	input · generic input · output · check report
`941`	accepted exit 0 · 0.057916726999792445s	PASS	input · generic input · output · check report
`942`	accepted exit 0 · 0.0678458310003407s	PASS	input · generic input · output · check report
`943`	accepted exit 0 · 0.06069656500039855s	PASS	input · generic input · output · check report
`944`	accepted exit 0 · 0.06009781600005226s	PASS	input · generic input · output · check report
`945`	accepted exit 0 · 0.06109102600021288s	PASS	input · generic input · output · check report
`946`	accepted exit 0 · 0.0548130819997823s	PASS	input · generic input · output · check report
`947`	accepted exit 0 · 0.06220170800042979s	PASS	input · generic input · output · check report
`948`	accepted exit 0 · 0.057407440999668324s	PASS	input · generic input · output · check report
`949`	rejected exit 1 · 0.09747342599985132s	—	input · stderr <stdin>:59:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:59:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`950`	accepted exit 0 · 0.0577021760000207s	PASS	input · generic input · output · check report
`951`	accepted exit 0 · 0.060012660000211326s	PASS	input · generic input · output · check report
`952`	accepted exit 0 · 0.06261510399963299s	PASS	input · generic input · output · check report
`953`	rejected exit 1 · 0.09845497200058162s	—	input · stderr <stdin>:44:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:44:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`954`	rejected exit 1 · 0.10511475499970402s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`955`	accepted exit 0 · 0.056846521000807115s	PASS	input · generic input · output · check report
`956`	accepted exit 0 · 0.055976841999836324s	PASS	input · generic input · output · check report
`957`	accepted exit 0 · 0.05593513200074085s	PASS	input · generic input · output · check report
`958`	accepted exit 0 · 0.06375814500006527s	PASS	input · generic input · output · check report
`959`	accepted exit 0 · 0.05862898700070218s	PASS	input · generic input · output · check report
`960`	accepted exit 0 · 0.05487410100067791s	PASS	input · generic input · output · check report
`961`	accepted exit 0 · 0.05471574100010912s	PASS	input · generic input · output · check report
`962`	accepted exit 0 · 0.05512363900015771s	PASS	input · generic input · output · check report
`963`	accepted exit 0 · 0.0990882469995995s	PASS	input · generic input · output · check report
`964`	accepted exit 0 · 0.054184788999918965s	PASS	input · generic input · output · check report
`965`	accepted exit 0 · 0.07973003100050846s	PASS	input · generic input · output · check report
`966`	accepted exit 0 · 0.07437097999991238s	PASS	input · generic input · output · check report
`967`	accepted exit 0 · 0.08554728199942474s	PASS	input · generic input · output · check report
`968`	accepted exit 0 · 0.08776197399947705s	PASS	input · generic input · output · check report
`969`	accepted exit 0 · 0.05874060099995404s	PASS	input · generic input · output · check report
`970`	rejected exit 1 · 0.09926079199976812s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`971`	rejected exit 1 · 0.09441556099955051s	—	input · stderr <stdin>:65:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:65:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`972`	rejected exit 1 · 0.0971507060003205s	—	input · stderr <stdin>:58:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:58:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`973`	accepted exit 0 · 0.08457214099962584s	PASS	input · generic input · output · check report
`974`	accepted exit 0 · 0.05217076899953099s	PASS	input · generic input · output · check report
`975`	accepted exit 0 · 0.0696168549993672s	PASS	input · generic input · output · check report
`976`	accepted exit 0 · 0.11158666699975583s	PASS	input · generic input · output · check report
`977`	accepted exit 0 · 0.05564336000043113s	PASS	input · generic input · output · check report
`978`	accepted exit 0 · 0.04830425000000105s	PASS	input · generic input · output · check report
`979`	accepted exit 0 · 0.05736017500021262s	PASS	input · generic input · output · check report
`980`	accepted exit 0 · 0.05919648400049482s	PASS	input · generic input · output · check report
`981`	accepted exit 0 · 0.058615789000214136s	PASS	input · generic input · output · check report
`982`	accepted exit 0 · 0.07062824499917042s	PASS	input · generic input · output · check report
`983`	accepted exit 0 · 0.0632161969997469s	PASS	input · generic input · output · check report
`984`	accepted exit 0 · 0.07162869900002988s	PASS	input · generic input · output · check report
`985`	accepted exit 0 · 0.054776300999947125s	PASS	input · generic input · output · check report
`986`	rejected exit 1 · 0.09141248800005997s	—	input · stderr <stdin>:27:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:27:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`987`	accepted exit 0 · 0.05362363799940795s	PASS	input · generic input · output · check report
`988`	accepted exit 0 · 0.05856893600048352s	PASS	input · generic input · output · check report
`989`	rejected exit 1 · 0.1104799170007027s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`990`	accepted exit 0 · 0.0637165059997642s	PASS	input · generic input · output · check report
`991`	accepted exit 0 · 0.059485663000486966s	PASS	input · generic input · output · check report
`992`	accepted exit 0 · 0.10983613099961076s	PASS	input · generic input · output · check report
`993`	accepted exit 0 · 0.05925644899980398s	PASS	input · generic input · output · check report
`994`	accepted exit 0 · 0.06454488399958791s	PASS	input · generic input · output · check report
`995`	accepted exit 0 · 0.06784792700000253s	PASS	input · generic input · output · check report
`996`	rejected exit 1 · 0.10024484299992764s	—	input · stderr <stdin>:29:19: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = llvm.call @extern_scale(%a) : (i32) -> i32 ^ <stdin>:29:19: note: see current operation: %0 = "llvm.call"(%arg1) <{CConv = #llvm.cconv<ccc>, TailCallKind = #llvm.tailcallkind<none>, callee = @extern_scale, fastmathFlags = #llvm.fastmath<none>, op_bundle_sizes = array<i32>, operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> i32
`997`	rejected exit 1 · 0.11179188000005524s	—	input · stderr <stdin>:28:19: error: loom-lower-graph-memory: operation 'func.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation %called = func.call @helper_double(%a) : (i32) -> i32 ^ <stdin>:28:19: note: see current operation: %0 = "func.call"(%arg1) <{callee = @helper_double}> : (i32) -> i32
`998`	accepted exit 0 · 0.05890980399999535s	PASS	input · generic input · output · check report
`999`	accepted exit 0 · 0.06678593499964336s	PASS	input · generic input · output · check report

How this PBT was generated and reviewed

paired production revision · manifest.json · review.json

partial source coverage: Approved to run and display existing artifacts; accuracy and completeness are measured separately.

Independent replay: 20 generated, 16 compiler-accepted; checker verdicts {"PASS": 16}. Compiler binary and revision identities matched.

Covered requirements

Prohibition of listed callable definitions, calls and launches in graph descendants.

Uncovered requirements

Partial: directly checks listed forbidden operations throughout graph descendants. All 16 accepted outputs contain graphs. The four rejected seeds (2,4,14,17) selected func.call/llvm.call inside candidates and fail graph lowering; these are not checker passes. Injecting a forbidden func.call fails; removing a graph symbol still passes. Symbol-bearing, module-scope and function-like requirements are absent. Empty output passes, which is a campaign applicability limitation rather than a counterexample to the body-only universal prohibition.

Agent-selected pinned authoring context · authoring-context.json

{"entries":[{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"457-494","path":"docs/spec-compiler-part-3-dfg.md","roles":["context","input_construction"],"text":"* `llvm.func` remains the sole function and ABI owner for a callable imported\n  from the final linked LLVM module. `func.func` is used only for a genuinely\n  standard-MLIR-native callable or helper; it cannot mirror the LLVM ABI.\n  Neither callable kind chooses HostCore or AccCore ownership. Call-context\n  classification decides where calls are legal.\n* `loom.spatial_region` is temporary compiler IR inside a\n  `dataflow.thread`. It owns one structured graph candidate with normalized\n  value, stream-channel, and memory boundary segments. It never appears in a\n  finalized Canonical Dataflow Program.\n* `dataflow.thread` is the logical accelerator execution-domain\n  **definition** (Symbol-bearing, module-scope, function-like). It owns the\n  kernel body and one domain kind. A dense definition owns coordinate rank\n  through its canonical entry-block shape; a dynamic definition designates\n  one ordinary argument as its work-item payload.\n  It does not itself execute; dynamic logical instances are\n  materialized by one or more `dataflow.thread.launch` ops at use\n  sites, then SystemMapping decides which instances occupy physical AccCore\n  slots.\n* `dataflow.thread.launch` is the logical accelerator execution\n  boundary. It references a `dataflow.thread` callable by symbol, supplies\n  async dependencies and ordinary body operands, plus one non-negative extent\n  per dense coordinate dimension. A dynamic launch instead supplies one root\n  work item and no extents. Both produce one collective completion token.\n* `dataflow.work.spawn` publishes one child of the currently executing dynamic\n  work item after atomically acquiring its termination responsibility. It is\n  illegal in a dense thread or any graph and is not nested thread launch.\n* `dataflow.graph` is the SpatialCore leaf DFG **definition**\n  (Symbol-bearing, module-scope, function-like). Its body cannot\n  contain callable definitions, `llvm.call`, `func.call`,\n  `dataflow.thread.launch`, `dataflow.graph.launch`, or another\n  `dataflow.graph` definition.\n  It is final target-independent software IR: its validity does not assert\n  that any current Fabric can realize it. TechMapping owns that decision.\n* `dataflow.graph.launch` is the SpatialCore execution boundary\n  inside a `dataflow.thread` definition's body. It references a\n  `dataflow.graph` callable by symbol, supplies dependency events, value\n  inputs, stream channel bindings, and memory imports, and yields value\n  outputs, memory exports, and a trailing `done : none` result.","why":"Governing context of the sampled obligation: fixes the callable kinds (llvm.func, func.func, dataflow.thread, dataflow.graph), the roles of loom.spatial_region, dataflow.thread, dataflow.graph.launch and dataflow.thread.launch, so the generator builds module-scope thread definitions owning explicit spatial candidates and the postcondition names exactly the excluded constructs."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"23-26","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"the launch result is derived. Part 3 consumes each explicit\n`loom.spatial_region` inside its owning `dataflow.thread` and publishes the\ncorresponding graph definition and launch only after complete conversion and\nnative finalization succeed.","why":"Part 3 consumes each explicit loom.spatial_region inside its owning dataflow.thread and publishes the graph definition and launch only on complete success; this is why every sampled input places the candidate inside a thread definition and why fail-closed samples publish nothing."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"499-506","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction","input_well_formedness"],"text":"`llvm.func` or `func.func` definitions. An `llvm.call` or `func.call` inside a\n`dataflow.thread` definition's body is an InstructionCore call. If the callee\ncontains code that must become a `dataflow.graph` definition, Part 3 must\ninline or specialize that callee into the active thread definition\nbefore graph extraction. A `dataflow.thread.launch` is invalid\ntransitively inside every thread or graph definition. Non-inlined\nInstructionCore calls may remain only when their callee body is graph-free\nafter this preparation.","why":"An llvm.call/func.call in a thread body is an InstructionCore call and may remain when its callee body is graph-free; motivates the optional thread-level func.call site (published graph must still exclude it) and the adversarial call-inside-candidate forms."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"564-569","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction","input_well_formedness"],"text":"6. `loom.spatial_region` is the temporary publication boundary inside an\n   existing `dataflow.thread`. Its operands are normalized as value inputs,\n   stream input channels, memory inputs, and stream output channels; its\n   results are value outputs followed by memory outputs. Each stream input\n   has one affine `source_map` from the consumer thread domain to the producer\n   thread domain. The lowering collects all explicit candidates before","why":"Normalized operand order of loom.spatial_region (value inputs, stream inputs, memory inputs, stream outputs; value then memory results) and the source_map requirement; determines the operandSegmentSizes/resultSegmentSizes and source_maps the generator emits."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"573-574","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"canonical graph. Current publication supports nested `scf.if` completion\n   propagation. Stream channel segments become payload-typed graph stream","why":"Nested scf.if completion propagation is supported, so candidate sites are sampled under scf.if as well as at thread top level."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"578-582","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"enter the canonical graph body. One binding denotes one ordered dynamic\n   event sequence. A fixed structured scope may contain multiple sequential\n   or structured mutually exclusive sites. Lowering emits one fixed ordinal\n   schedule, filters inactive branch sites, demuxes each input from the\n   filtered ordinal, and muxes outputs back into that same dynamic order.","why":"A fixed structured scope may contain multiple sequential or mutually exclusive sites; justifies sampling one or two candidate sites per thread and a branch-shaped candidate body."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"591-598","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"Branches may have unequal or empty site sets, and a later branch selector\n   may depend on an earlier input event. Enclosing loops repeatedly activate\n   the same schedule, so one or several static body sites may each fire\n   dynamically. Across repeated thread launches, each endpoint binding and\n   logical point concatenates these per-instance sequences in deterministic\n   launch issue order. Channel delivery pairs the resulting producer and\n   consumer sequences by message ordinal after applying `source_map`; it does\n   not pair thread activations or create activation-owned segments. Endpoint","why":"Enclosing loops repeatedly activate the same schedule; justifies sampling candidate sites nested under scf.for and loop-carried arithmetic inside a candidate."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"598-601","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_well_formedness"],"text":"not pair thread activations or create activation-owned segments. Endpoint\n   sites nested under `scf.parallel` or `scf.forall` have no inferred\n   traversal order and fail before publication. Unselected or non-fixed\n   graph-owned parallel forms also fail closed.","why":"Endpoint sites nested under scf.parallel or scf.forall have no inferred traversal order and fail before publication; the generator therefore never nests a candidate under those forms."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"1413-1419","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_well_formedness"],"text":"* `loom.spatial_region` is a transparent structured boundary. A blocking\n  receive inside that region cannot be justified by a send that follows the\n  region in the same stored-program strand merely because the published graph\n  launch becomes asynchronous. Such a transformation would turn an\n  inline-semantics deadlock into progress. A resulting retirement/send cycle\n  therefore identifies a deadlocking or incorrectly cut candidate; lowering\n  must not remove a wait by inventing a same-activation channel witness.","why":"A blocking receive inside the transparent region boundary may not be justified by a later send; the generator emits no channel send/receive endpoints so no sampled candidate is a deadlocking or incorrectly cut candidate."},{"file_sha256":"73f239de628bbf8d40145ecde732142ffcf6567c9483e6dc2286ae9176a6907c","kind":"language_definition","lines":"8-103","path":"include/Frontend/IR/LoomOps.td","roles":["input_construction","input_well_formedness"],"text":"def Loom_SpatialRegionOp : Loom_Op<\"spatial_region\", [\n    IsolatedFromAbove,\n    SingleBlock,\n    AttrSizedOperandSegments,\n    AttrSizedResultSegments,\n    RecursiveMemoryEffects\n]> {\n  let summary = \"Structured candidate for one SpatialCore graph\";\n  let description = [{\n    Holds one structured candidate inside a `dataflow.thread`. Operands are\n    normalized as value inputs, stream input channels, memory inputs, and\n    stream output channels. Results are normalized as value outputs followed\n    by memory outputs. Each stream input has one affine `source_map`.\n\n    This operation is temporary compiler IR. Successful publication replaces\n    it with one native-valid `dataflow.graph` and its matching launch.\n  }];\n\n  let arguments = (ins\n      Variadic<AnyType>:$valueInputs,\n      Variadic<Dataflow_ChannelType>:$streamInputs,\n      Variadic<AnyType>:$memoryInputs,\n      Variadic<Dataflow_ChannelType>:$streamOutputs,\n      AffineMapArrayAttr:$source_maps,\n      OptionalAttr<StrAttr>:$graph_name);\n\n  let results = (outs\n      Variadic<AnyType>:$valueResults,\n      Variadic<AnyType>:$memoryResults);\n\n  let regions = (region AnyRegion:$body);\n\n  let skipDefaultBuilders = 1;\n  let builders = [\n    OpBuilder<(ins\n        \"::mlir::ValueRange\":$valueInputs,\n        \"::mlir::ValueRange\":$streamInputs,\n        \"::mlir::ValueRange\":$memoryInputs,\n        \"::mlir::ValueRange\":$streamOutputs,\n        \"::mlir::TypeRange\":$valueResultTypes,\n        \"::mlir::TypeRange\":$memoryResultTypes,\n        \"::mlir::ArrayAttr\":$sourceMaps,\n        CArg<\"::mlir::StringAttr\", \"{}\">:$graphName), [{\n      $_state.addOperands(valueInputs);\n      $_state.addOperands(streamInputs);\n      $_state.addOperands(memoryInputs);\n      $_state.addOperands(streamOutputs);\n      $_state.addTypes(valueResultTypes);\n      $_state.addTypes(memoryResultTypes);\n      $_state.addAttribute(\"source_maps\", sourceMaps);\n      if (graphName)\n        $_state.addAttribute(\"graph_name\", graphName);\n      auto &properties = $_state.getOrAddProperties<Properties>();\n      properties.operandSegmentSizes = {\n          static_cast<int32_t>(valueInputs.size()),\n          static_cast<int32_t>(streamInputs.size()),\n          static_cast<int32_t>(memoryInputs.size()),\n          static_cast<int32_t>(streamOutputs.size())};\n      properties.resultSegmentSizes = {\n          static_cast<int32_t>(valueResultTypes.size()),\n          static_cast<int32_t>(memoryResultTypes.size())};\n      $_state.addRegion();\n    }]>\n  ];\n\n  let hasVerifier = 1;\n}\n\ndef Loom_SpatialYieldOp : Loom_Op<\"spatial_yield\", [\n    Terminator,\n    ParentOneOf<[\"::loom::SpatialRegionOp\"]>,\n    AttrSizedOperandSegments,\n    Pure\n]> {\n  let summary = \"Yield value and memory results from a spatial candidate\";\n\n  let arguments = (ins\n      Variadic<AnyType>:$values,\n      Variadic<AnyType>:$memories);\n\n  let skipDefaultBuilders = 1;\n  let builders = [\n    OpBuilder<(ins\n        \"::mlir::ValueRange\":$values,\n        \"::mlir::ValueRange\":$memories), [{\n      $_state.addOperands(values);\n      $_state.addOperands(memories);\n      auto &properties = $_state.getOrAddProperties<Properties>();\n      properties.operandSegmentSizes = {\n          static_cast<int32_t>(values.size()),\n          static_cast<int32_t>(memories.size())};\n    }]>\n  ];\n\n  let hasVerifier = 1;\n}","why":"Definition of loom.spatial_region and loom.spatial_yield: AttrSizedOperandSegments/AttrSizedResultSegments, the four operand segments, the AffineMapArrayAttr source_maps and optional graph_name, and the terminator's two operand segments; fixes the exact generic-form spelling emitted by the grammar."},{"file_sha256":"f4e60b2e62b496c3714437bd100ab5236540abebd3685dfbd25eeddb37cb7160","kind":"language_definition","lines":"614-620,767-773,839-845,973-979","path":"include/Dataflow/IR/DataflowOps.td","roles":["context"],"text":"def Dataflow_ThreadOp : Dataflow_Op<\"thread\", [\n    AutomaticAllocationScope,\n    IsolatedFromAbove,\n    HasParent<\"::mlir::ModuleOp\">,\n    SingleBlockImplicitTerminator<\"ThreadYieldOp\">,\n    FunctionOpInterface,\n    RecursiveMemoryEffects\ndef Dataflow_ThreadLaunchOp : Dataflow_Op<\"thread.launch\", [\n    AttrSizedOperandSegments,\n    DeclareOpInterfaceMethods<SymbolUserOpInterface>\n]> {\n  let summary = \"Async launch of a dataflow.thread callable\";\n  let description = [{\n    References a `dataflow.thread` definition by symbol and supplies\ndef Dataflow_GraphOp : Dataflow_Op<\"graph\", [\n    IsolatedFromAbove,\n    HasParent<\"::mlir::ModuleOp\">,\n    SingleBlockImplicitTerminator<\"GraphReturnOp\">,\n    FunctionOpInterface,\n    RecursiveMemoryEffects,\n    DeclareOpInterfaceMethods<RegionKindInterface>\ndef Dataflow_GraphLaunchOp : Dataflow_Op<\"graph.launch\", [\n    AttrSizedOperandSegments,\n    AttrSizedResultSegments,\n    DeclareOpInterfaceMethods<SymbolUserOpInterface>\n]> {\n  let summary = \"Asynchronous launch of a dataflow.graph callable\";\n  let description = [{","why":"Canonical op-name spellings dataflow.thread, dataflow.thread.launch, dataflow.graph and dataflow.graph.launch used verbatim in the generated thread definitions and in the postcondition's name tests."},{"file_sha256":"4295a7f0089a5b35f7f7f538032b31f51ca3966d4279faa030a2d493a8f76385","kind":"verifier","lines":"262-303","path":"lib/Frontend/Lowering/GraphRegionLowering.cpp","roles":["input_well_formedness"],"text":"}\n    if (::llvm::isa<::mlir::scf::SCFDialect>(op->getDialect()) &&\n        !::llvm::isa<::mlir::scf::IfOp, ::mlir::scf::ForOp,\n                     ::mlir::scf::WhileOp, ::mlir::scf::IndexSwitchOp,\n                     ::mlir::scf::ParallelOp, ::mlir::scf::ForallOp,\n                     ::mlir::scf::YieldOp, ::mlir::scf::ConditionOp,\n                     ::mlir::scf::ReduceOp, ::mlir::scf::InParallelOp>(op)) {\n      op->emitError(\"loom-lower-graph-memory: unsupported residual SCF \"\n                    \"must be normalized before graph-region lowering\");\n      return ::mlir::WalkResult::interrupt();\n    }\n    bool modeled =\n        ::loom::lowering::detail::isGraphRegionControlOperation(op) ||\n        ::loom::lowering::classifyGraphLoweringLeaf(op) !=\n            ::loom::lowering::GraphLeafLowering::Unsupported;\n    if (::llvm::isa<::dataflow::ChannelSendOp, ::dataflow::ChannelReceiveOp>(\n            op))\n      modeled = boundary.isTransient();\n    // A registered actor that no capability covers is reported for what it is,\n    // so an effectful memory actor is not mistaken for an unregistered one.\n    if (!modeled && ::dataflow::isCanonicalDataflowActor(op)) {\n      op->emitError() << \"loom-lower-graph-memory: canonical Dataflow actor '\"\n                      << op->getName().getStringRef()\n                      << \"' has no graph-region lowering\";\n      return ::mlir::WalkResult::interrupt();\n    }\n    if (!modeled && (op->getNumRegions() != 0 || op->getNumSuccessors() != 0)) {\n      op->emitError()\n          << \"loom-lower-graph-memory: effectful or unmodeled graph \"\n             \"operation '\"\n          << op->getName().getStringRef() << \"' is unsupported\";\n      return ::mlir::WalkResult::interrupt();\n    }\n    if (!modeled) {\n      op->emitError()\n          << \"loom-lower-graph-memory: operation '\"\n          << op->getName().getStringRef()\n          << \"' is not a registered canonical Dataflow actor or a supported \"\n             \"graph-lowering operation\";\n      return ::mlir::WalkResult::interrupt();\n    }\n    return ::mlir::WalkResult::advance();","why":"Acceptance rule for operations inside a candidate: only supported SCF control forms and registered canonical Dataflow actors or supported graph-lowering leaves survive. Determines which body ops (arith, memref.store, llvm.freeze, scf.if/scf.for) the grammar samples as publishable and which calls fail closed."},{"file_sha256":"7f380008fb405f6cf8d60d16d1b5980dc1d2e694f9842bcfeb6538fbcfa01099","kind":"implementation","lines":"1-12","path":"lib/Frontend/Lowering/Pipeline.cpp","roles":["applicability"],"text":"// Pipeline glue and pass-registry hooks for the SCF-to-DFG lowering\n// passes. The standard pipeline runs:\n//\n//     loom-lower-for-to-graph           (module-level)\n//\n// `loom-lower-for-to-graph` owns the atomic publication transaction. It\n// consumes explicit loom.spatial_region candidates, runs graph finalization\n// on a scratch module, validates the native result, and publishes only the\n// completed module. Graph memref-copy expansion is part of that finalization,\n// so a copy the current profile cannot expand fails the transaction instead of\n// reaching the published program.\n//","why":"loom-lower-for-to-graph owns the atomic publication transaction that consumes explicit loom.spatial_region candidates and publishes the completed module; evidence that this flag is the stage whose output the obligation constrains."},{"file_sha256":"05567d70fd335a83ee2f46b2d0a3025a903207a88602a798b1845033e7f8ef64","kind":"implementation","lines":"905-919","path":"lib/Frontend/Lowering/LowerForToGraphPass.cpp","roles":["applicability"],"text":"LowerForToGraphPass() = default;\n  LowerForToGraphPass(const LowerForToGraphPass &) : PassWrapper() {}\n\n  Statistic parallelCompletionCandidateInspections{\n      this, \"parallel-completion-candidate-inspections\",\n      \"Number of parallel completion candidates inspected for publication\"};\n\n  ::llvm::StringRef getArgument() const final {\n    return \"loom-lower-for-to-graph\";\n  }\n  ::llvm::StringRef getDescription() const final {\n    return \"Publish explicit loom.spatial_region operations as \"\n           \"dataflow.graph definitions plus dataflow.graph.launch ops.\";\n  }","why":"The pass argument string loom-lower-for-to-graph and its description (publish loom.spatial_region as dataflow.graph definitions plus dataflow.graph.launch ops) confirm the subject-command flag and the output population selected by the postcondition."},{"file_sha256":"c25a72ad99349973a47f2a1e081b6b269920e25cc5f59f74619c2e7ce0c2b65d","kind":"example","lines":"22-52","path":"test/raise/scf-to-dfg-explicit-spatial-ownership.mlir","roles":["input_construction"],"text":"func.func @host_container(%target: memref<4xi32>, %value: i32) {\n  %zero = arith.constant 0 : index\n  %four = arith.constant 4 : index\n  %one = arith.constant 1 : index\n  scf.for %index = %zero to %four step %one {\n    memref.store %value, %target[%index] : memref<4xi32>\n  }\n  return\n}\n\ndataflow.thread private @instruction_only domain(#dataflow.thread_domain<dense>)(\n    %target: memref<1xi32>, %value: i32) ctrl (%ctrl: none) {\n  %zero = arith.constant 0 : index\n  memref.store %value, %target[%zero] : memref<1xi32>\n  dataflow.thread.yield\n}\n\ndataflow.thread private @selected_spatial domain(#dataflow.thread_domain<dense>)(\n    %target: memref<1xi32>, %value: i32) ctrl (%ctrl: none) {\n  \"loom.spatial_region\"(%value, %target)\n      <{operandSegmentSizes = array<i32: 1, 0, 1, 0>,\n        resultSegmentSizes = array<i32: 0, 0>}> ({\n    ^bb0(%payload: i32, %memory: memref<1xi32>):\n      %zero = arith.constant 0 : index\n      memref.store %payload, %memory[%zero] : memref<1xi32>\n      \"loom.spatial_yield\"()\n          <{operandSegmentSizes = array<i32: 0, 0>}> : () -> ()\n  }) {graph_name = \"selected_graph\", source_maps = []} :\n      (i32, memref<1xi32>) -> ()\n  dataflow.thread.yield\n}","why":"Accepted spelling of a module with a host func.func, a dataflow.thread with dense domain and ctrl argument, and a value+memory loom.spatial_region candidate; used as the skeleton for the generated modules."},{"file_sha256":"fa58edd15b93582934f4f94945c053d793a5b1edefdfdcbadbd37e0be4e7dc6d","kind":"example","lines":"9-20","path":"test/raise/freeze-candidate-finalization.mlir","roles":["input_construction"],"text":"dataflow.thread private @selected_freeze domain(#dataflow.thread_domain<dense>)(%input: i32) ctrl (%start: none) {\n  %result = \"loom.spatial_region\"(%input)\n      <{operandSegmentSizes = array<i32: 1, 0, 0, 0>,\n        resultSegmentSizes = array<i32: 1, 0>}> ({\n    ^bb0(%value: i32):\n      %stable = llvm.freeze %value : i32\n      \"loom.spatial_yield\"(%stable)\n          <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n  }) {graph_name = \"selected_freeze_graph\", source_maps = []} :\n      (i32) -> i32\n  dataflow.thread.yield\n}","why":"Accepted spelling of a single-value-input candidate with one value result (llvm.freeze body); basis for the value-result region forms."},{"file_sha256":"df76d22d1149cf2929b700df6f97b58d27b64d523346cfbb4dbf9ba8e66baa49","kind":"example","lines":"60-78","path":"test/raise/scf-to-dfg-nested-completion.mlir","roles":["input_construction"],"text":"//--- supported.mlir\nmodule {\n  dataflow.thread private @for_completion domain(#dataflow.thread_domain<dense>)(%limit: index, %enabled: i1)\n      ctrl (%start: none) {\n    %c0 = arith.constant 0 : index\n    %c1 = arith.constant 1 : index\n    scf.for %i = %c0 to %limit step %c1 {\n      scf.if %enabled {\n        \"loom.spatial_region\"()\n            <{operandSegmentSizes = array<i32: 0, 0, 0, 0>,\n              resultSegmentSizes = array<i32: 0, 0>}> ({\n          ^bb0:\n            \"loom.spatial_yield\"()\n                <{operandSegmentSizes = array<i32: 0, 0>}> : () -> ()\n        }) {graph_name = \"for_graph\", source_maps = []} : () -> ()\n      }\n    }\n    dataflow.thread.yield\n  }","why":"Accepted spelling of a candidate site nested under scf.for and scf.if inside a thread whose input terminator is a bare dataflow.thread.yield; basis for the nesting variants."},{"file_sha256":"3a48482db91f758cf3933d286ceeda00d8a00c1457435fce086635a0ca918a3a","kind":"test","lines":"1-42","path":"test/raise/library-call-candidate-rejection.mlir","roles":["input_construction"],"text":"// RUN: not loom-raise-opt --loom-lower-for-to-graph --mlir-disable-threading --mlir-print-ir-after-failure --mlir-print-ir-module-scope %s 2>&1 | FileCheck %s --implicit-check-not=\"dataflow.graph private\" --implicit-check-not=dataflow.graph.launch\n\n// A library spelling and matching arity do not prove call semantics. The call\n// remains under the imported LLVM declaration and makes only the candidate\n// that selected it for SpatialCore non-finalizable.\n// CHECK: error: loom-lower-graph-memory: operation 'llvm.call' is not a registered canonical Dataflow actor or a supported graph-lowering operation\n// CHECK-LABEL: llvm.func @arm_nn_vec_mat_mult_t_s8\n// CHECK-LABEL: dataflow.thread private @selected_library_call domain(#dataflow.thread_domain<dense>)\n// CHECK: loom.spatial_region\n// CHECK: llvm.call @arm_nn_vec_mat_mult_t_s8\n\nllvm.func @arm_nn_vec_mat_mult_t_s8(i32, i32, i32, i32, i32, i32, i32,\n                                    i32, i32, i32, i32, i32, i32, i32,\n                                    i32) -> i32\n\ndataflow.thread private @selected_library_call domain(#dataflow.thread_domain<dense>)(\n    %arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32,\n    %arg5: i32, %arg6: i32, %arg7: i32, %arg8: i32, %arg9: i32,\n    %arg10: i32, %arg11: i32, %arg12: i32, %arg13: i32, %arg14: i32)\n    ctrl (%start: none) {\n  %status = \"loom.spatial_region\"(\n      %arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6, %arg7, %arg8,\n      %arg9, %arg10, %arg11, %arg12, %arg13, %arg14)\n      <{operandSegmentSizes = array<i32: 15, 0, 0, 0>,\n        resultSegmentSizes = array<i32: 1, 0>}> ({\n    ^bb0(%value0: i32, %value1: i32, %value2: i32, %value3: i32,\n         %value4: i32, %value5: i32, %value6: i32, %value7: i32,\n         %value8: i32, %value9: i32, %value10: i32, %value11: i32,\n         %value12: i32, %value13: i32, %value14: i32):\n      %result = llvm.call @arm_nn_vec_mat_mult_t_s8(\n          %value0, %value1, %value2, %value3, %value4, %value5, %value6,\n          %value7, %value8, %value9, %value10, %value11, %value12,\n          %value13, %value14)\n          : (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,\n             i32, i32, i32, i32) -> i32\n      \"loom.spatial_yield\"(%result)\n          <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n  }) {graph_name = \"selected_library_call_graph\", source_maps = []} :\n      (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,\n       i32, i32, i32) -> i32\n  dataflow.thread.yield\n}","why":"Evidence that a call selected into a candidate makes the publication transaction fail closed rather than publishing a graph containing the call; supports sampling those adversarial forms at a low rate as direct falsification attempts for the obligation."}],"primary_bundle_sha256":"e5045156ba6a108940f1e743febf4bd26c9d4ddf6c59857d83f7f0c30b3798e1","project":"PolyArch/loom","revision":"48615bc5925ef4b9db8b4550b5d4322933cf4b7b","schema":"spectriad.authoring-context/v1","selection_sha256":"239f291d7a3a7fbe0ba28026177beb1ab089ca6189bb4fde208e11bfe6c6892d"}

generator source-blind backtranslation · sessions/reverse-generator/session-evidence/result-events.json

[
  {
    "api_error_status": null,
    "duration_api_ms": 45196,
    "duration_ms": 45258,
    "fast_mode_disabled_reason": "sdk_opt_in_required",
    "fast_mode_state": "off",
    "first_content_frame_ms": 1480,
    "is_error": false,
    "modelUsage": {
      "claude-opus-5": {
        "cacheCreationInputTokens": 6504,
        "cacheReadInputTokens": 0,
        "canonicalModel": "claude-opus-5",
        "contextWindow": 1000000,
        "costBasis": "list",
        "costUSD": 0.1525,
        "inputTokens": 2,
        "maxOutputTokens": 64000,
        "outputTokens": 3498,
        "provider": "firstParty",
        "thinkingTokens": 273,
        "webSearchRequests": 0
      }
    },
    "num_turns": 1,
    "permission_denials": [],
    "queued_turn_count": 0,
    "result": "## Preconditions\n\n1. Every emitted program is a single top-level `module { ... }` whose body contains, in this order, a `func.func` definition, an `llvm.func` declaration, a `func.func` host function, and one or more `dataflow.thread` definitions.\n2. Every program defines `func.func @helper_double(%a: i32) -> i32` whose body is `arith.addi %a, %a : i32` followed by `return`, i.e. a callee containing no graph or region construct.\n3. Every program declares the external symbol `llvm.func @extern_scale(i32) -> i32` with no body.\n4. Every program defines `func.func @host_container(%target: memref<4xi32>, %value: i32)` containing three `arith.constant ... : index` values (0, 4, 1), an `scf.for` over them whose body is a single `memref.store %value, %target[%hi] : memref<4xi32>`, and a bare `return`; this function contains no `loom.spatial_region`.\n5. Every `dataflow.thread` is declared `private`, carries `domain(#dataflow.thread_domain<dense>)`, takes exactly the argument list `(%mem: memref<4xi32>, %val: i32, %flag: i1)`, and has a control operand list `ctrl (%start: none)`.\n6. Every thread body begins with exactly three index constants bound to `%lo` = 0, `%hi` = 2, `%stp` = 1, before any other operation.\n7. Every thread body ends with `dataflow.thread.yield` as its terminator.\n8. Every thread body contains at least one `loom.spatial_region` operation.\n9. Every `loom.spatial_region` appears inside a `dataflow.thread` body, either directly at the thread's top level or nested exactly one level inside a structured `scf.if` or `scf.for` of that thread; regions are never nested inside one another and never appear in `func.func` or `llvm.func` bodies.\n10. Any `scf.if` wrapping a region is predicated on the thread argument `%flag` of type `i1` and has no results and no `else` branch; any `scf.for` wrapping a region iterates from `%lo` to `%hi` step `%stp` using the thread-level index constants and carries no iteration arguments.\n11. Every `loom.spatial_region` is written in generic operation form with a `<{operandSegmentSizes = array<i32: ...>, resultSegmentSizes = array<i32: ...>}>` properties dictionary, a single entry block region, and a trailing discardable attribute dictionary.\n12. The `operandSegmentSizes` array of each region has exactly four entries and the `resultSegmentSizes` array exactly two entries, and both sum-match the actual operand list and result list of the region's functional type signature.\n13. Every region's entry block `^bb0` has one block argument per region operand, with matching types, and those block arguments are the only values flowing into the region body from outside.\n14. Every region body is terminated by a `\"loom.spatial_yield\"` operation in generic form with its own two-entry `operandSegmentSizes` array, whose operand count and types match the region's result count and types.\n15. Region operands are drawn only from the enclosing thread's own arguments (`%val` of type `i32`, `%mem` of type `memref<4xi32>`, `%flag` of type `i1`), never from values defined earlier in the thread body or from another region's results.\n16. Every `loom.spatial_region` carries exactly the two discardable attributes `graph_name` (a string) and `source_maps` (an empty array), and the `graph_name` value is unique across the whole module.\n17. Region results, when present, are bound to SSA names that are unique across the whole module.\n18. Regions that yield no value produce no SSA result and are written as a bare operation of type `... -> ()`.\n19. Any memory access inside a region body addresses only a `memref<4xi32>` passed in as a region operand, indexed by a constant defined inside that region body, never by an index constant defined in the enclosing thread.\n20. Calls occurring inside a region body target only symbols declared at module scope (`@helper_double` via `func.call`, `@extern_scale` via `llvm.call`), and the same is true of any call placed in a thread body outside a region.\n21. A `func.call` to `@helper_double` may appear directly in a thread body, positioned after the thread's index constants and before the first region site.\n22. Control flow inside a region body is limited to structured `scf.if` with both branches and `scf.yield`, or `scf.for` with `iter_args` and `scf.yield`; no unstructured branches, no multi-block regions beyond `^bb0` plus structured nesting.\n23. All integer values in the program are `i32` except the predicate `%flag`/`%c`, which is `i1`, and all loop bounds and memref indices, which are `index`.\n24. Thread symbol names, graph names and region result names are correlated: no two threads share a symbol name and no two regions share either a graph name or a result name.\n\n## Sampling conventions\n\n1. The number of `dataflow.thread` definitions is exactly 1 or 2.\n2. Threads are named `@thread_0` and, if present, `@thread_1`, using a counter starting at 0 and incremented per thread.\n3. Each thread contains exactly 1 or 2 region sites, chosen independently per thread, so a module holds between 1 and 4 regions in total.\n4. A single module-wide counter starting at 0 numbers the regions in emission order, producing result names `%r0, %r1, ...` and graph names `\"graph_0\", \"graph_1\", ...\"`; the counter is shared across threads rather than reset per thread.\n5. The counter is incremented once per region site, including for the value-less memory form that emits no `%r` name, so graph-name indices may skip values used by no SSA result.\n6. Whether a thread contains the top-level `func.call @helper_double(%val)` is an independent binary choice per thread; when present it is emitted exactly once, bound to `%icall`, and its result is never used.\n7. The nesting of each site is chosen from exactly three options \u2014 no nesting, an `scf.if %flag` wrapper, or an `scf.for` wrapper \u2014 with the un-nested form sampled at twice the weight of each wrapper.\n8. Each site's region contents are chosen from exactly six fixed bodies: pure arithmetic value-in/value-out, value-plus-memref store with no result, internal `scf.if` selection, `llvm.freeze`, internal `scf.for` with `iter_args`, and an in-region call; the first five are sampled at twice the weight of the call form.\n9. The in-region call form further chooses uniformly between `func.call @helper_double` and `llvm.call @extern_scale`.\n10. The arithmetic body is fixed as `%s = arith.addi %a, %a` then `%p = arith.muli %s, %a`, yielding `%p`.\n11. The memory body is fixed as a zero `index` constant followed by `memref.store %payload, %memory[%z]`, yielding nothing, and it is the only form whose `operandSegmentSizes` is `array<i32: 1, 0, 1, 0>` and `resultSegmentSizes` is `array<i32: 0, 0>`.\n12. The branch body is fixed as `scf.if %c -> (i32)` with `arith.addi %a, %a` in the then branch and `arith.muli %a, %a` in the else branch; it is the only form taking `%flag` as a region operand and the only one with `operandSegmentSizes = array<i32: 2, 0, 0, 0>`.\n13. The loop body is fixed with constants 0, 2, 1 and a single `arith.addi %carry, %a` accumulation, yielding the loop result.\n14. All value-producing forms use the operand segment layout `array<i32: 1, 0, 0, 0>` and result segment layout `array<i32: 1, 0>`, and never exercise the second, third or fourth operand segments beyond the memory and branch cases above.\n15. `source_maps` is always emitted as the literal empty list `[]`; no non-empty source map is ever generated.\n16. The helper preamble is a constant: exactly one `func.func` callee and one `llvm.func` declaration, both fixed in name, arity and body, regardless of whether any emitted region or thread actually calls them.\n17. The `@host_container` function is a constant preamble with fixed argument names and bounds 0/4/1, and it is emitted exactly once even though nothing calls it.\n18. Memref types are fixed at `memref<4xi32>` and thread-level loop trip counts at 2 (`%lo`=0, `%hi`=2, `%stp`=1) everywhere; no other shape, element type, or bound is ever emitted.\n19. Region-internal SSA names are reused verbatim across regions in distinct scopes (`%a`, `%s`, `%p`, `%z`, `%sel`, `%acc`, `%called`, `%stable`), and wrapper induction variables are always `%iv` inside a thread and `%i` inside a region loop.\n20. Indentation is fixed: thread-level operations at two spaces, wrapped operations and region headers at four, region bodies at six or more; each thread definition is followed by a blank line.\n21. No thread ever emits zero sites, and no program ever emits a region outside a thread, so the empty-thread and host-side-region shapes are never exercised.\n22. Nesting depth is capped at one wrapper level per site; `scf.if` inside `scf.for` or any deeper nesting of sites is never emitted.\n23. No `dataflow.thread` uses a domain other than `dense`, no non-`private` visibility is emitted, and the `ctrl` list always has exactly one `none`-typed operand.",
    "result_index": 0,
    "session_id": "6d6f6fb0-ea77-4120-89f5-2927c8443a0f",
    "stop_reason": "end_turn",
    "subagent_stats": {
      "by_type": {},
      "completed": 0,
      "failed": 0,
      "killed": {
        "parent": 0,
        "system": 0,
        "user": 0
      },
      "max_depth": 0,
      "refused": {
        "budget": 0,
        "concurrency_limit": 0,
        "depth_limit": 0
      },
      "requested": {
        "background": 0,
        "foreground": 0,
        "unset": 0
      },
      "spawned": 0,
      "spawned_by_subagents": 0,
      "started_in_background": 0
    },
    "subtype": "success",
    "terminal_reason": "completed",
    "time_to_request_ms": 62,
    "total_cost_usd": 0.1525,
    "ttft_ms": 4699,
    "ttft_stream_ms": 949,
    "type": "result",
    "usage": {
      "cache_creation": {
        "ephemeral_1h_input_tokens": 6504,
        "ephemeral_5m_input_tokens": 0
      },
      "cache_creation_input_tokens": 6504,
      "cache_read_input_tokens": 0,
      "inference_geo": "not_available",
      "input_tokens": 2,
      "iterations": [],
      "output_tokens": 3498,
      "output_tokens_details": {
        "thinking_tokens": 273
      },
      "server_tool_use": {
        "web_fetch_requests": 0,
        "web_search_requests": 0
      },
      "service_tier": "standard",
      "speed": "standard"
    },
    "uuid": "3b089a98-3054-4240-953a-c975465908aa"
  }
]

postcondition source-blind backtranslation · sessions/reverse-postcondition/session-evidence/result-events.json

[
  {
    "api_error_status": null,
    "duration_api_ms": 10803,
    "duration_ms": 10830,
    "fast_mode_disabled_reason": "sdk_opt_in_required",
    "fast_mode_state": "off",
    "first_content_frame_ms": 1573,
    "is_error": false,
    "modelUsage": {
      "claude-opus-5": {
        "cacheCreationInputTokens": 5538,
        "cacheReadInputTokens": 0,
        "canonicalModel": "claude-opus-5",
        "contextWindow": 1000000,
        "costBasis": "list",
        "costUSD": 0.073765,
        "inputTokens": 2,
        "maxOutputTokens": 64000,
        "outputTokens": 735,
        "provider": "firstParty",
        "thinkingTokens": 154,
        "webSearchRequests": 0
      }
    },
    "num_turns": 1,
    "permission_denials": [],
    "queued_turn_count": 0,
    "result": "This postcondition selects, from the subject's output program only, every operation named `dataflow.graph` at any nesting depth, since `output.operations` enumerates the whole program in pre-order; the `input` program is never consulted, and no attributes, types, operands, results, or symbol references are examined \u2014 the only value source is each operation's `name` string compared against fixed literals. For each selected graph it universally quantifies over `mlir::descendants(g)`, the transitive set of operations strictly inside that graph (the graph op itself is excluded), and asserts six separate `none ... where` conditions over that same descendant set. It rejects a graph whose body transitively contains any operation named `func.func`, `llvm.func`, `dataflow.thread`, or `dataflow.graph` (the first assert), or named `llvm.call`, `func.call`, `dataflow.thread.launch`, `dataflow.graph.launch`, or again `dataflow.graph` (the remaining asserts); a nested `dataflow.graph` therefore trips two asserts, and the sixth assert is subsumed by the first. It accepts any graph whose descendants carry none of those nine names, regardless of what other operations, regions, or blocks appear there, and regardless of how deeply they nest. A graph with an empty body, or with no regions at all, passes every assert, because each `none` quantifier is vacuously true over an empty descendant sequence. If the output program contains no operation named `dataflow.graph`, the enclosing `forall` ranges over an empty sequence and the entire postcondition holds vacuously. Non-vacuous checking occurs exactly when at least one `dataflow.graph` operation exists and has at least one descendant; failure is reported per-graph, per-assert, with the offending descendant operation as the witness.",
    "result_index": 0,
    "session_id": "8cc0758c-2576-418c-a715-d152f7a25e8d",
    "stop_reason": "end_turn",
    "subagent_stats": {
      "by_type": {},
      "completed": 0,
      "failed": 0,
      "killed": {
        "parent": 0,
        "system": 0,
        "user": 0
      },
      "max_depth": 0,
      "refused": {
        "budget": 0,
        "concurrency_limit": 0,
        "depth_limit": 0
      },
      "requested": {
        "background": 0,
        "foreground": 0,
        "unset": 0
      },
      "spawned": 0,
      "spawned_by_subagents": 0,
      "started_in_background": 0
    },
    "subtype": "success",
    "terminal_reason": "completed",
    "time_to_request_ms": 27,
    "total_cost_usd": 0.073765,
    "ttft_ms": 3523,
    "ttft_stream_ms": 1100,
    "type": "result",
    "usage": {
      "cache_creation": {
        "ephemeral_1h_input_tokens": 5538,
        "ephemeral_5m_input_tokens": 0
      },
      "cache_creation_input_tokens": 5538,
      "cache_read_input_tokens": 0,
      "inference_geo": "not_available",
      "input_tokens": 2,
      "iterations": [],
      "output_tokens": 735,
      "output_tokens_details": {
        "thinking_tokens": 154
      },
      "server_tool_use": {
        "web_fetch_requests": 0,
        "web_search_requests": 0
      },
      "service_tier": "standard",
      "speed": "standard"
    },
    "uuid": "17402c3b-9348-4659-b1a2-e1fc0356c633"
  }
]

Activation review

This paired revision was activated by an explicit partial-scope team review bound to both executable artifact hashes.

Approved to run and display existing artifacts; accuracy and completeness are measured separately.

Run and triage

Work progress