sparsetensor dialect generating deallocs at end of function than end of current region

[vmiheer]

input.mlir

#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d2)>
#csrv = #sparse_tensor.encoding<{ map = (d0, d1, d2) ->
    (d0 : dense, d1 : compressed, d2 : dense) }>
#dense1d = #sparse_tensor.encoding<{ map = (d0) ->
    (d0 : dense) }>
#dense = #sparse_tensor.encoding<{ map = (d0, d1) ->
    (d0 : dense, d1 : dense) }>
#densev = #sparse_tensor.encoding<{ map = (d0, d1, d2) ->
    (d0 : dense, d1 : dense, d2 : dense) }>
#csr = #sparse_tensor.encoding<{ map = (d0, d1) ->
    (d0 : dense, d1 : compressed) }>
#partCsr = #part_tensor.encoding<{
  partConst = 1,
  sparseAttributes = #csr
}>
#partDense = #part_tensor.encoding<{
  partConst = 1,
  sparseAttributes = #dense
}>
#partDensev = #part_tensor.encoding<{
  partConst = 1,
  sparseAttributes = #densev
}>
#input_proj_map = {
  indexing_maps = [
    affine_map<(n, f, dh, nh) -> (n, f)>,  // X (in)
    affine_map<(n, f, dh, nh) -> (dh, nh, f)>,  // Q_Proj (in)
    affine_map<(n, f, dh, nh) -> (n, dh, nh)>  // Q (out)
  ],
  iterator_types = ["parallel", "reduction", "parallel", "parallel"]
}
#output_proj_map = {
  indexing_maps = [
    affine_map<(n, f, dh, nh) -> (n, dh, nh)>,  // Attn (in)
    affine_map<(n, f, dh, nh) -> (dh, nh, f)>,  // O_Proj (in)
    affine_map<(n, f, dh, nh) -> (n, f)>  // O (out)
  ],
  iterator_types = ["parallel", "parallel", "reduction", "reduction"]
}
#bsddmm_map = {
  indexing_maps = [
    affine_map<(n1, n2, dh, nh) -> (n1, dh, nh)>,  // q (in)
    affine_map<(n1, n2, dh, nh) -> (n2, dh, nh)>,  // k (in)
    affine_map<(n1, n2, dh, nh) -> (n1, n2)>,  // A (in)
    affine_map<(n1, n2, dh, nh) -> (n1, n2, nh)>   // attn (out)
  ],
  iterator_types = ["parallel", "parallel", "reduction", "parallel"],
  doc = "attn(n1, n2, nh) = q(n1, dh, nh) * k(n2, dh, nh)"
}
#bspmm_map = {
  indexing_maps = [
    affine_map<(n1, n2, dh, nh) -> (n1, n2, nh)>,  // attn (in)
    affine_map<(n1, n2, dh, nh) -> (n2, dh, nh)>,  // v (in)
    affine_map<(n1, n2, dh, nh) -> (n1, dh, nh)>   // out (out)
  ],
  iterator_types = ["parallel", "parallel", "reduction", "parallel"],
  doc = "out(n1, dh, nh) = attn(n1, n2, nh) * v(n2, dh, nh)"
}

module {
  func.func private @mpi_getRank() -> index attributes {llvm.emit_c_interface}

  func.func @pte_sparse_mha(%A: tensor<?x?xf32, #partCsr>,
    %X: tensor<?x?xf32, #partDense>,
    %Q_proj: tensor<?x?x?xf32, #densev>, %K_proj: tensor<?x?x?xf32, #densev>,
    %V_proj: tensor<?x?x?xf32, #densev>, %O_proj: tensor<?x?x?xf32, #densev>,
    %N: index, %Dh: index, %Nh: index, %Nf: index, %Tn: index)
      // ->  tensor<?x?xf32>
      ->  tensor<?x?xf32, #dense>
  {
    %c0_index = arith.constant 0 : index
    %c1_index = arith.constant 1 : index
    %c2_index = arith.constant 2 : index
    %c3_index = arith.constant 3 : index
    %c4_index = arith.constant 4 : index
    %c5_index = arith.constant 5 : index
    %c6_index = arith.constant 6 : index

    %a_partition_plan = part_tensor.get_partitions %A:
      tensor<?x?xf32, #partCsr> -> memref<?xindex>
    %mrank = call @mpi_getRank() : () -> index
    %a_pspec = memref.alloc(%c4_index) : memref<?xindex>
    %pspec_start0 = arith.muli %mrank, %c4_index : index
    %el00 = memref.load %a_partition_plan[%pspec_start0] : memref<?xindex>
    %pspec_start1 = arith.addi %pspec_start0, %c1_index : index
    %el10 = memref.load %a_partition_plan[%pspec_start1] : memref<?xindex>
    %pspec_start2 = arith.addi %pspec_start0, %c2_index : index
    %el20 = memref.load %a_partition_plan[%pspec_start2] : memref<?xindex>
    %pspec_start3 = arith.addi %pspec_start0, %c3_index : index
    %el30 = memref.load %a_partition_plan[%pspec_start3] : memref<?xindex>
    memref.store %el00, %a_pspec[%c0_index] : memref<?xindex> // n1_low
    memref.store %el10, %a_pspec[%c1_index] : memref<?xindex> // n2_low
    memref.store %el20, %a_pspec[%c2_index] : memref<?xindex> // n1_high
    memref.store %el30, %a_pspec[%c3_index] : memref<?xindex> // n2_high

    // get aslice just to get dims
    %A0_slice = part_tensor.get_slice %A, %a_pspec:
      tensor<?x?xf32, #partCsr>, memref<?xindex> -> tensor<?x?xf32, #csr>
    %lN10 = tensor.dim %A0_slice, %c0_index : tensor<?x?xf32, #csr>
    %O0 = tensor.empty(%lN10, %Nf) : tensor<?x?xf32>
    %c0_f32 = arith.constant 0.0 : f32
    %O4 = linalg.fill ins(%c0_f32: f32) outs(%O0 : tensor<?x?xf32>)
      -> tensor<?x?xf32>
    %O5 = bufferization.materialize_in_destination  %O4 in %O0 : (tensor<?x?xf32>,
      tensor<?x?xf32>) -> tensor<?x?xf32>

    %O2 = scf.for %iv = %c0_index to %N step %Tn
        iter_args(%O1 = %O5) -> (tensor<?x?xf32>) {
      memref.store %iv,      %a_pspec[%c1_index] : memref<?xindex> // n2_low
      %iv_next = arith.addi %iv, %Tn : index
      memref.store %iv_next, %a_pspec[%c3_index] : memref<?xindex> // n2_high
      %A_slice = part_tensor.get_slice %A, %a_pspec:
        tensor<?x?xf32, #partCsr>, memref<?xindex> -> tensor<?x?xf32, #csr>
      %a_am_0 = part_tensor.get_active_mask %A, %a_pspec, %c0_index:
        tensor<?x?xf32, #partCsr>, memref<?xindex> -> index
      %a_am_1 = part_tensor.get_active_mask %A, %a_pspec, %c1_index:
        tensor<?x?xf32, #partCsr>, memref<?xindex> -> index

      %el0 = memref.load %a_pspec[%c0_index] : memref<?xindex>
      %el1 = memref.load %a_pspec[%c1_index] : memref<?xindex>
      %el2 = memref.load %a_pspec[%c2_index] : memref<?xindex>
      %el3 = memref.load %a_pspec[%c3_index] : memref<?xindex>
      %Q_pspec = memref.alloc(%c4_index) : memref<?xindex>
      memref.store %el0, %Q_pspec[%c0_index] : memref<?xindex> // n1_low
      memref.store %c0_index, %Q_pspec[%c1_index] : memref<?xindex> // nf_low
      memref.store %el2, %Q_pspec[%c2_index] : memref<?xindex> // n1_high
      memref.store %Nf, %Q_pspec[%c3_index] : memref<?xindex> // nf_high
      %K_pspec = memref.alloc(%c4_index) : memref<?xindex>
      memref.store %el1, %K_pspec[%c0_index] : memref<?xindex> // n2_low
      memref.store %c0_index, %K_pspec[%c1_index] : memref<?xindex> // nf_low
      memref.store %el3, %K_pspec[%c2_index] : memref<?xindex> // n2_high
      memref.store %Nf, %K_pspec[%c3_index] : memref<?xindex> // nf_high

      %XforQ_slice = part_tensor.get_slice %X, %Q_pspec:
        tensor<?x?xf32, #partDense>, memref<?xindex> ->
          tensor<?x?xf32, #dense>
      %XforK_slice = part_tensor.get_slice_for_active_mask %X, %K_pspec,
          %a_am_1, %c0_index:
        tensor<?x?xf32, #partDense>, memref<?xindex>, index, index ->
          tensor<?x?xf32, #dense>
      %lN1 = tensor.dim %A_slice, %c0_index : tensor<?x?xf32, #csr>
      %lN2 = tensor.dim %A_slice, %c1_index : tensor<?x?xf32, #csr>
      %Q0 = tensor.empty(%lN1, %Dh, %Nh) : tensor<?x?x?xf32, #densev>
      %Q_slice = linalg.generic #input_proj_map ins(%XforQ_slice, %Q_proj
          : tensor<?x?xf32, #dense>, tensor<?x?x?xf32, #densev>)
        outs(%Q0: tensor<?x?x?xf32, #densev>) {
        ^bb0(%x: f32, %q: f32, %a: f32):  // no predecessors
          %0 = arith.mulf %x, %q : f32
          %1 = arith.addf %0, %a : f32
          linalg.yield %1 : f32
      } -> tensor<?x?x?xf32, #densev>
      %K0 = tensor.empty(%lN2, %Dh, %Nh) : tensor<?x?x?xf32, #densev>
      %K_slice = linalg.generic #input_proj_map ins(%XforK_slice, %K_proj
          : tensor<?x?xf32, #dense>, tensor<?x?x?xf32, #densev>)
        outs(%K0: tensor<?x?x?xf32, #densev>) {
        ^bb0(%x: f32, %q: f32, %a: f32):  // no predecessors
          %0 = arith.mulf %x, %q : f32
          %1 = arith.addf %0, %a : f32
          linalg.yield %1 : f32
      } -> tensor<?x?x?xf32, #densev>
      %attn0 = tensor.empty (%lN1, %lN2, %Nh) : tensor<?x?x?xf32, #csrv>
      %attn2 = linalg.generic #bsddmm_map
        ins(%Q_slice, %K_slice, %A_slice: tensor<?x?x?xf32, #densev>,
          tensor<?x?x?xf32, #densev>, tensor<?x?xf32, #csr>)
        outs(%attn0: tensor<?x?x?xf32, #csrv>) {
        ^bb0(%q: f32, %k: f32, %mask: f32, %attn: f32):  // no predecessors
          %0 = arith.mulf %q, %k : f32
          %1 = arith.mulf %0, %mask : f32
          %2 = arith.addf %1, %attn: f32
          linalg.yield %2 : f32
      } -> tensor<?x?x?xf32, #csrv>

      // attn = attn.softmax()  # (sparse) [N, N, nh]
      %sc0 = arith.constant 0 : index
      %sc1 = arith.constant 1 : index
      %sc1_i8 = arith.constant 1 : i8
      %sc2 = arith.constant 2 : index
      %scst = arith.constant 0.000000e+00 : f32
      %sdim = tensor.dim %attn2, %sc0 : tensor<?x?x?xf32, #csrv>
      %sdim_0 = tensor.dim %attn2, %sc1 : tensor<?x?x?xf32, #csrv>
      %sdim_1 = tensor.dim %attn2, %sc2 : tensor<?x?x?xf32, #csrv>
      %s0 = tensor.empty(%sdim, %sdim_0, %sdim_1) : tensor<?x?x?xf32, #csrv>
      %sc0_2 = arith.constant 0 : index
      %sdim_3 = tensor.dim %attn2, %sc0_2 : tensor<?x?x?xf32, #csrv>
      %sc1_4 = arith.constant 1 : index
      %sdim_5 = tensor.dim %attn2, %sc1_4 : tensor<?x?x?xf32, #csrv>
      %sc2_6 = arith.constant 2 : index
      %sdim_7 = tensor.dim %attn2, %sc2_6 : tensor<?x?x?xf32, #csrv>
      %s11 = tensor.empty(%sdim_3, %sdim_7) : tensor<?x?xf32>
      %sminus_inf = arith.constant -3.40282347E+38 : f32

      %s21 = linalg.fill ins(%sminus_inf : f32) outs(%s11 : tensor<?x?xf32>)
        -> tensor<?x?xf32>
      %s31 = linalg.generic {indexing_maps = [#map, #map1],
        iterator_types = ["parallel", "reduction", "parallel"]}
        ins(%attn2 : tensor<?x?x?xf32, #csrv>) outs(%s21 : tensor<?x?xf32>) {
          ^bb0(%sin: f32, %sout: f32):
            %sres = sparse_tensor.reduce %sin, %sout, %sminus_inf : f32 {
              ^bb0(%sx0: f32, %sx1: f32):
                %s00 = arith.maxnumf %sx0, %sx1 : f32
                sparse_tensor.yield %s00: f32
            }
            linalg.yield %sres : f32
      } -> tensor<?x?xf32>
      %s3 = linalg.generic {indexing_maps = [#map, #map],
        iterator_types = ["parallel", "parallel", "parallel"]}
        ins(%attn2 : tensor<?x?x?xf32, #csrv>)
        outs(%attn2 : tensor<?x?x?xf32, #csrv>) {
          ^bb0(%sin: f32, %sout: f32):
            %sx = linalg.index 0: index
            %sz = linalg.index 2: index
            %sresult = sparse_tensor.unary %sin : f32 to f32
            present={
            ^bb0(%sin1: f32):
              %smaxel = tensor.extract %s31[%sx, %sz]: tensor<?x?xf32>
              %s8 = arith.subf %sin1, %smaxel : f32
              %sret = math.exp %s8 : f32
              sparse_tensor.yield %sret : f32
            }
            absent={}
            linalg.yield %sresult : f32
      } -> tensor<?x?x?xf32, #csrv>
      %s1 = tensor.empty(%sdim_3, %sdim_7) : tensor<?x?xf32>
      %scst_8 = arith.constant 0. : f32
      %s2 = linalg.fill ins(%scst_8 : f32) outs(%s1 : tensor<?x?xf32>)
        -> tensor<?x?xf32>
      %s4 = linalg.generic {indexing_maps = [#map, #map1],
        iterator_types = ["parallel", "reduction", "parallel"]}
        ins(%s3 : tensor<?x?x?xf32, #csrv>) outs(%s2 : tensor<?x?xf32>) {
          ^bb0(%sin: f32, %sout: f32):
            %sres = sparse_tensor.reduce %sin, %sout, %scst_8 : f32 {
              ^bb0(%sx0: f32, %sx1: f32):
                %s00 = arith.addf %sx0, %sx1 : f32
                sparse_tensor.yield %s00: f32
            }
            linalg.yield %sres : f32
      } -> tensor<?x?xf32>
      %attn31  = linalg.generic {indexing_maps = [#map],
        iterator_types = ["parallel", "parallel", "parallel"]}
        outs(%s3: tensor<?x?x?xf32, #csrv>) {
          ^bb0(%sin: f32):
            %sx = linalg.index 0: index
            %sz = linalg.index 2: index
            %sresult = sparse_tensor.unary %sin : f32 to f32
            present={
            ^bb0(%sin1: f32):
              %sdenom = tensor.extract %s4[%sx, %sz]: tensor<?x?xf32>
              %sret = arith.divf %sin1, %sdenom : f32
              sparse_tensor.yield %sret : f32
            }
            absent={}
            linalg.yield %sresult : f32
      } -> tensor<?x?x?xf32, #csrv>
      %V0 = tensor.empty(%lN2, %Dh, %Nh) : tensor<?x?x?xf32, #densev>
      %V_slice = linalg.generic #input_proj_map ins(%XforK_slice, %V_proj
          : tensor<?x?xf32, #dense>, tensor<?x?x?xf32, #densev>)
        outs(%V0: tensor<?x?x?xf32, #densev>) {
        ^bb0(%x: f32, %q: f32, %a: f32):  // no predecessors
          %0 = arith.mulf %x, %q : f32
          %1 = arith.addf %0, %a : f32
          linalg.yield %1 : f32
      } -> tensor<?x?x?xf32, #densev>
      // out = dglsp.bspmm(attn, v)  # [N, dh, nh]
      %spmm_in0 = tensor.empty (%lN1, %Dh, %Nh) : tensor<?x?x?xf32, #densev>
      %spmm_in1 = linalg.fill ins(%c0_f32: f32) outs(%spmm_in0 : tensor<?x?x?xf32, #densev>)
        -> tensor<?x?x?xf32, #densev>
      %attn32 = sparse_tensor.load %attn31 hasInserts : tensor<?x?x?xf32, #csrv>
      %attn4 = linalg.generic #bspmm_map
        ins(%attn32, %V_slice: tensor<?x?x?xf32, #csrv>, tensor<?x?x?xf32, #densev>)
        outs(%spmm_in1: tensor<?x?x?xf32, #densev>) {
        ^bb0(%q: f32, %k: f32, %attn: f32):  // no predecessors
          %0 = arith.mulf %q, %k : f32
          %1 = arith.addf %0, %attn: f32
          linalg.yield %1 : f32
      } -> tensor<?x?x?xf32, #densev>
      // %O0 = tensor.empty(%lN1, %Nf) : tensor<?x?xf32, #dense>
      %O = linalg.generic #output_proj_map ins(%attn4, %O_proj: tensor<?x?x?xf32, #densev>,
      tensor<?x?x?xf32, #densev>)
        outs(%O1: tensor<?x?xf32>) {
        ^bb0(%x: f32, %q: f32, %a: f32):  // no predecessors
          %0 = arith.mulf %x, %q : f32
          %1 = arith.addf %0, %a : f32
          linalg.yield %1 : f32
      } -> tensor<?x?xf32>
      // %O11 = bufferization.materialize_in_destination %O in %O1 : (tensor<?x?xf32>,
      //   tensor<?x?xf32>) -> tensor<?x?xf32>
      // return %attn4 : tensor<?x?x?xf32, #densev>
      // scf.yield %O : tensor<?x?xf32>

      scf.yield %O : tensor<?x?xf32>
    }
    %O3 = tensor.cast %O2 : tensor<?x?xf32> to tensor<?x?xf32, #dense>
    return %O3 : tensor<?x?xf32, #dense>
    // return %O2 : tensor<?x?xf32>
  }
}
                                          

// Local Variables:
// rmsbolt-command: "lapis-opt --sparse-compiler-kokkos='pt-backend=mpi'"
// rmsbolt-automatic-recompile: on-save
// End:                                   

Compiling above mlir causes error:

../sparseMHA.3.dist.mlir:163:16: error: operand #0 does not dominate this use
      %attn2 = linalg.generic #bsddmm_map
               ^
../sparseMHA.3.dist.mlir:163:16: note: see current operation: "memref.dealloc"(%212) : (memref<?xf32>) -> ()
../sparseMHA.3.dist.mlir:163:16: note: operand defined here (op in a child region)

[vmiheer]

Failed0.mlir is the last dumped mlir in the pipeline.

failed0.mlir

#map = affine_map<(d0, d1) -> (d0, d1)>
"builtin.module"() ({
  "func.func"() <{function_type = (!llvm.ptr, memref<?xindex>, memref<f32>) -> (), sym_name = "lexInsertF32", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr) -> (), sym_name = "endLexInsert", sym_visibility = "private"}> ({
  }) : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, memref<?xindex>, memref<?xf32>, memref<?xi1>, memref<?xindex>, index) -> (), sym_name = "expInsertF32", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, index) -> memref<?xindex>, sym_name = "sparseCoordinates0", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, index) -> memref<?xindex>, sym_name = "sparsePositions0", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr, sym_name = "newSparseTensor", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr) -> memref<?xf32>, sym_name = "sparseValuesF32", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, index) -> index, sym_name = "sparseLvlSize", sym_visibility = "private"}> ({
  }) : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, memref<?xindex>, index, index) -> !llvm.ptr, sym_name = "mpi_getSliceForActiveMask", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, memref<?xindex>, index) -> index, sym_name = "mpi_getActiveMask", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, memref<?xindex>) -> !llvm.ptr, sym_name = "mpi_getSlice", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr) -> memref<?xindex>, sym_name = "mpi_getPartitions", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = () -> index, sym_name = "mpi_getRank", sym_visibility = "private"}> ({
  }) {llvm.emit_c_interface} : () -> ()
  "func.func"() <{function_type = (!llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, index, index, index, index, index) -> !llvm.ptr, sym_name = "pte_sparse_mha"}> ({
  ^bb0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: !llvm.ptr, %arg4: !llvm.ptr, %arg5: !llvm.ptr, %arg6: index, %arg7: index, %arg8: index, %arg9: index, %arg10: index):
    %0 = "arith.constant"() <{value = true}> : () -> i1
    %1 = "arith.constant"() <{value = false}> : () -> i1
    %2 = "arith.constant"() <{value = -3.40282347E+38 : f32}> : () -> f32
    %3 = "arith.constant"() <{value = 0.000000e+00 : f32}> : () -> f32
    %4 = "arith.constant"() <{value = 0 : index}> : () -> index
    %5 = "arith.constant"() <{value = 1 : index}> : () -> index
    %6 = "arith.constant"() <{value = 2 : index}> : () -> index
    %7 = "arith.constant"() <{value = 3 : index}> : () -> index
    %8 = "arith.constant"() <{value = 4 : index}> : () -> index
    %9 = "func.call"(%arg0) <{callee = @mpi_getPartitions}> : (!llvm.ptr) -> memref<?xindex>
    %10 = "func.call"() <{callee = @mpi_getRank}> : () -> index
    %11 = "memref.alloc"(%8) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
    %12 = "arith.muli"(%10, %8) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %13 = "memref.load"(%9, %12) : (memref<?xindex>, index) -> index
    %14 = "arith.addi"(%12, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %15 = "memref.load"(%9, %14) : (memref<?xindex>, index) -> index
    %16 = "arith.addi"(%12, %6) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %17 = "memref.load"(%9, %16) : (memref<?xindex>, index) -> index
    %18 = "arith.addi"(%12, %7) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
    %19 = "memref.load"(%9, %18) : (memref<?xindex>, index) -> index
    "memref.store"(%13, %11, %4) : (index, memref<?xindex>, index) -> ()
    "memref.store"(%15, %11, %5) : (index, memref<?xindex>, index) -> ()
    "memref.store"(%17, %11, %6) : (index, memref<?xindex>, index) -> ()
    "memref.store"(%19, %11, %7) : (index, memref<?xindex>, index) -> ()
    %20 = "func.call"(%arg0, %11) <{callee = @mpi_getSlice}> : (!llvm.ptr, memref<?xindex>) -> !llvm.ptr
    %21 = "arith.constant"() <{value = 0 : index}> : () -> index
    %22 = "func.call"(%20, %21) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %23 = "bufferization.alloc_tensor"(%22, %arg9) <{operandSegmentSizes = array<i32: 2, 0, 0>}> : (index, index) -> tensor<?x?xf32>
    %24 = "linalg.generic"(%23) <{indexing_maps = [#map], iterator_types = [#linalg.iterator_type<parallel>, #linalg.iterator_type<parallel>], operandSegmentSizes = array<i32: 0, 1>}> ({
    ^bb0(%arg72: f32):
      "linalg.yield"(%3) : (f32) -> ()
    }) : (tensor<?x?xf32>) -> tensor<?x?xf32>
    %25 = "bufferization.materialize_in_destination"(%24, %23) : (tensor<?x?xf32>, tensor<?x?xf32>) -> tensor<?x?xf32>
    %26 = "func.call"(%arg2) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
    %27 = "arith.constant"() <{value = 0 : index}> : () -> index
    %28 = "func.call"(%arg2, %27) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %29 = "arith.constant"() <{value = 1 : index}> : () -> index
    %30 = "func.call"(%arg2, %29) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %31 = "arith.constant"() <{value = 2 : index}> : () -> index
    %32 = "func.call"(%arg2, %31) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %33 = "func.call"(%arg3) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
    %34 = "arith.constant"() <{value = 0 : index}> : () -> index
    %35 = "func.call"(%arg3, %34) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %36 = "arith.constant"() <{value = 1 : index}> : () -> index
    %37 = "func.call"(%arg3, %36) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %38 = "arith.constant"() <{value = 2 : index}> : () -> index
    %39 = "func.call"(%arg3, %38) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %40 = "func.call"(%arg4) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
    %41 = "arith.constant"() <{value = 0 : index}> : () -> index
    %42 = "func.call"(%arg4, %41) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %43 = "arith.constant"() <{value = 1 : index}> : () -> index
    %44 = "func.call"(%arg4, %43) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %45 = "arith.constant"() <{value = 2 : index}> : () -> index
    %46 = "func.call"(%arg4, %45) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %47 = "func.call"(%arg5) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
    %48 = "arith.constant"() <{value = 1 : index}> : () -> index
    %49 = "func.call"(%arg5, %48) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %50 = "arith.constant"() <{value = 2 : index}> : () -> index
    %51 = "func.call"(%arg5, %50) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
    %52 = "arith.constant"() <{value = 3 : index}> : () -> index
    %53 = "memref.alloca"(%52) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
    %54 = "memref.alloca"() <{operandSegmentSizes = array<i32: 0, 0>}> : () -> memref<f32>
    %55 = "scf.for"(%4, %arg6, %arg10, %25) ({
    ^bb0(%arg15: index, %arg16: tensor<?x?xf32>):
      "memref.store"(%arg15, %11, %5) : (index, memref<?xindex>, index) -> ()
      %93 = "arith.addi"(%arg15, %arg10) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
      "memref.store"(%93, %11, %7) : (index, memref<?xindex>, index) -> ()
      %94 = "func.call"(%arg0, %11) <{callee = @mpi_getSlice}> : (!llvm.ptr, memref<?xindex>) -> !llvm.ptr
      %95 = "func.call"(%arg0, %11, %4) <{callee = @mpi_getActiveMask}> : (!llvm.ptr, memref<?xindex>, index) -> index
      %96 = "func.call"(%arg0, %11, %5) <{callee = @mpi_getActiveMask}> : (!llvm.ptr, memref<?xindex>, index) -> index
      %97 = "memref.load"(%11, %4) : (memref<?xindex>, index) -> index
      %98 = "memref.load"(%11, %5) : (memref<?xindex>, index) -> index
      %99 = "memref.load"(%11, %6) : (memref<?xindex>, index) -> index
      %100 = "memref.load"(%11, %7) : (memref<?xindex>, index) -> index
      %101 = "memref.alloc"(%8) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      "memref.store"(%97, %101, %4) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%4, %101, %5) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%99, %101, %6) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%arg9, %101, %7) : (index, memref<?xindex>, index) -> ()
      %102 = "memref.alloc"(%8) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      "memref.store"(%98, %102, %4) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%4, %102, %5) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%100, %102, %6) : (index, memref<?xindex>, index) -> ()
      "memref.store"(%arg9, %102, %7) : (index, memref<?xindex>, index) -> ()
      %103 = "func.call"(%arg1, %101) <{callee = @mpi_getSlice}> : (!llvm.ptr, memref<?xindex>) -> !llvm.ptr
      %104 = "func.call"(%arg1, %102, %96, %4) <{callee = @mpi_getSliceForActiveMask}> : (!llvm.ptr, memref<?xindex>, index, index) -> !llvm.ptr
      %105 = "arith.constant"() <{value = 0 : index}> : () -> index
      %106 = "func.call"(%94, %105) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %107 = "arith.constant"() <{value = 1 : index}> : () -> index
      %108 = "func.call"(%94, %107) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %109 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %110 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %111 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %112 = "arith.constant"() <{value = 3 : index}> : () -> index
      %113 = "memref.alloca"(%112) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %114 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%109, %113, %114) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %115 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%110, %113, %115) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %116 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%111, %113, %116) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %117 = "arith.constant"() <{value = 3 : index}> : () -> index
      %118 = "memref.alloca"(%117) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %119 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%106, %118, %119) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %120 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%arg7, %118, %120) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %121 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%arg8, %118, %121) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %122 = "arith.constant"() <{value = 0 : index}> : () -> index
      %123 = "arith.constant"() <{value = 1 : index}> : () -> index
      %124 = "arith.constant"() <{value = 2 : index}> : () -> index
      %125 = "arith.constant"() <{value = 3 : index}> : () -> index
      %126 = "memref.alloca"(%125) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %127 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%122, %126, %127) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %128 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%123, %126, %128) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %129 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%124, %126, %129) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %130 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %131 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %132 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %133 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %134 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %135 = "func.call"(%118, %118, %113, %126, %126, %130, %131, %132, %133, %134) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %136 = "func.call"(%103) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %137 = "func.call"(%135) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %138 = "arith.constant"() <{value = 0 : index}> : () -> index
      %139 = "func.call"(%103, %138) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %140 = "arith.constant"() <{value = 1 : index}> : () -> index
      %141 = "func.call"(%103, %140) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %142 = "arith.constant"() <{value = 1 : index}> : () -> index
      %143 = "func.call"(%135, %142) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %144 = "arith.constant"() <{value = 2 : index}> : () -> index
      %145 = "func.call"(%135, %144) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %139, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg66: index):
        %537 = "arith.muli"(%arg66, %143) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %538 = "arith.muli"(%arg66, %141) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        "scf.parallel"(%4, %28, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg67: index):
          %539 = "arith.addi"(%arg67, %537) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %540 = "arith.muli"(%arg67, %30) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %541 = "arith.muli"(%539, %145) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %30, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg68: index):
            %542 = "arith.addi"(%arg68, %540) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %543 = "arith.addi"(%arg68, %541) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %544 = "memref.load"(%137, %543) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %545 = "arith.muli"(%542, %32) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %546 = "scf.parallel"(%4, %141, %5, %544) <{operandSegmentSizes = array<i32: 1, 1, 1, 1>}> ({
            ^bb0(%arg69: index):
              %547 = "arith.addi"(%arg69, %538) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %548 = "arith.addi"(%arg69, %545) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %549 = "memref.load"(%136, %547) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %550 = "memref.load"(%26, %548) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %551 = "arith.mulf"(%549, %550) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              "scf.reduce"(%551) ({
              ^bb0(%arg70: f32, %arg71: f32):
                %552 = "arith.addf"(%arg70, %arg71) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
                "scf.reduce.return"(%552) : (f32) -> ()
              }) : (f32) -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index, f32) -> f32
            "memref.store"(%546, %137, %543) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %146 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %147 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %148 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %149 = "arith.constant"() <{value = 3 : index}> : () -> index
      %150 = "memref.alloca"(%149) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %151 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%146, %150, %151) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %152 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%147, %150, %152) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %153 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%148, %150, %153) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %154 = "arith.constant"() <{value = 3 : index}> : () -> index
      %155 = "memref.alloca"(%154) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %156 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%108, %155, %156) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %157 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%arg7, %155, %157) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %158 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%arg8, %155, %158) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %159 = "arith.constant"() <{value = 0 : index}> : () -> index
      %160 = "arith.constant"() <{value = 1 : index}> : () -> index
      %161 = "arith.constant"() <{value = 2 : index}> : () -> index
      %162 = "arith.constant"() <{value = 3 : index}> : () -> index
      %163 = "memref.alloca"(%162) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %164 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%159, %163, %164) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %165 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%160, %163, %165) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %166 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%161, %163, %166) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %167 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %168 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %169 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %170 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %171 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %172 = "func.call"(%155, %155, %150, %163, %163, %167, %168, %169, %170, %171) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %173 = "func.call"(%104) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %174 = "func.call"(%172) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %175 = "arith.constant"() <{value = 0 : index}> : () -> index
      %176 = "func.call"(%104, %175) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %177 = "arith.constant"() <{value = 1 : index}> : () -> index
      %178 = "func.call"(%104, %177) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %179 = "arith.constant"() <{value = 1 : index}> : () -> index
      %180 = "func.call"(%172, %179) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %181 = "arith.constant"() <{value = 2 : index}> : () -> index
      %182 = "func.call"(%172, %181) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %176, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg60: index):
        %521 = "arith.muli"(%arg60, %180) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %522 = "arith.muli"(%arg60, %178) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        "scf.parallel"(%4, %35, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg61: index):
          %523 = "arith.addi"(%arg61, %521) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %524 = "arith.muli"(%arg61, %37) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %525 = "arith.muli"(%523, %182) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %37, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg62: index):
            %526 = "arith.addi"(%arg62, %524) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %527 = "arith.addi"(%arg62, %525) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %528 = "memref.load"(%174, %527) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %529 = "arith.muli"(%526, %39) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %530 = "scf.parallel"(%4, %178, %5, %528) <{operandSegmentSizes = array<i32: 1, 1, 1, 1>}> ({
            ^bb0(%arg63: index):
              %531 = "arith.addi"(%arg63, %522) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %532 = "arith.addi"(%arg63, %529) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %533 = "memref.load"(%173, %531) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %534 = "memref.load"(%33, %532) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %535 = "arith.mulf"(%533, %534) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              "scf.reduce"(%535) ({
              ^bb0(%arg64: f32, %arg65: f32):
                %536 = "arith.addf"(%arg64, %arg65) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
                "scf.reduce.return"(%536) : (f32) -> ()
              }) : (f32) -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index, f32) -> f32
            "memref.store"(%530, %174, %527) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %183 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %184 = "arith.constant"() <{value = 262144 : i64}> : () -> i64
      %185 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %186 = "arith.constant"() <{value = 3 : index}> : () -> index
      %187 = "memref.alloca"(%186) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %188 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%183, %187, %188) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %189 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%184, %187, %189) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %190 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%185, %187, %190) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %191 = "arith.constant"() <{value = 3 : index}> : () -> index
      %192 = "memref.alloca"(%191) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %193 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%106, %192, %193) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %194 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%108, %192, %194) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %195 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%arg8, %192, %195) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %196 = "arith.constant"() <{value = 0 : index}> : () -> index
      %197 = "arith.constant"() <{value = 1 : index}> : () -> index
      %198 = "arith.constant"() <{value = 2 : index}> : () -> index
      %199 = "arith.constant"() <{value = 3 : index}> : () -> index
      %200 = "memref.alloca"(%199) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %201 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%196, %200, %201) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %202 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%197, %200, %202) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %203 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%198, %200, %203) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %204 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %205 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %206 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %207 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %208 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %209 = "func.call"(%192, %192, %187, %200, %200, %204, %205, %206, %207, %208) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %210 = "arith.constant"() <{value = 2 : index}> : () -> index
      %211 = "func.call"(%209, %210) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %212 = "memref.alloc"(%211) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xf32>
      %213 = "memref.alloc"(%211) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi1>
      %214 = "memref.alloc"(%211) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %215 = "arith.constant"() <{value = 0 : index}> : () -> index
      %216 = "arith.constant"() <{value = 0.000000e+00 : f32}> : () -> f32
      "linalg.fill"(%216, %212) <{operandSegmentSizes = array<i32: 1, 1>}> ({
      ^bb0(%arg58: f32, %arg59: f32):
        "linalg.yield"(%arg58) : (f32) -> ()
      }) : (f32, memref<?xf32>) -> ()
      %217 = "arith.constant"() <{value = false}> : () -> i1
      "linalg.fill"(%217, %213) <{operandSegmentSizes = array<i32: 1, 1>}> ({
      ^bb0(%arg56: i1, %arg57: i1):
        "linalg.yield"(%arg56) : (i1) -> ()
      }) : (i1, memref<?xi1>) -> ()
      %218 = "func.call"(%135) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %219 = "func.call"(%172) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %220 = "func.call"(%94) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %221 = "arith.constant"() <{value = 0 : index}> : () -> index
      %222 = "func.call"(%135, %221) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %223 = "arith.constant"() <{value = 1 : index}> : () -> index
      %224 = "func.call"(%135, %223) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %225 = "arith.constant"() <{value = 2 : index}> : () -> index
      %226 = "func.call"(%135, %225) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %227 = "arith.constant"() <{value = 1 : index}> : () -> index
      %228 = "func.call"(%172, %227) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %229 = "arith.constant"() <{value = 2 : index}> : () -> index
      %230 = "func.call"(%172, %229) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %231 = "arith.constant"() <{value = 1 : index}> : () -> index
      %232 = "func.call"(%94, %231) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %233 = "arith.constant"() <{value = 1 : index}> : () -> index
      %234 = "func.call"(%94, %233) <{callee = @sparseCoordinates0}> : (!llvm.ptr, index) -> memref<?xindex>
      %235 = "scf.for"(%4, %222, %5, %209) ({
      ^bb0(%arg48: index, %arg49: !llvm.ptr):
        %491 = "memref.load"(%232, %arg48) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %492 = "arith.addi"(%arg48, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %493 = "memref.load"(%232, %492) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %494 = "arith.muli"(%arg48, %224) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %495 = "scf.for"(%491, %493, %5, %arg49) ({
        ^bb0(%arg50: index, %arg51: !llvm.ptr):
          %496 = "memref.load"(%234, %arg50) <{nontemporal = false}> : (memref<?xindex>, index) -> index
          %497 = "memref.load"(%220, %arg50) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
          %498 = "arith.muli"(%496, %228) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %499 = "scf.for"(%4, %224, %5, %215) ({
          ^bb0(%arg52: index, %arg53: index):
            %504 = "arith.addi"(%arg52, %494) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %505 = "arith.addi"(%arg52, %498) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %506 = "arith.muli"(%504, %226) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %507 = "arith.muli"(%505, %230) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %508 = "scf.for"(%4, %226, %5, %arg53) ({
            ^bb0(%arg54: index, %arg55: index):
              %509 = "arith.addi"(%arg54, %506) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %510 = "arith.addi"(%arg54, %507) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %511 = "memref.load"(%218, %509) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %512 = "memref.load"(%219, %510) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %513 = "arith.mulf"(%511, %512) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              %514 = "arith.mulf"(%513, %497) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              %515 = "memref.load"(%212, %arg54) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %516 = "arith.addf"(%514, %515) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              %517 = "memref.load"(%213, %arg54) <{nontemporal = false}> : (memref<?xi1>, index) -> i1
              %518 = "arith.cmpi"(%517, %1) <{predicate = 0 : i64}> : (i1, i1) -> i1
              %519 = "scf.if"(%518) ({
                "memref.store"(%0, %213, %arg54) <{nontemporal = false}> : (i1, memref<?xi1>, index) -> ()
                "memref.store"(%arg54, %214, %arg55) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
                %520 = "arith.addi"(%arg55, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
                "scf.yield"(%520) : (index) -> ()
              }, {
                "scf.yield"(%arg55) : (index) -> ()
              }) : (i1) -> index
              "memref.store"(%516, %212, %arg54) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
              "scf.yield"(%519) : (index) -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index, index) -> index
            "scf.yield"(%508) : (index) -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index, index) -> index
          %500 = "arith.constant"() <{value = 3 : index}> : () -> index
          %501 = "memref.alloca"(%500) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
          %502 = "arith.constant"() <{value = 0 : index}> : () -> index
          "memref.store"(%arg48, %501, %502) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
          %503 = "arith.constant"() <{value = 1 : index}> : () -> index
          "memref.store"(%496, %501, %503) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
          "func.call"(%arg51, %501, %212, %213, %214, %499) <{callee = @expInsertF32}> : (!llvm.ptr, memref<?xindex>, memref<?xf32>, memref<?xi1>, memref<?xindex>, index) -> ()
          "scf.yield"(%arg51) : (!llvm.ptr) -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
        "scf.yield"(%495) : (!llvm.ptr) -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
      "func.call"(%235) <{callee = @endLexInsert}> : (!llvm.ptr) -> ()
      %236 = "arith.constant"() <{value = 0 : index}> : () -> index
      %237 = "func.call"(%235, %236) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %238 = "arith.constant"() <{value = 2 : index}> : () -> index
      %239 = "func.call"(%235, %238) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %240 = "bufferization.alloc_tensor"(%237, %239) <{operandSegmentSizes = array<i32: 2, 0, 0>}> : (index, index) -> tensor<?x?xf32>
      %241 = "linalg.generic"(%240) <{indexing_maps = [#map], iterator_types = [#linalg.iterator_type<parallel>, #linalg.iterator_type<parallel>], operandSegmentSizes = array<i32: 0, 1>}> ({
      ^bb0(%arg47: f32):
        "linalg.yield"(%2) : (f32) -> ()
      }) : (tensor<?x?xf32>) -> tensor<?x?xf32>
      %242 = "func.call"(%235) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %243 = "bufferization.to_memref"(%241) : (tensor<?x?xf32>) -> memref<?x?xf32>
      %244 = "arith.constant"() <{value = 0 : index}> : () -> index
      %245 = "func.call"(%235, %244) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %246 = "arith.constant"() <{value = 1 : index}> : () -> index
      %247 = "func.call"(%235, %246) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %248 = "arith.constant"() <{value = 2 : index}> : () -> index
      %249 = "func.call"(%235, %248) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %245, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg44: index):
        %483 = "memref.load"(%247, %arg44) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %484 = "arith.addi"(%arg44, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %485 = "memref.load"(%247, %484) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        "scf.parallel"(%483, %485, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg45: index):
          %486 = "arith.muli"(%arg45, %249) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %249, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg46: index):
            %487 = "arith.addi"(%arg46, %486) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %488 = "memref.load"(%242, %487) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %489 = "memref.load"(%243, %arg44, %arg46) <{nontemporal = false}> : (memref<?x?xf32>, index, index) -> f32
            %490 = "arith.maxnumf"(%488, %489) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
            "memref.store"(%490, %243, %arg44, %arg46) <{nontemporal = false}> : (f32, memref<?x?xf32>, index, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %250 = "bufferization.to_tensor"(%243) : (memref<?x?xf32>) -> tensor<?x?xf32>
      %251 = "arith.constant"() <{value = 0 : index}> : () -> index
      %252 = "func.call"(%135, %251) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %253 = "arith.constant"() <{value = 2 : index}> : () -> index
      %254 = "func.call"(%135, %253) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %255 = "arith.constant"() <{value = 0 : index}> : () -> index
      %256 = "func.call"(%172, %255) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %257 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %258 = "arith.constant"() <{value = 262144 : i64}> : () -> i64
      %259 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %260 = "arith.constant"() <{value = 3 : index}> : () -> index
      %261 = "memref.alloca"(%260) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %262 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%257, %261, %262) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %263 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%258, %261, %263) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %264 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%259, %261, %264) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %265 = "arith.constant"() <{value = 3 : index}> : () -> index
      %266 = "memref.alloca"(%265) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %267 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%252, %266, %267) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %268 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%256, %266, %268) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %269 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%254, %266, %269) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %270 = "arith.constant"() <{value = 0 : index}> : () -> index
      %271 = "arith.constant"() <{value = 1 : index}> : () -> index
      %272 = "arith.constant"() <{value = 2 : index}> : () -> index
      %273 = "arith.constant"() <{value = 3 : index}> : () -> index
      %274 = "memref.alloca"(%273) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %275 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%270, %274, %275) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %276 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%271, %274, %276) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %277 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%272, %274, %277) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %278 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %279 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %280 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %281 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %282 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %283 = "func.call"(%266, %266, %261, %274, %274, %278, %279, %280, %281, %282) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %284 = "func.call"(%235) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %285 = "arith.constant"() <{value = 0 : index}> : () -> index
      %286 = "func.call"(%235, %285) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %287 = "arith.constant"() <{value = 1 : index}> : () -> index
      %288 = "func.call"(%235, %287) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %289 = "arith.constant"() <{value = 1 : index}> : () -> index
      %290 = "func.call"(%235, %289) <{callee = @sparseCoordinates0}> : (!llvm.ptr, index) -> memref<?xindex>
      %291 = "arith.constant"() <{value = 2 : index}> : () -> index
      %292 = "func.call"(%235, %291) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %293 = "scf.for"(%4, %286, %5, %283) ({
      ^bb0(%arg38: index, %arg39: !llvm.ptr):
        %468 = "memref.load"(%288, %arg38) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %469 = "arith.addi"(%arg38, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %470 = "memref.load"(%288, %469) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %471 = "scf.for"(%468, %470, %5, %arg39) ({
        ^bb0(%arg40: index, %arg41: !llvm.ptr):
          %472 = "memref.load"(%290, %arg40) <{nontemporal = false}> : (memref<?xindex>, index) -> index
          %473 = "arith.muli"(%arg40, %292) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %474 = "scf.for"(%4, %292, %5, %arg41) ({
          ^bb0(%arg42: index, %arg43: !llvm.ptr):
            %475 = "arith.addi"(%arg42, %473) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %476 = "memref.load"(%284, %475) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %477 = "tensor.extract"(%250, %arg38, %arg42) : (tensor<?x?xf32>, index, index) -> f32
            %478 = "arith.subf"(%476, %477) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
            %479 = "math.exp"(%478) <{fastmath = #arith.fastmath<none>}> : (f32) -> f32
            %480 = "arith.constant"() <{value = 0 : index}> : () -> index
            "memref.store"(%arg38, %53, %480) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
            %481 = "arith.constant"() <{value = 1 : index}> : () -> index
            "memref.store"(%472, %53, %481) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
            %482 = "arith.constant"() <{value = 2 : index}> : () -> index
            "memref.store"(%arg42, %53, %482) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
            "memref.store"(%479, %54) : (f32, memref<f32>) -> ()
            "func.call"(%arg43, %53, %54) <{callee = @lexInsertF32}> : (!llvm.ptr, memref<?xindex>, memref<f32>) -> ()
            "scf.yield"(%arg43) : (!llvm.ptr) -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
          "scf.yield"(%474) : (!llvm.ptr) -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
        "scf.yield"(%471) : (!llvm.ptr) -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
      "func.call"(%293) <{callee = @endLexInsert}> : (!llvm.ptr) -> ()
      %294 = "bufferization.alloc_tensor"(%237, %239) <{operandSegmentSizes = array<i32: 2, 0, 0>}> : (index, index) -> tensor<?x?xf32>
      %295 = "linalg.generic"(%294) <{indexing_maps = [#map], iterator_types = [#linalg.iterator_type<parallel>, #linalg.iterator_type<parallel>], operandSegmentSizes = array<i32: 0, 1>}> ({
      ^bb0(%arg37: f32):
        "linalg.yield"(%3) : (f32) -> ()
      }) : (tensor<?x?xf32>) -> tensor<?x?xf32>
      %296 = "func.call"(%293) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %297 = "bufferization.to_memref"(%295) : (tensor<?x?xf32>) -> memref<?x?xf32>
      %298 = "arith.constant"() <{value = 0 : index}> : () -> index
      %299 = "func.call"(%293, %298) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %300 = "arith.constant"() <{value = 1 : index}> : () -> index
      %301 = "func.call"(%293, %300) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %302 = "arith.constant"() <{value = 2 : index}> : () -> index
      %303 = "func.call"(%293, %302) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %299, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg34: index):
        %460 = "memref.load"(%301, %arg34) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %461 = "arith.addi"(%arg34, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %462 = "memref.load"(%301, %461) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        "scf.parallel"(%460, %462, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg35: index):
          %463 = "arith.muli"(%arg35, %303) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %303, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg36: index):
            %464 = "arith.addi"(%arg36, %463) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %465 = "memref.load"(%296, %464) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %466 = "memref.load"(%297, %arg34, %arg36) <{nontemporal = false}> : (memref<?x?xf32>, index, index) -> f32
            %467 = "arith.addf"(%465, %466) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
            "memref.store"(%467, %297, %arg34, %arg36) <{nontemporal = false}> : (f32, memref<?x?xf32>, index, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %304 = "bufferization.to_tensor"(%297) : (memref<?x?xf32>) -> tensor<?x?xf32>
      %305 = "func.call"(%293) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %306 = "arith.constant"() <{value = 0 : index}> : () -> index
      %307 = "func.call"(%293, %306) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %308 = "arith.constant"() <{value = 1 : index}> : () -> index
      %309 = "func.call"(%293, %308) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %310 = "arith.constant"() <{value = 2 : index}> : () -> index
      %311 = "func.call"(%293, %310) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %307, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg31: index):
        %452 = "memref.load"(%309, %arg31) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %453 = "arith.addi"(%arg31, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %454 = "memref.load"(%309, %453) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        "scf.parallel"(%452, %454, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg32: index):
          %455 = "arith.muli"(%arg32, %311) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %311, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg33: index):
            %456 = "arith.addi"(%arg33, %455) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %457 = "memref.load"(%305, %456) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %458 = "tensor.extract"(%304, %arg31, %arg33) : (tensor<?x?xf32>, index, index) -> f32
            %459 = "arith.divf"(%457, %458) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
            "memref.store"(%459, %305, %456) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %312 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %313 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %314 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %315 = "arith.constant"() <{value = 3 : index}> : () -> index
      %316 = "memref.alloca"(%315) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %317 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%312, %316, %317) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %318 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%313, %316, %318) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %319 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%314, %316, %319) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %320 = "arith.constant"() <{value = 3 : index}> : () -> index
      %321 = "memref.alloca"(%320) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %322 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%108, %321, %322) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %323 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%arg7, %321, %323) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %324 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%arg8, %321, %324) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %325 = "arith.constant"() <{value = 0 : index}> : () -> index
      %326 = "arith.constant"() <{value = 1 : index}> : () -> index
      %327 = "arith.constant"() <{value = 2 : index}> : () -> index
      %328 = "arith.constant"() <{value = 3 : index}> : () -> index
      %329 = "memref.alloca"(%328) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %330 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%325, %329, %330) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %331 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%326, %329, %331) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %332 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%327, %329, %332) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %333 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %334 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %335 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %336 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %337 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %338 = "func.call"(%321, %321, %316, %329, %329, %333, %334, %335, %336, %337) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %339 = "func.call"(%104) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %340 = "func.call"(%338) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %341 = "arith.constant"() <{value = 0 : index}> : () -> index
      %342 = "func.call"(%104, %341) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %343 = "arith.constant"() <{value = 1 : index}> : () -> index
      %344 = "func.call"(%104, %343) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %345 = "arith.constant"() <{value = 1 : index}> : () -> index
      %346 = "func.call"(%338, %345) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %347 = "arith.constant"() <{value = 2 : index}> : () -> index
      %348 = "func.call"(%338, %347) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %342, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg25: index):
        %436 = "arith.muli"(%arg25, %346) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %437 = "arith.muli"(%arg25, %344) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        "scf.parallel"(%4, %42, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg26: index):
          %438 = "arith.addi"(%arg26, %436) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %439 = "arith.muli"(%arg26, %44) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %440 = "arith.muli"(%438, %348) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %44, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg27: index):
            %441 = "arith.addi"(%arg27, %439) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %442 = "arith.addi"(%arg27, %440) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %443 = "memref.load"(%340, %442) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %444 = "arith.muli"(%441, %46) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %445 = "scf.parallel"(%4, %344, %5, %443) <{operandSegmentSizes = array<i32: 1, 1, 1, 1>}> ({
            ^bb0(%arg28: index):
              %446 = "arith.addi"(%arg28, %437) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %447 = "arith.addi"(%arg28, %444) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %448 = "memref.load"(%339, %446) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %449 = "memref.load"(%40, %447) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %450 = "arith.mulf"(%448, %449) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              "scf.reduce"(%450) ({
              ^bb0(%arg29: f32, %arg30: f32):
                %451 = "arith.addf"(%arg29, %arg30) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
                "scf.reduce.return"(%451) : (f32) -> ()
              }) : (f32) -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index, f32) -> f32
            "memref.store"(%445, %340, %442) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %349 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %350 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %351 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
      %352 = "arith.constant"() <{value = 3 : index}> : () -> index
      %353 = "memref.alloca"(%352) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
      %354 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%349, %353, %354) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %355 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%350, %353, %355) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %356 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%351, %353, %356) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
      %357 = "arith.constant"() <{value = 3 : index}> : () -> index
      %358 = "memref.alloca"(%357) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %359 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%106, %358, %359) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %360 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%arg7, %358, %360) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %361 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%arg8, %358, %361) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %362 = "arith.constant"() <{value = 0 : index}> : () -> index
      %363 = "arith.constant"() <{value = 1 : index}> : () -> index
      %364 = "arith.constant"() <{value = 2 : index}> : () -> index
      %365 = "arith.constant"() <{value = 3 : index}> : () -> index
      %366 = "memref.alloca"(%365) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
      %367 = "arith.constant"() <{value = 0 : index}> : () -> index
      "memref.store"(%362, %366, %367) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %368 = "arith.constant"() <{value = 1 : index}> : () -> index
      "memref.store"(%363, %366, %368) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %369 = "arith.constant"() <{value = 2 : index}> : () -> index
      "memref.store"(%364, %366, %369) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
      %370 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %371 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %372 = "arith.constant"() <{value = 2 : i32}> : () -> i32
      %373 = "arith.constant"() <{value = 0 : i32}> : () -> i32
      %374 = "llvm.mlir.zero"() : () -> !llvm.ptr
      %375 = "func.call"(%358, %358, %353, %366, %366, %370, %371, %372, %373, %374) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      "func.call"(%293) <{callee = @endLexInsert}> : (!llvm.ptr) -> ()
      %376 = "func.call"(%293) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %377 = "func.call"(%338) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %378 = "func.call"(%375) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %379 = "arith.constant"() <{value = 0 : index}> : () -> index
      %380 = "func.call"(%293, %379) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %381 = "arith.constant"() <{value = 1 : index}> : () -> index
      %382 = "func.call"(%293, %381) <{callee = @sparsePositions0}> : (!llvm.ptr, index) -> memref<?xindex>
      %383 = "arith.constant"() <{value = 1 : index}> : () -> index
      %384 = "func.call"(%293, %383) <{callee = @sparseCoordinates0}> : (!llvm.ptr, index) -> memref<?xindex>
      %385 = "arith.constant"() <{value = 2 : index}> : () -> index
      %386 = "func.call"(%293, %385) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %387 = "arith.constant"() <{value = 1 : index}> : () -> index
      %388 = "func.call"(%338, %387) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %389 = "arith.constant"() <{value = 2 : index}> : () -> index
      %390 = "func.call"(%338, %389) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %391 = "arith.constant"() <{value = 1 : index}> : () -> index
      %392 = "func.call"(%375, %391) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %393 = "arith.constant"() <{value = 2 : index}> : () -> index
      %394 = "func.call"(%375, %393) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %380, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg21: index):
        %417 = "memref.load"(%382, %arg21) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %418 = "arith.addi"(%arg21, %5) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        %419 = "memref.load"(%382, %418) <{nontemporal = false}> : (memref<?xindex>, index) -> index
        %420 = "arith.muli"(%arg21, %392) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        "scf.parallel"(%417, %419, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg22: index):
          %421 = "memref.load"(%384, %arg22) <{nontemporal = false}> : (memref<?xindex>, index) -> index
          %422 = "arith.muli"(%421, %388) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %423 = "arith.muli"(%arg22, %386) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %388, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg23: index):
            %424 = "arith.addi"(%arg23, %422) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %425 = "arith.addi"(%arg23, %420) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %426 = "arith.muli"(%424, %390) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %427 = "arith.muli"(%425, %394) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            "scf.parallel"(%4, %386, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
            ^bb0(%arg24: index):
              %428 = "arith.addi"(%arg24, %423) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %429 = "arith.addi"(%arg24, %426) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %430 = "arith.addi"(%arg24, %427) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %431 = "memref.load"(%376, %428) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %432 = "memref.load"(%377, %429) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %433 = "arith.mulf"(%431, %432) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              %434 = "memref.load"(%378, %430) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %435 = "arith.addf"(%433, %434) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              "memref.store"(%435, %378, %430) <{nontemporal = false}> : (f32, memref<?xf32>, index) -> ()
              "scf.reduce"() : () -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %395 = "func.call"(%375) <{callee = @sparseValuesF32}> : (!llvm.ptr) -> memref<?xf32>
      %396 = "bufferization.to_memref"(%arg16) : (tensor<?x?xf32>) -> memref<?x?xf32>
      %397 = "arith.constant"() <{value = 0 : index}> : () -> index
      %398 = "func.call"(%375, %397) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %399 = "arith.constant"() <{value = 1 : index}> : () -> index
      %400 = "func.call"(%375, %399) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      %401 = "arith.constant"() <{value = 2 : index}> : () -> index
      %402 = "func.call"(%375, %401) <{callee = @sparseLvlSize}> : (!llvm.ptr, index) -> index
      "scf.parallel"(%4, %398, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
      ^bb0(%arg17: index):
        %404 = "arith.muli"(%arg17, %400) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
        "scf.parallel"(%4, %400, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
        ^bb0(%arg18: index):
          %405 = "arith.addi"(%arg18, %404) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %406 = "arith.muli"(%405, %402) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          %407 = "arith.muli"(%arg18, %49) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
          "scf.parallel"(%4, %402, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
          ^bb0(%arg19: index):
            %408 = "arith.addi"(%arg19, %406) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %409 = "arith.addi"(%arg19, %407) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            %410 = "memref.load"(%395, %408) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
            %411 = "arith.muli"(%409, %51) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
            "scf.parallel"(%4, %51, %5) <{operandSegmentSizes = array<i32: 1, 1, 1, 0>}> ({
            ^bb0(%arg20: index):
              %412 = "arith.addi"(%arg20, %411) <{overflowFlags = #arith.overflow<none>}> : (index, index) -> index
              %413 = "memref.load"(%47, %412) <{nontemporal = false}> : (memref<?xf32>, index) -> f32
              %414 = "arith.mulf"(%410, %413) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              %415 = "memref.load"(%396, %arg17, %arg20) <{nontemporal = false}> : (memref<?x?xf32>, index, index) -> f32
              %416 = "arith.addf"(%414, %415) <{fastmath = #arith.fastmath<none>}> : (f32, f32) -> f32
              "memref.store"(%416, %396, %arg17, %arg20) <{nontemporal = false}> : (f32, memref<?x?xf32>, index, index) -> ()
              "scf.reduce"() : () -> ()
            }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
            "scf.reduce"() : () -> ()
          }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
          "scf.reduce"() : () -> ()
        }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
        "scf.reduce"() : () -> ()
      }) {"Emitted from" = "linalg.generic"} : (index, index, index) -> ()
      %403 = "bufferization.to_tensor"(%396) : (memref<?x?xf32>) -> tensor<?x?xf32>
      "scf.yield"(%403) : (tensor<?x?xf32>) -> ()
    }) : (index, index, index, tensor<?x?xf32>) -> tensor<?x?xf32>
    "memref.dealloc"(%212) : (memref<?xf32>) -> ()
    "memref.dealloc"(%213) : (memref<?xi1>) -> ()
    "memref.dealloc"(%214) : (memref<?xindex>) -> ()
    %56 = "tensor.dim"(%55, %4) : (tensor<?x?xf32>, index) -> index
    %57 = "tensor.dim"(%55, %5) : (tensor<?x?xf32>, index) -> index
    %58 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
    %59 = "arith.constant"() <{value = 65536 : i64}> : () -> i64
    %60 = "arith.constant"() <{value = 2 : index}> : () -> index
    %61 = "memref.alloca"(%60) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xi64>
    %62 = "arith.constant"() <{value = 0 : index}> : () -> index
    "memref.store"(%58, %61, %62) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
    %63 = "arith.constant"() <{value = 1 : index}> : () -> index
    "memref.store"(%59, %61, %63) <{nontemporal = false}> : (i64, memref<?xi64>, index) -> ()
    %64 = "arith.constant"() <{value = 2 : index}> : () -> index
    %65 = "memref.alloca"(%64) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
    %66 = "arith.constant"() <{value = 0 : index}> : () -> index
    "memref.store"(%56, %65, %66) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
    %67 = "arith.constant"() <{value = 1 : index}> : () -> index
    "memref.store"(%57, %65, %67) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
    %68 = "arith.constant"() <{value = 0 : index}> : () -> index
    %69 = "arith.constant"() <{value = 1 : index}> : () -> index
    %70 = "arith.constant"() <{value = 2 : index}> : () -> index
    %71 = "memref.alloca"(%70) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
    %72 = "arith.constant"() <{value = 0 : index}> : () -> index
    "memref.store"(%68, %71, %72) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
    %73 = "arith.constant"() <{value = 1 : index}> : () -> index
    "memref.store"(%69, %71, %73) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
    %74 = "arith.constant"() <{value = 0 : i32}> : () -> i32
    %75 = "arith.constant"() <{value = 0 : i32}> : () -> i32
    %76 = "arith.constant"() <{value = 2 : i32}> : () -> i32
    %77 = "arith.constant"() <{value = 0 : i32}> : () -> i32
    %78 = "llvm.mlir.zero"() : () -> !llvm.ptr
    %79 = "func.call"(%65, %65, %61, %71, %71, %74, %75, %76, %77, %78) <{callee = @newSparseTensor}> : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
    %80 = "bufferization.to_memref"(%55) : (tensor<?x?xf32>) -> memref<?x?xf32>
    %81 = "tensor.dim"(%55, %4) : (tensor<?x?xf32>, index) -> index
    %82 = "tensor.dim"(%55, %5) : (tensor<?x?xf32>, index) -> index
    %83 = "arith.constant"() <{value = 2 : index}> : () -> index
    %84 = "memref.alloca"(%83) <{operandSegmentSizes = array<i32: 1, 0>}> : (index) -> memref<?xindex>
    %85 = "memref.alloca"() <{operandSegmentSizes = array<i32: 0, 0>}> : () -> memref<f32>
    %86 = "scf.for"(%4, %81, %5, %79) ({
    ^bb0(%arg11: index, %arg12: !llvm.ptr):
      %87 = "scf.for"(%4, %82, %5, %arg12) ({
      ^bb0(%arg13: index, %arg14: !llvm.ptr):
        %88 = "memref.load"(%80, %arg11, %arg13) <{nontemporal = false}> : (memref<?x?xf32>, index, index) -> f32
        %89 = "arith.cmpf"(%88, %3) <{fastmath = #arith.fastmath<none>, predicate = 13 : i64}> : (f32, f32) -> i1
        %90 = "scf.if"(%89) ({
          %91 = "arith.constant"() <{value = 0 : index}> : () -> index
          "memref.store"(%arg11, %84, %91) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
          %92 = "arith.constant"() <{value = 1 : index}> : () -> index
          "memref.store"(%arg13, %84, %92) <{nontemporal = false}> : (index, memref<?xindex>, index) -> ()
          "memref.store"(%88, %85) : (f32, memref<f32>) -> ()
          "func.call"(%arg14, %84, %85) <{callee = @lexInsertF32}> : (!llvm.ptr, memref<?xindex>, memref<f32>) -> ()
          "scf.yield"(%arg14) : (!llvm.ptr) -> ()
        }, {
          "scf.yield"(%arg14) : (!llvm.ptr) -> ()
        }) : (i1) -> !llvm.ptr
        "scf.yield"(%90) : (!llvm.ptr) -> ()
      }) {"Emitted from" = "sparse_tensor.foreach"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
      "scf.yield"(%87) : (!llvm.ptr) -> ()
    }) {"Emitted from" = "sparse_tensor.foreach"} : (index, index, index, !llvm.ptr) -> !llvm.ptr
    "func.call"(%86) <{callee = @endLexInsert}> : (!llvm.ptr) -> ()
    "func.return"(%86) : (!llvm.ptr) -> ()
  }) : () -> ()
}) : () -> ()

This mlir causes error:

failed0.mlir:804:22: error: use of undeclared SSA value name
    "memref.dealloc"(%212) : (memref<?xf32>) -> ()
                     ^
failed0.mlir:805:22: error: use of undeclared SSA value name
    "memref.dealloc"(%213) : (memref<?xi1>) -> ()
                     ^
failed0.mlir:806:22: error: use of undeclared SSA value name
    "memref.dealloc"(%214) : (memref<?xindex>) -> ()
                     ^

Moving these inside the outermost scf.for makes this particular go away.

[vmiheer]

This also seem to affect somewhere in the translation pipeline.
See:

bspmm.mlir

module {
  func.func private @delSparseTensor(!llvm.ptr)
  func.func private @sparseCoordinates0(!llvm.ptr, index) -> memref<?xindex> attributes {llvm.emit_c_interface}
  func.func private @sparsePositions0(!llvm.ptr, index) -> memref<?xindex> attributes {llvm.emit_c_interface}
  func.func private @sparseValuesF32(!llvm.ptr) -> memref<?xf32> attributes {llvm.emit_c_interface}
  func.func private @newSparseTensor(memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr attributes {llvm.emit_c_interface}
  func.func private @sparseLvlSize(!llvm.ptr, index) -> index
  func.func private @mpi_getSliceForActiveMask(!llvm.ptr, memref<?xindex>, index, index) -> !llvm.ptr attributes {llvm.emit_c_interface}
  func.func private @mpi_getActiveMask(!llvm.ptr, memref<?xindex>, index) -> index attributes {llvm.emit_c_interface}
  func.func private @mpi_getSlice(!llvm.ptr, memref<?xindex>) -> !llvm.ptr attributes {llvm.emit_c_interface}
  func.func private @mpi_getPartitions(!llvm.ptr) -> memref<?xindex> attributes {llvm.emit_c_interface}
  func.func private @mpi_getRank() -> index attributes {llvm.emit_c_interface}
  func.func private @concat_csrv_csrv(index, !llvm.ptr, index, index) attributes {llvm.emit_c_interface}
  func.func private @csr_to_csrv(!llvm.ptr, !llvm.ptr) -> !llvm.ptr attributes {llvm.emit_c_interface}
  func.func private @overwrite_csrv_csrv(!llvm.ptr, !llvm.ptr, index, index) attributes {llvm.emit_c_interface}
  func.func private @extract_slice(index, index, index) -> !llvm.ptr attributes {llvm.emit_c_interface}
  func.func @pte_bspmm_tiled(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: index, %arg3: !llvm.ptr, %arg4: !llvm.ptr, %arg5: index, %arg6: index, %arg7: index, %arg8: index, %arg9: index) -> !llvm.ptr {
    %0 = llvm.mlir.zero : !llvm.ptr
    %c2_i32 = arith.constant 2 : i32
    %c0_i32 = arith.constant 0 : i32
    %c65536_i64 = arith.constant 65536 : i64
    %c0 = arith.constant 0 : index
    %c1 = arith.constant 1 : index
    %c2 = arith.constant 2 : index
    %c3 = arith.constant 3 : index
    %c4 = arith.constant 4 : index
    %1 = call @mpi_getPartitions(%arg0) : (!llvm.ptr) -> memref<?xindex>
    %2 = call @mpi_getRank() : () -> index
    %alloc = memref.alloc() : memref<4xindex>
    %cast = memref.cast %alloc : memref<4xindex> to memref<?xindex>
    %3 = arith.muli %2, %c4 : index
    %4 = memref.load %1[%3] : memref<?xindex>
    %5 = arith.addi %3, %c1 : index
    %6 = memref.load %1[%5] : memref<?xindex>
    %7 = arith.addi %3, %c2 : index
    %8 = memref.load %1[%7] : memref<?xindex>
    %9 = arith.addi %3, %c3 : index
    %10 = memref.load %1[%9] : memref<?xindex>
    memref.store %4, %alloc[%c0] : memref<4xindex>
    memref.store %6, %alloc[%c1] : memref<4xindex>
    memref.store %8, %alloc[%c2] : memref<4xindex>
    memref.store %10, %alloc[%c3] : memref<4xindex>
    %11 = call @mpi_getSlice(%arg0, %cast) : (!llvm.ptr, memref<?xindex>) -> !llvm.ptr
    %12 = call @sparseLvlSize(%11, %c0) : (!llvm.ptr, index) -> index
    %alloca = memref.alloca() : memref<3xi64>
    %cast_0 = memref.cast %alloca : memref<3xi64> to memref<?xi64>
    memref.store %c65536_i64, %alloca[%c0] : memref<3xi64>
    memref.store %c65536_i64, %alloca[%c1] : memref<3xi64>
    memref.store %c65536_i64, %alloca[%c2] : memref<3xi64>
    %alloca_1 = memref.alloca() : memref<3xindex>
    %cast_2 = memref.cast %alloca_1 : memref<3xindex> to memref<?xindex>
    memref.store %12, %alloca_1[%c0] : memref<3xindex>
    memref.store %arg6, %alloca_1[%c1] : memref<3xindex>
    memref.store %arg7, %alloca_1[%c2] : memref<3xindex>
    %alloca_3 = memref.alloca() : memref<3xindex>
    %cast_4 = memref.cast %alloca_3 : memref<3xindex> to memref<?xindex>
    memref.store %c0, %alloca_3[%c0] : memref<3xindex>
    memref.store %c1, %alloca_3[%c1] : memref<3xindex>
    memref.store %c2, %alloca_3[%c2] : memref<3xindex>
    %13 = call @newSparseTensor(%cast_2, %cast_2, %cast_0, %cast_4, %cast_4, %c0_i32, %c0_i32, %c2_i32, %c0_i32, %0) : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
    %14 = call @sparseValuesF32(%arg3) : (!llvm.ptr) -> memref<?xf32>
    %15 = call @sparseLvlSize(%arg3, %c0) : (!llvm.ptr, index) -> index
    %16 = call @sparseLvlSize(%arg3, %c1) : (!llvm.ptr, index) -> index
    %17 = call @sparseLvlSize(%arg3, %c2) : (!llvm.ptr, index) -> index
    kokkos.sync %14 {memorySpace = 1 : i64} : memref<?xf32>
    scf.for %arg10 = %c0 to %arg5 step %arg9 {
      memref.store %arg10, %alloc[%c1] : memref<4xindex>
      %18 = arith.addi %arg10, %arg9 : index
      memref.store %18, %alloc[%c3] : memref<4xindex>
      %19 = func.call @mpi_getSlice(%arg0, %cast) : (!llvm.ptr, memref<?xindex>) -> !llvm.ptr
      %20 = func.call @mpi_getActiveMask(%arg0, %cast, %c1) : (!llvm.ptr, memref<?xindex>, index) -> index
      %21 = memref.load %alloc[%c1] : memref<4xindex>
      %22 = memref.load %alloc[%c3] : memref<4xindex>
      %alloc_5 = memref.alloc() : memref<4xindex>
      %cast_6 = memref.cast %alloc_5 : memref<4xindex> to memref<?xindex>
      memref.store %21, %alloc_5[%c0] : memref<4xindex>
      memref.store %c0, %alloc_5[%c1] : memref<4xindex>
      memref.store %22, %alloc_5[%c2] : memref<4xindex>
      memref.store %arg8, %alloc_5[%c3] : memref<4xindex>
      %23 = func.call @mpi_getSliceForActiveMask(%arg1, %cast_6, %20, %c0) : (!llvm.ptr, memref<?xindex>, index, index) -> !llvm.ptr
      %24 = func.call @sparseLvlSize(%19, %c1) : (!llvm.ptr, index) -> index
      %25 = func.call @extract_slice(%arg2, %c1, %21) : (index, index, index) -> !llvm.ptr
      %alloca_7 = memref.alloca() : memref<3xi64>
      %cast_8 = memref.cast %alloca_7 : memref<3xi64> to memref<?xi64>
      memref.store %c65536_i64, %alloca_7[%c0] : memref<3xi64>
      memref.store %c65536_i64, %alloca_7[%c1] : memref<3xi64>
      memref.store %c65536_i64, %alloca_7[%c2] : memref<3xi64>
      %alloca_9 = memref.alloca() : memref<3xindex>
      %cast_10 = memref.cast %alloca_9 : memref<3xindex> to memref<?xindex>
      memref.store %24, %alloca_9[%c0] : memref<3xindex>
      memref.store %arg6, %alloca_9[%c1] : memref<3xindex>
      memref.store %arg7, %alloca_9[%c2] : memref<3xindex>
      %alloca_11 = memref.alloca() : memref<3xindex>
      %cast_12 = memref.cast %alloca_11 : memref<3xindex> to memref<?xindex>
      memref.store %c0, %alloca_11[%c0] : memref<3xindex>
      memref.store %c1, %alloca_11[%c1] : memref<3xindex>
      memref.store %c2, %alloca_11[%c2] : memref<3xindex>
      %26 = func.call @newSparseTensor(%cast_10, %cast_10, %cast_8, %cast_12, %cast_12, %c0_i32, %c0_i32, %c2_i32, %c0_i32, %0) : (memref<?xindex>, memref<?xindex>, memref<?xi64>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr
      %27 = func.call @sparseValuesF32(%23) : (!llvm.ptr) -> memref<?xf32>
      %28 = func.call @sparseValuesF32(%26) : (!llvm.ptr) -> memref<?xf32>
      %29 = func.call @sparseLvlSize(%23, %c0) : (!llvm.ptr, index) -> index
      %30 = func.call @sparseLvlSize(%23, %c1) : (!llvm.ptr, index) -> index
      %31 = func.call @sparseLvlSize(%26, %c1) : (!llvm.ptr, index) -> index
      %32 = func.call @sparseLvlSize(%26, %c2) : (!llvm.ptr, index) -> index
      kokkos.sync %27 {memorySpace = 1 : i64} : memref<?xf32>
      kokkos.sync %28 {memorySpace = 1 : i64} : memref<?xf32>
      kokkos.modify %28 {memorySpace = 1 : i64} : memref<?xf32>
      "kokkos.team_parallel"(%29, %15, %30) ({
      ^bb0(%arg11: index, %arg12: index, %arg13: index, %arg14: index):
        %50 = arith.muli %arg13, %31 : index
        %51 = arith.muli %arg13, %30 : index
        kokkos.range_parallel (%arg15) -> (%15) {
          %52 = arith.addi %arg15, %50 : index
          %53 = arith.muli %arg15, %16 : index
          %54 = arith.muli %52, %32 : index
          scf.for %arg16 = %c0 to %16 step %c1 {
            %55 = arith.addi %arg16, %53 : index
            %56 = arith.addi %arg16, %54 : index
            %57 = memref.load %28[%56] : memref<?xf32>
            %58 = arith.muli %55, %17 : index
            %59 = kokkos.range_parallel (%arg17) -> (%30) -> f32 {
              %60 = arith.addi %arg17, %51 : index
              %61 = arith.addi %arg17, %58 : index
              %62 = memref.load %27[%60] : memref<?xf32>
              %63 = memref.load %14[%61] : memref<?xf32>
              %64 = arith.mulf %62, %63 : f32
              "kokkos.update_reduction"(%64, %57) ({
              ^bb0(%arg18: f32, %arg19: f32):
                %65 = arith.addf %arg18, %arg19 : f32
                kokkos.yield %65 : f32
              }) : (f32, f32) -> ()
              kokkos.yield
            } {executionSpace = 2 : i64, parallelLevel = 3 : i64}
            "kokkos.single"() <{level = 1 : i64}> ({
              memref.store %59, %28[%56] : memref<?xf32>
              kokkos.yield
            }) : () -> ()
          }
          kokkos.yield
        } {executionSpace = 2 : i64, parallelLevel = 2 : i64}
        "kokkos.team_barrier"() : () -> ()
        kokkos.yield
      }) : (index, index, index) -> ()
      %33 = func.call @sparseValuesF32(%25) : (!llvm.ptr) -> memref<?xf32>
      %34 = func.call @sparseValuesF32(%26) : (!llvm.ptr) -> memref<?xf32>
      %35 = func.call @sparseValuesF32(%13) : (!llvm.ptr) -> memref<?xf32>
      %36 = func.call @sparseLvlSize(%25, %c0) : (!llvm.ptr, index) -> index
      %37 = func.call @sparsePositions0(%25, %c1) : (!llvm.ptr, index) -> memref<?xindex>
      %38 = func.call @sparseCoordinates0(%25, %c1) : (!llvm.ptr, index) -> memref<?xindex>
      %39 = func.call @sparseLvlSize(%25, %c2) : (!llvm.ptr, index) -> index
      %40 = func.call @sparseLvlSize(%26, %c1) : (!llvm.ptr, index) -> index
      %41 = func.call @sparseLvlSize(%26, %c2) : (!llvm.ptr, index) -> index
      %42 = func.call @sparseLvlSize(%13, %c1) : (!llvm.ptr, index) -> index
      %43 = func.call @sparseLvlSize(%13, %c2) : (!llvm.ptr, index) -> index
      kokkos.sync %37 {memorySpace = 0 : i64} : memref<?xindex>
      %44 = memref.load %37[%36] : memref<?xindex>
      kokkos.sync %37 {memorySpace = 0 : i64} : memref<?xindex>
      %45 = memref.load %37[%c0] : memref<?xindex>
      %46 = arith.subi %44, %45 : index
      %47 = arith.addi %46, %36 : index
      %48 = arith.subi %47, %c1 : index
      %49 = arith.divui %48, %36 : index
      kokkos.sync %35 {memorySpace = 1 : i64} : memref<?xf32>
      kokkos.modify %35 {memorySpace = 1 : i64} : memref<?xf32>
      kokkos.sync %34 {memorySpace = 1 : i64} : memref<?xf32>
      kokkos.sync %38 {memorySpace = 1 : i64} : memref<?xindex>
      kokkos.sync %37 {memorySpace = 1 : i64} : memref<?xindex>
      kokkos.sync %33 {memorySpace = 1 : i64} : memref<?xf32>
      "kokkos.team_parallel"(%36, %49, %39) ({
      ^bb0(%arg11: index, %arg12: index, %arg13: index, %arg14: index):
        %50 = memref.load %37[%arg13] : memref<?xindex>
        %51 = arith.addi %arg13, %c1 : index
        %52 = memref.load %37[%51] : memref<?xindex>
        %53 = arith.muli %arg13, %42 : index
        %54 = arith.subi %52, %50 : index
        kokkos.range_parallel (%arg15) -> (%54) {
          %55 = arith.addi %50, %arg15 : index
          %56 = memref.load %38[%55] : memref<?xindex>
          %57 = arith.muli %56, %40 : index
          %58 = arith.muli %55, %39 : index
          scf.for %arg16 = %c0 to %40 step %c1 {
            %59 = arith.addi %arg16, %57 : index
            %60 = arith.addi %arg16, %53 : index
            %61 = arith.muli %59, %41 : index
            %62 = arith.muli %60, %43 : index
            kokkos.range_parallel (%arg17) -> (%39) {
              %63 = arith.addi %arg17, %58 : index
              %64 = arith.addi %arg17, %61 : index
              %65 = arith.addi %arg17, %62 : index
              %66 = memref.load %33[%63] : memref<?xf32>
              %67 = memref.load %34[%64] : memref<?xf32>
              %68 = arith.mulf %66, %67 : f32
              %69 = memref.load %35[%65] : memref<?xf32>
              %70 = arith.addf %68, %69 : f32
              memref.store %70, %35[%65] : memref<?xf32>
              kokkos.yield
            } {executionSpace = 2 : i64, parallelLevel = 3 : i64}
          }
          kokkos.yield
        } {executionSpace = 2 : i64, parallelLevel = 2 : i64}
        "kokkos.team_barrier"() : () -> ()
        kokkos.yield
      }) : (index, index, index) -> ()
      func.call @delSparseTensor(%26) : (!llvm.ptr) -> ()
      func.call @delSparseTensor(%25) : (!llvm.ptr) -> ()
    }
    return %13 : !llvm.ptr
  }
}

lowered.cpp

#include <Kokkos_Core.hpp>
#include <type_traits>
#include <cstdint>
#include <unistd.h>
#include <iostream>

template <typename T, int N>
struct StridedMemRefType {
  T *basePtr;
  T *data;
  int64_t offset;
  int64_t sizes[N];
  int64_t strides[N];
};

namespace LAPIS
{
  using TeamPolicy = Kokkos::TeamPolicy<>;
  using TeamMember = typename TeamPolicy::member_type;

  template<typename V>
    StridedMemRefType<typename V::value_type, V::rank> viewToStridedMemref(const V& v)
    {
      StridedMemRefType<typename V::value_type, V::rank> smr;
      smr.basePtr = v.data();
      smr.data = v.data();
      smr.offset = 0;
      for(int i = 0; i < int(V::rank); i++)
      {
        smr.sizes[i] = v.extent(i);
        smr.strides[i] = v.stride(i);
      }
      return smr;
    }

  template<typename V>
    V stridedMemrefToView(const StridedMemRefType<typename V::value_type, V::rank>& smr)
    {
      using Layout = typename V::array_layout;
      static_assert(std::is_same_v<typename V::memory_space, Kokkos::HostSpace> ||
          std::is_same_v<typename V::memory_space, Kokkos::AnonymousSpace>,
          "Can only convert a StridedMemRefType to a Kokkos::View in HostSpace.");
      if constexpr(std::is_same_v<Layout, Kokkos::LayoutStride>)
      {
        size_t extents[8] = {0};
        size_t strides[8] = {0};
        for(int i = 0; i < V::rank; i++) {
          extents[i] = smr.sizes[i];
          strides[i] = smr.strides[i];
        }
        Layout layout(
            extents[0], strides[0],
            extents[1], strides[1],
            extents[2], strides[2],
            extents[3], strides[3],
            extents[4], strides[4],
            extents[5], strides[5],
            extents[6], strides[6],
            extents[7], strides[7]);
        return V(&smr.data[smr.offset], layout);
      }
      size_t extents[8] = {
        KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX,
        KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX, KOKKOS_INVALID_INDEX};
      for(int i = 0; i < V::rank; i++)
        extents[i] = smr.sizes[i];
      Layout layout(
          extents[0], extents[1], extents[2], extents[3],
          extents[4], extents[5], extents[6], extents[7]);
      if constexpr(std::is_same_v<Layout, Kokkos::LayoutLeft>)
      {
        int64_t expectedStride = 1;
        for(int i = 0; i < int(V::rank); i++)
        {
          if(expectedStride != smr.strides[i])
            Kokkos::abort("Cannot shallow-copy StridedMemRefType that is not contiguous and LayoutLeft to LayoutLeft Kokkos::View");
          expectedStride *= smr.sizes[i];
        }
      }
      else if constexpr(std::is_same_v<Layout, Kokkos::LayoutRight>)
      {
        int64_t expectedStride = 1;
        for(int i = int(V::rank) - 1; i >= 0; i--)
        {
          if(expectedStride != smr.strides[i])
            Kokkos::abort("Cannot shallow-copy StridedMemRefType that is not contiguous and LayoutRight to LayoutRight Kokkos::View");
          expectedStride *= smr.sizes[i];
        }
      }
      return V(&smr.data[smr.offset], layout);
    }

  struct DualViewBase
  {
    virtual ~DualViewBase() {}
    virtual void syncHost() = 0;
    virtual void syncDevice() = 0;
    bool modified_host = false;
    bool modified_device = false;
    DualViewBase* parent;
  };

  template<typename DataType, typename Layout>
    struct DualView : public DualViewBase
  {
    using HostView = Kokkos::View<DataType, Layout, Kokkos::DefaultHostExecutionSpace>;
    using DeviceView = Kokkos::View<DataType, Layout, Kokkos::DefaultExecutionSpace>;

    static constexpr bool deviceAccessesHost = Kokkos::SpaceAccessibility<Kokkos::DefaultHostExecutionSpace, typename DeviceView::memory_space>::accessible;
    static constexpr bool hostAccessesDevice = Kokkos::SpaceAccessibility<Kokkos::DefaultHostExecutionSpace, typename DeviceView::memory_space>::accessible;

    // Default constructor makes empty views and self as parent.
    DualView() : device_view(), host_view() {
      parent = this;
    }

    // Constructor for allocating a new view.
    // Does not actually allocate anything yet; instead 
    DualView(
        const std::string& label,
        size_t ex0 = KOKKOS_INVALID_INDEX, size_t ex1 = KOKKOS_INVALID_INDEX, size_t ex2 = KOKKOS_INVALID_INDEX, size_t ex3 = KOKKOS_INVALID_INDEX,
        size_t ex4 = KOKKOS_INVALID_INDEX, size_t ex5 = KOKKOS_INVALID_INDEX, size_t ex6 = KOKKOS_INVALID_INDEX, size_t ex7 = KOKKOS_INVALID_INDEX)
    {
      if constexpr(hostAccessesDevice) {
        device_view = DeviceView(Kokkos::view_alloc(Kokkos::WithoutInitializing, label + "_dev"), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
        host_view = HostView(device_view.data(), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
      }
      else if constexpr(deviceAccessesHost) {
        // Otherwise, host_view must be a separate allocation.
        host_view = HostView(Kokkos::view_alloc(Kokkos::WithoutInitializing, label + "_host"), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
        device_view = DeviceView(host_view.data(), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
      }
      else {
        device_view = DeviceView(Kokkos::view_alloc(Kokkos::WithoutInitializing, label + "_dev"), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
        host_view = HostView(Kokkos::view_alloc(Kokkos::WithoutInitializing, label + "_host"), ex0, ex1, ex2, ex3, ex4, ex5, ex6, ex7);
      }
      parent = this;
    }

    // Constructor which is given explicit device and host views, and a parent.
    // This can be used for subviewing/casting operations.
    // Note: d,h should alias parent's memory, but they can
    // have a different data type and layout.
    DualView(DeviceView d, HostView h, DualViewBase* parent_)
      : device_view(d), host_view(h)
    {
      parent = parent_;
      // Walk up to the top-level DualView (which has itself as parent).
      // This is important because its modify flags must be used for itself and all children.
      // Children have their own flag members, but they are not used or kept in sync with parent.
      while(parent->parent != parent)
        parent = parent->parent;
    }

    // Constructor taking a host or device view
    template<typename DT, typename... Args>
    DualView(Kokkos::View<DT, Args...> v)
    {
      using ViewType = decltype(v);
      using Space = typename ViewType::memory_space;
      if constexpr(std::is_same_v<typename DeviceView::memory_space, Space>) {
        // Treat v like a device view, even though it's possible that DeviceView and HostView have the same type.
        // In this case, the host view will alias it.
        modified_device = true;
        if constexpr(deviceAccessesHost) {
          host_view = HostView(v.data(), v.layout());
        }
        else {
          host_view = HostView(Kokkos::view_alloc(Kokkos::WithoutInitializing, v.label() + "_host"), v.layout());
        }
        device_view = v;
      }
      else {
        modified_host = true;
        if constexpr(deviceAccessesHost) {
          device_view = DeviceView(v.data(), v.layout());
        }
        else {
          device_view = DeviceView(Kokkos::view_alloc(Kokkos::WithoutInitializing, v.label() + "_dev"), v.layout());
        }
        host_view = v;
      }
      parent = this;
    }

    // Copy-assignment equivalent to the above constructor.
    // Shallow copying a temporary DualView to a persistent one leaves the
    // persistent one in an invalid state, since its parent pointer still points to the temporary.
    //
    // Shallow-copy from one persistent DualView to another persistent or temporary is OK, as long
    // as the lifetime of original covers the lifetime of the copy.
    DualView& operator=(const HostView& h)
    {
      modified_host = true;
      if constexpr(deviceAccessesHost) {
        device_view = DeviceView(h.data(), h.layout());
      }
      else {
        device_view = DeviceView(Kokkos::view_alloc(Kokkos::WithoutInitializing, h.label() + "_dev"), h.layout());
      }
      host_view = h;
      parent = this;
      return *this;
    }

    // General shallow-copy from one DualView to another
    // (used by static -> dynamic conversion)
    template<typename OtherData, typename OtherLayout>
    DualView(const DualView<OtherData, OtherLayout>& other)
    {
      device_view = other.device_view;
      host_view = other.host_view;
      parent = other.parent;
    }

    void modifyHost()
    {
      parent->modified_host = true;
    }

    void modifyDevice()
    {
      parent->modified_device = true;
    }

    bool modifiedHost()
    {
      // note: parent may just point to this
      return parent->modified_host;
    }

    bool modifiedDevice()
    {
      // note: parent may just point to this
      return parent->modified_device;
    }

    void syncHost() override
    {
      if (device_view.data() == host_view.data()) {
        // Imitating Kokkos::DualView behavior: if device and host are the same space
        // then this sync (if required) is equivalent to a fence.
        if(parent->modified_device) {
          parent->modified_device = false;
          Kokkos::fence();
        }
      }
      else if (parent->modified_device) {
        if(parent == this) {
          Kokkos::deep_copy(host_view, device_view);
          modified_device = false;
        }
        else {
          parent->syncHost();
        }
      }
    }

    void syncDevice() override
    {
      // If host and device views are the same, do not sync or fence
      // because all host execution spaces are synchronous.
      // Any changes on the host side are immediately visible on the device side.
      if (device_view.data() != host_view.data()) {
        if(parent == this) {
          if(modified_host) {
            Kokkos::deep_copy(device_view, host_view);
            modified_host = false;
          }
        }
        else {
          parent->syncDevice();
        }
      }
    }

    void deallocate() {
      device_view = DeviceView();
      host_view = HostView();
    }

    size_t extent(int dim) {
      return device_view.extent(dim);
    }

    size_t stride(int dim) {
      return device_view.stride(dim);
    }

    DeviceView device_view;
    HostView host_view;
  };

  inline int threadParallelVectorLength(int par) {
    if (par < 1)
      return 1;
    int max_vector_length = TeamPolicy::vector_length_max();
    int vector_length = 1;
    while(vector_length < max_vector_length && vector_length * 6 < par) vector_length *= 2;
    return vector_length;
  }

  // KeepAlive structure keeps a reference to Kokkos::Views which
  // are returned to Python. Since it's difficult to transfer ownership of a
  // Kokkos::View's memory to numpy, we just have the Kokkos::View maintain ownership
  // and return an unmanaged numpy array to Python.
  //
  // All these views will be deallocated during lapis_finalize to avoid leaking.
  // The downside is that if a function is called many times,
  // all its results are kept in memory at the same time.
  struct KeepAlive
  {
    virtual ~KeepAlive() {}
  };

  template<typename T>
  struct KeepAliveT : public KeepAlive
  {
    // Make a shallow-copy of val
    KeepAliveT(const T& val) : p(new T(val)) {}
    std::unique_ptr<T> p;
  };

  static std::vector<std::unique_ptr<KeepAlive>> alives;

  template<typename T>
  void keepAlive(const T& val)
  {
    alives.emplace_back(new KeepAliveT(val));
  }
} // namespace LAPIS

#ifndef LAPIS_CPP_DRIVER
extern "C" void delSparseTensor(void*);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void _mlir_ciface_sparseCoordinates0(StridedMemRefType<size_t, 1>*, void*, size_t);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void _mlir_ciface_sparsePositions0(StridedMemRefType<size_t, 1>*, void*, size_t);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void _mlir_ciface_sparseValuesF32(StridedMemRefType<float, 1>*, void*);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void* _mlir_ciface_newSparseTensor(StridedMemRefType<size_t, 1>*, StridedMemRefType<size_t, 1>*, StridedMemRefType<int64_t, 1>*, StridedMemRefType<size_t, 1>*, StridedMemRefType<size_t, 1>*, int32_t, int32_t, int32_t, int32_t, void*);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" size_t sparseLvlSize(void*, size_t);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void* _mlir_ciface_mpi_getSliceForActiveMask(void*, StridedMemRefType<size_t, 1>*, size_t, size_t);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" size_t _mlir_ciface_mpi_getActiveMask(void*, StridedMemRefType<size_t, 1>*, size_t);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void* _mlir_ciface_mpi_getSlice(void*, StridedMemRefType<size_t, 1>*);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" void _mlir_ciface_mpi_getPartitions(StridedMemRefType<size_t, 1>*, void*);
#endif

#ifndef LAPIS_CPP_DRIVER
extern "C" size_t _mlir_ciface_mpi_getRank();
#endif

void concat_csrv_csrv(size_t, void*, size_t, size_t);

void* csr_to_csrv(void*, void*);

#ifndef LAPIS_CPP_DRIVER
extern "C" void overwrite_csrv_csrv(void*, void*, size_t, size_t);
#endif

void* extract_slice(size_t, size_t, size_t);

extern "C" void* pte_bspmm_tiled(void* v1, void* v2, size_t v3, void* v4, void* v5, size_t v6, size_t v7, size_t v8, size_t v9, size_t v10) {
  void* v11 = 0;
  Kokkos::View<size_t*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v12;
  {
    StridedMemRefType<size_t, 1> v12_smr;
    _mlir_ciface_mpi_getPartitions(&v12_smr, v1);
    v12 = LAPIS::stridedMemrefToView<Kokkos::View<size_t*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v12_smr);
  }
  ;
  size_t v13;
  {
    v13 = _mlir_ciface_mpi_getRank();
  }
  ;
  Kokkos::View<size_t[4], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v14(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v14"));
  size_t v15 = v13 * 4;
  size_t v16 = v12(v15);
  size_t v17 = v15 + 1;
  size_t v18 = v12(v17);
  size_t v19 = v15 + 2;
  size_t v20 = v12(v19);
  size_t v21 = v15 + 3;
  size_t v22 = v12(v21);
  v14(0) = v16;
  v14(1) = v18;
  v14(2) = v20;
  v14(3) = v22;
  void* v23;
  {
    StridedMemRefType<size_t, 1> v14_smr = LAPIS::viewToStridedMemref(v14);
    v23 = _mlir_ciface_mpi_getSlice(v1, &v14_smr);
  }
  ;
  size_t v24;
  {
    v24 = sparseLvlSize(v23, 0);
  }
  ;
  Kokkos::View<int64_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v25(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v25"));
  v25(0) = 65536;
  v25(1) = 65536;
  v25(2) = 65536;
  Kokkos::View<size_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v26(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v26"));
  v26(0) = v24;
  v26(1) = v7;
  v26(2) = v8;
  Kokkos::View<size_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v27(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v27"));
  v27(0) = 0;
  v27(1) = 1;
  v27(2) = 2;
  void* v28;
  {
    StridedMemRefType<size_t, 1> v26_smr = LAPIS::viewToStridedMemref(v26);
    StridedMemRefType<int64_t, 1> v25_smr = LAPIS::viewToStridedMemref(v25);
    StridedMemRefType<size_t, 1> v27_smr = LAPIS::viewToStridedMemref(v27);
    v28 = _mlir_ciface_newSparseTensor(&v26_smr, &v26_smr, &v25_smr, &v27_smr, &v27_smr, 0, 0, 2, 0, v11);
  }
  ;
  LAPIS::DualView<float*, Kokkos::LayoutRight> v29;
  {
    StridedMemRefType<float, 1> v29_smr;
    _mlir_ciface_sparseValuesF32(&v29_smr, v4);
    v29 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v29_smr);
  }
  ;
  size_t v30;
  {
    v30 = sparseLvlSize(v4, 0);
  }
  ;
  size_t v31;
  {
    v31 = sparseLvlSize(v4, 1);
  }
  ;
  size_t v32;
  {
    v32 = sparseLvlSize(v4, 2);
  }
  ;
  v29.syncDevice();
  for (size_t v33 = 0; v33 < v6; v33 += v10) {
    v14(1) = v33;
    size_t v34 = v33 + v10;
    v14(3) = v34;
    void* v35;
    {
      StridedMemRefType<size_t, 1> v14_smr = LAPIS::viewToStridedMemref(v14);
      v35 = _mlir_ciface_mpi_getSlice(v1, &v14_smr);
    }
    ;
    size_t v36;
    {
      StridedMemRefType<size_t, 1> v14_smr = LAPIS::viewToStridedMemref(v14);
      v36 = _mlir_ciface_mpi_getActiveMask(v1, &v14_smr, 1);
    }
    ;
    size_t v37 = v14(1);
    size_t v38 = v14(3);
    Kokkos::View<size_t[4], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v39(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v39"));
    v39(0) = v37;
    v39(1) = 0;
    v39(2) = v38;
    v39(3) = v9;
    void* v40;
    {
      StridedMemRefType<size_t, 1> v39_smr = LAPIS::viewToStridedMemref(v39);
      v40 = _mlir_ciface_mpi_getSliceForActiveMask(v2, &v39_smr, v36, 0);
    }
    ;
    size_t v41;
    {
      v41 = sparseLvlSize(v35, 1);
    }
    ;
    void* v42 = extract_slice(v3, 1, v37);
    Kokkos::View<int64_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v43(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v43"));
    v43(0) = 65536;
    v43(1) = 65536;
    v43(2) = 65536;
    Kokkos::View<size_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v44(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v44"));
    v44(0) = v41;
    v44(1) = v7;
    v44(2) = v8;
    Kokkos::View<size_t[3], Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace> v45(Kokkos::view_alloc(Kokkos::WithoutInitializing, "v45"));
    v45(0) = 0;
    v45(1) = 1;
    v45(2) = 2;
    void* v46;
    {
      StridedMemRefType<size_t, 1> v44_smr = LAPIS::viewToStridedMemref(v44);
      StridedMemRefType<int64_t, 1> v43_smr = LAPIS::viewToStridedMemref(v43);
      StridedMemRefType<size_t, 1> v45_smr = LAPIS::viewToStridedMemref(v45);
      v46 = _mlir_ciface_newSparseTensor(&v44_smr, &v44_smr, &v43_smr, &v45_smr, &v45_smr, 0, 0, 2, 0, v11);
    }
    ;
    LAPIS::DualView<float*, Kokkos::LayoutRight> v47;
    {
      StridedMemRefType<float, 1> v47_smr;
      _mlir_ciface_sparseValuesF32(&v47_smr, v40);
      v47 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v47_smr);
    }
    ;
    LAPIS::DualView<float*, Kokkos::LayoutRight> v48;
    {
      StridedMemRefType<float, 1> v48_smr;
      _mlir_ciface_sparseValuesF32(&v48_smr, v46);
      v48 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v48_smr);
    }
    ;
    size_t v49;
    {
      v49 = sparseLvlSize(v40, 0);
    }
    ;
    size_t v50;
    {
      v50 = sparseLvlSize(v40, 1);
    }
    ;
    size_t v51;
    {
      v51 = sparseLvlSize(v46, 1);
    }
    ;
    size_t v52;
    {
      v52 = sparseLvlSize(v46, 2);
    }
    ;
    v47.syncDevice();
    v48.syncDevice();
    v48.modifyDevice();
    auto lambda_v53 = 
    KOKKOS_LAMBDA(const LAPIS::TeamMember& team) {
      size_t v54 = team.league_rank() * v51;
      size_t v55 = team.league_rank() * v50;
      Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 0, v30),
      [=](size_t v56) {
        size_t v57 = v56 + v54;
        size_t v58 = v56 * v31;
        size_t v59 = v57 * v52;
        for (size_t v60 = 0; v60 < v31; v60 += 1) {
          size_t v61 = v60 + v58;
          size_t v62 = v60 + v59;
          float v63 = v48.device_view(v62);
          size_t v64 = v61 * v32;
          float v65;
          Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team, 0, v50),
          [=](size_t v66, float& lreduce2) {
            size_t v67 = v66 + v55;
            size_t v68 = v66 + v64;
            float v69 = v47.device_view(v67);
            float v70 = v29.device_view(v68);
            float v71 = v69 * v70;
            float v72 = lreduce2 + v71;
            lreduce2 = v72;
            ;
          }, Kokkos::Sum<float>(v65));
          Kokkos::single(Kokkos::PerThread(team), [&]() {
            v48.device_view(v62) = v65;
          });
        };
      });
      team.team_barrier();
    };
    size_t targetVectorLength_v73 = v50 ? v50 : 8;
    size_t vectorLength_v74 = Kokkos::min<size_t>(targetVectorLength_v73, LAPIS::TeamPolicy::vector_length_max());
    size_t teamSize_v75 = v30;
    if(teamSize_v75) {
      teamSize_v75 = Kokkos::min<size_t>(teamSize_v75, LAPIS::TeamPolicy(1, 1, vectorLength_v74).team_size_max(lambda_v53, Kokkos::ParallelForTag{}));
    }
    else {
      teamSize_v75 = LAPIS::TeamPolicy(1, 1, vectorLength_v74).team_size_recommended(lambda_v53, Kokkos::ParallelForTag{});
    }
    Kokkos::parallel_for(LAPIS::TeamPolicy(v49, teamSize_v75, vectorLength_v74), lambda_v53);
    LAPIS::DualView<float*, Kokkos::LayoutRight> v76;
    {
      StridedMemRefType<float, 1> v76_smr;
      _mlir_ciface_sparseValuesF32(&v76_smr, v42);
      v76 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v76_smr);
    }
    ;
    LAPIS::DualView<float*, Kokkos::LayoutRight> v77;
    {
      StridedMemRefType<float, 1> v77_smr;
      _mlir_ciface_sparseValuesF32(&v77_smr, v46);
      v77 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v77_smr);
    }
    ;
    LAPIS::DualView<float*, Kokkos::LayoutRight> v78;
    {
      StridedMemRefType<float, 1> v78_smr;
      _mlir_ciface_sparseValuesF32(&v78_smr, v28);
      v78 = LAPIS::stridedMemrefToView<Kokkos::View<float*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v78_smr);
    }
    ;
    size_t v79;
    {
      v79 = sparseLvlSize(v42, 0);
    }
    ;
    LAPIS::DualView<size_t*, Kokkos::LayoutRight> v80;
    {
      StridedMemRefType<size_t, 1> v80_smr;
      _mlir_ciface_sparsePositions0(&v80_smr, v42, 1);
      v80 = LAPIS::stridedMemrefToView<Kokkos::View<size_t*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v80_smr);
    }
    ;
    LAPIS::DualView<size_t*, Kokkos::LayoutRight> v81;
    {
      StridedMemRefType<size_t, 1> v81_smr;
      _mlir_ciface_sparseCoordinates0(&v81_smr, v42, 1);
      v81 = LAPIS::stridedMemrefToView<Kokkos::View<size_t*, Kokkos::LayoutRight, Kokkos::DefaultHostExecutionSpace>>(v81_smr);
    }
    ;
    size_t v82;
    {
      v82 = sparseLvlSize(v42, 2);
    }
    ;
    size_t v83;
    {
      v83 = sparseLvlSize(v46, 1);
    }
    ;
    size_t v84;
    {
      v84 = sparseLvlSize(v46, 2);
    }
    ;
    size_t v85;
    {
      v85 = sparseLvlSize(v28, 1);
    }
    ;
    size_t v86;
    {
      v86 = sparseLvlSize(v28, 2);
    }
    ;
    v80.syncHost();
    size_t v87 = v80.host_view(v79);
    v80.syncHost();
    size_t v88 = v80.host_view(0);
    size_t v89 = v87 - v88;
    size_t v90 = v89 + v79;
    size_t v91 = v90 - 1;
    size_t v92 = v91 / v79;
    v78.syncDevice();
    v78.modifyDevice();
    v77.syncDevice();
    v81.syncDevice();
    v80.syncDevice();
    v76.syncDevice();
    auto lambda_v93 = 
    KOKKOS_LAMBDA(const LAPIS::TeamMember& team) {
      size_t v94 = v80.device_view(team.league_rank());
      size_t v95 = team.league_rank() + 1;
      size_t v96 = v80.device_view(v95);
      size_t v97 = team.league_rank() * v85;
      size_t v98 = v96 - v94;
      Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 0, v98),
      [=](size_t v99) {
        size_t v100 = v94 + v99;
        size_t v101 = v81.device_view(v100);
        size_t v102 = v101 * v83;
        size_t v103 = v100 * v82;
        for (size_t v104 = 0; v104 < v83; v104 += 1) {
          size_t v105 = v104 + v102;
          size_t v106 = v104 + v97;
          size_t v107 = v105 * v84;
          size_t v108 = v106 * v86;
          Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 0, v82),
          [=](size_t v109) {
            size_t v110 = v109 + v103;
            size_t v111 = v109 + v107;
            size_t v112 = v109 + v108;
            float v113 = v76.device_view(v110);
            float v114 = v77.device_view(v111);
            float v115 = v113 * v114;
            float v116 = v78.device_view(v112);
            float v117 = v115 + v116;
            v78.device_view(v112) = v117;
          });
        };
      });
      team.team_barrier();
    };
    size_t targetVectorLength_v118 = v82 ? v82 : 8;
    size_t vectorLength_v119 = Kokkos::min<size_t>(targetVectorLength_v118, LAPIS::TeamPolicy::vector_length_max());
    size_t teamSize_v120 = v92;
    if(teamSize_v120) {
      teamSize_v120 = Kokkos::min<size_t>(teamSize_v120, LAPIS::TeamPolicy(1, 1, vectorLength_v119).team_size_max(lambda_v93, Kokkos::ParallelForTag{}));
    }
    else {
      teamSize_v120 = LAPIS::TeamPolicy(1, 1, vectorLength_v119).team_size_recommended(lambda_v93, Kokkos::ParallelForTag{});
    }
    Kokkos::parallel_for(LAPIS::TeamPolicy(v79, teamSize_v120, vectorLength_v119), lambda_v93);
    {
      delSparseTensor(v46);
    }
    ;
    {
      delSparseTensor(v42);
    }
    ;
  }
  v29.syncHost();
  v47.syncHost();
  v48.syncHost();
  v76.syncHost();
  v77.syncHost();
  v78.syncHost();
  v80.syncHost();
  v81.syncHost();
  return v28;
}



extern "C" void lapis_initialize()
{
  if (!Kokkos::is_initialized()) Kokkos::initialize();
  Kokkos::DefaultExecutionSpace().fence();
}

extern "C" void lapis_finalize()
{
  Kokkos::finalize();
}

In generated cpp, the syncHost calls are generated outside of loop (immediately after loop instead they should be inside the loop).