void spmv(int r, const float *val, const int *idx, const float *x,
          const int *ptr, float *y) {
  for (int i = 0; i < r; i++) {
    int k;
    float yi0 = 0, yi1 = 0, yi2 = 0, yi3 = 0;
    for (k = ptr[i]; k < ptr[i + 1] - 3; k += 4) {
      yi0 += val[k + 0] * x[idx[k + 0]];
      yi1 += val[k + 1] * x[idx[k + 1]];
      yi2 += val[k + 2] * x[idx[k + 2]];
      yi3 += val[k + 3] * x[idx[k + 3]];
    }
    for (; k < ptr[i + 1]; k++) {
      yi0 += val[k] * x[idx[k]];
    }
    y[i] = (yi0 + yi1) + (yi2 + yi3);
  }
}


x86 assembly (clang, -O0):
<spmv>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1313 <spmv+0x213>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1280 <spmv+0x180>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    115c <spmv+0x5c>
jmp    1285 <spmv+0x185>
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12e0 <spmv+0x1e0>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1285 <spmv+0x185>
movss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
addss  -0x48(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1122 <spmv+0x22>
pop    %rbp
ret

x86 assembly (clang, -O2):
<spmv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    127c <spmv+0x17c>
mov    %edi,%r10d
mov    (%r8),%r15d
xor    %r14d,%r14d
jmp    114c <spmv+0x4c>
nopl   (%rax)
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
addss  %xmm1,%xmm2
movaps %xmm0,%xmm1
shufps $0xff,%xmm0,%xmm1
movhlps %xmm0,%xmm0
addss  %xmm1,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%r9,%r11,4)
cmp    %r10,%r14
je     127c <spmv+0x17c>
mov    %r14,%r11
mov    %r15d,%edi
mov    0x4(%r8,%r14,4),%r15d
movslq %r15d,%r13
lea    -0x3(%r13),%r14
xorps  %xmm0,%xmm0
cmp    %r14d,%edi
jge    11bd <spmv+0xbd>
movslq %edi,%rdi
xorps  %xmm2,%xmm2
nopl   0x0(%rax)
movaps %xmm2,%xmm1
movslq (%rdx,%rdi,4),%r12
movslq 0x4(%rdx,%rdi,4),%rax
movslq 0x8(%rdx,%rdi,4),%rbx
movups (%rsi,%rdi,4),%xmm2
movslq 0xc(%rdx,%rdi,4),%rbp
movss  (%rcx,%rbp,4),%xmm0
movss  (%rcx,%rbx,4),%xmm3
unpcklps %xmm0,%xmm3
movss  (%rcx,%rax,4),%xmm4
movss  (%rcx,%r12,4),%xmm0
unpcklps %xmm4,%xmm0
movlhps %xmm3,%xmm0
mulps  %xmm2,%xmm0
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
add    $0x4,%rdi
cmp    %r14,%rdi
jl     1170 <spmv+0x70>
addps  %xmm1,%xmm0
lea    0x1(%r11),%r14
movaps %xmm0,%xmm1
cmp    %r15d,%edi
jge    1120 <spmv+0x20>
movslq %edi,%rbx
mov    %r15d,%ebp
sub    %edi,%ebp
mov    %rbx,%r12
not    %r12
add    %r13,%r12
and    $0x3,%rbp
je     120c <spmv+0x10c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsi,%rbx,4),%xmm2
movslq (%rdx,%rbx,4),%rdi
mulss  (%rcx,%rdi,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    11f0 <spmv+0xf0>
cmp    $0x3,%r12
jb     1120 <spmv+0x20>
cs nopw 0x0(%rax,%rax,1)
movslq (%rdx,%rbx,4),%rax
movss  (%rsi,%rbx,4),%xmm2
movss  0x4(%rsi,%rbx,4),%xmm3
mulss  (%rcx,%rax,4),%xmm2
addss  %xmm1,%xmm2
movslq 0x4(%rdx,%rbx,4),%rax
mulss  (%rcx,%rax,4),%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rsi,%rbx,4),%xmm2
movslq 0x8(%rdx,%rbx,4),%rax
mulss  (%rcx,%rax,4),%xmm2
movss  0xc(%rsi,%rbx,4),%xmm1
movslq 0xc(%rdx,%rbx,4),%rax
mulss  (%rcx,%rax,4),%xmm1
addss  %xmm3,%xmm2
addss  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1220 <spmv+0x120>
jmp    1120 <spmv+0x20>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @spmv(i32 %0, float* %1, i32* %2, float* %3, i32* %4, float* %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32*
%10 = alloca float*
%11 = alloca i32*
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store i32* %2, i32** %9
store float* %3, float** %10
store i32* %4, i32** %11
store float* %5, float** %12
store i32 0, i32* %13
br label %19
19: ; preds = %157, %6
%20 = load i32, i32* %13
%21 = load i32, i32* %7
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %160
23: ; preds = %19
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
%24 = load i32*, i32** %11
%25 = load i32, i32* %13
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
%28 = load i32, i32* %27
store i32 %28, i32* %14
br label %29
29: ; preds = %112, %23
%30 = load i32, i32* %14
%31 = load i32*, i32** %11
%32 = load i32, i32* %13
%33 = add nsw i32 %32, 1
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %31, i64 %34
%36 = load i32, i32* %35
%37 = sub nsw i32 %36, 3
%38 = icmp slt i32 %30, %37
br i1 %38, label %39, label %115
39: ; preds = %29
%40 = load float*, float** %8
%41 = load i32, i32* %14
%42 = add nsw i32 %41, 0
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %40, i64 %43
%45 = load float, float* %44
%46 = load float*, float** %10
%47 = load i32*, i32** %9
%48 = load i32, i32* %14
%49 = add nsw i32 %48, 0
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %47, i64 %50
%52 = load i32, i32* %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %46, i64 %53
%55 = load float, float* %54
%56 = load float, float* %15
%57 = call float @llvm.fmuladd.f32(float %45, float %55, float %56)
store float %57, float* %15
%58 = load float*, float** %8
%59 = load i32, i32* %14
%60 = add nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %58, i64 %61
%63 = load float, float* %62
%64 = load float*, float** %10
%65 = load i32*, i32** %9
%66 = load i32, i32* %14
%67 = add nsw i32 %66, 1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %65, i64 %68
%70 = load i32, i32* %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %64, i64 %71
%73 = load float, float* %72
%74 = load float, float* %16
%75 = call float @llvm.fmuladd.f32(float %63, float %73, float %74)
store float %75, float* %16
%76 = load float*, float** %8
%77 = load i32, i32* %14
%78 = add nsw i32 %77, 2
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %76, i64 %79
%81 = load float, float* %80
%82 = load float*, float** %10
%83 = load i32*, i32** %9
%84 = load i32, i32* %14
%85 = add nsw i32 %84, 2
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %83, i64 %86
%88 = load i32, i32* %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %82, i64 %89
%91 = load float, float* %90
%92 = load float, float* %17
%93 = call float @llvm.fmuladd.f32(float %81, float %91, float %92)
store float %93, float* %17
%94 = load float*, float** %8
%95 = load i32, i32* %14
%96 = add nsw i32 %95, 3
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %94, i64 %97
%99 = load float, float* %98
%100 = load float*, float** %10
%101 = load i32*, i32** %9
%102 = load i32, i32* %14
%103 = add nsw i32 %102, 3
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %101, i64 %104
%106 = load i32, i32* %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %100, i64 %107
%109 = load float, float* %108
%110 = load float, float* %18
%111 = call float @llvm.fmuladd.f32(float %99, float %109, float %110)
store float %111, float* %18
br label %112
112: ; preds = %39
%113 = load i32, i32* %14
%114 = add nsw i32 %113, 4
store i32 %114, i32* %14
br label %29
115: ; preds = %29
br label %116
116: ; preds = %142, %115
%117 = load i32, i32* %14
%118 = load i32*, i32** %11
%119 = load i32, i32* %13
%120 = add nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %118, i64 %121
%123 = load i32, i32* %122
%124 = icmp slt i32 %117, %123
br i1 %124, label %125, label %145
125: ; preds = %116
%126 = load float*, float** %8
%127 = load i32, i32* %14
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float, float* %129
%131 = load float*, float** %10
%132 = load i32*, i32** %9
%133 = load i32, i32* %14
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %132, i64 %134
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %131, i64 %137
%139 = load float, float* %138
%140 = load float, float* %15
%141 = call float @llvm.fmuladd.f32(float %130, float %139, float %140)
store float %141, float* %15
br label %142
142: ; preds = %125
%143 = load i32, i32* %14
%144 = add nsw i32 %143, 1
store i32 %144, i32* %14
br label %116
145: ; preds = %116
%146 = load float, float* %15
%147 = load float, float* %16
%148 = fadd float %146, %147
%149 = load float, float* %17
%150 = load float, float* %18
%151 = fadd float %149, %150
%152 = fadd float %148, %151
%153 = load float*, float** %12
%154 = load i32, i32* %13
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
store float %152, float* %156
br label %157
157: ; preds = %145
%158 = load i32, i32* %13
%159 = add nsw i32 %158, 1
store i32 %159, i32* %13
br label %19
160: ; preds = %19
ret void
}

LLVM IR (-O2):
define void @spmv(i32 %0, float* nocapture %1, i32* nocapture %2, float* nocapture %3, i32* nocapture %4, float* nocapture writeonly %5) {
%7 = icmp sgt i32 %0, 0
br i1 %7, label %8, label %11
8: ; preds = %6
%9 = zext i32 %0 to i64
%10 = load i32, i32* %4
br label %12
11: ; preds = %135, %6
ret void
12: ; preds = %8, %135
%13 = phi i32 [ %10, %8 ], [ %17, %135 ]
%14 = phi i64 [ 0, %8 ], [ %15, %135 ]
%15 = add nuw nsw i64 %14, 1
%16 = getelementptr inbounds i32, i32* %4, i64 %15
%17 = load i32, i32* %16
%18 = add nsw i32 %17, -3
%19 = icmp slt i32 %13, %18
br i1 %19, label %20, label %26
20: ; preds = %12
%21 = sext i32 %13 to i64
%22 = sext i32 %18 to i64
br label %59
23: ; preds = %59
%24 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %82, <4 x float> %91, <4 x float> %61)
%25 = trunc i64 %93 to i32
br label %26
26: ; preds = %23, %12
%27 = phi i32 [ %13, %12 ], [ %25, %23 ]
%28 = phi <4 x float> [ zeroinitializer, %12 ], [ %24, %23 ]
%29 = icmp slt i32 %27, %17
%30 = extractelement <4 x float> %28, i64 0
br i1 %29, label %31, label %135
31: ; preds = %26
%32 = sext i32 %27 to i64
%33 = sext i32 %17 to i64
%34 = sub nsw i64 %33, %32
%35 = xor i64 %32, -1
%36 = add nsw i64 %35, %33
%37 = and i64 %34, 3
%38 = icmp eq i64 %37, 0
br i1 %38, label %54, label %39
39: ; preds = %31, %39
%40 = phi i64 [ %51, %39 ], [ %32, %31 ]
%41 = phi float [ %50, %39 ], [ %30, %31 ]
%42 = phi i64 [ %52, %39 ], [ 0, %31 ]
%43 = getelementptr inbounds float, float* %1, i64 %40
%44 = load float, float* %43
%45 = getelementptr inbounds i32, i32* %2, i64 %40
%46 = load i32, i32* %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %3, i64 %47
%49 = load float, float* %48
%50 = tail call float @llvm.fmuladd.f32(float %44, float %49, float %41)
%51 = add nsw i64 %40, 1
%52 = add i64 %42, 1
%53 = icmp eq i64 %52, %37
br i1 %53, label %54, label %39
54: ; preds = %39, %31
%55 = phi float [ undef, %31 ], [ %50, %39 ]
%56 = phi i64 [ %32, %31 ], [ %51, %39 ]
%57 = phi float [ %30, %31 ], [ %50, %39 ]
%58 = icmp ult i64 %36, 3
br i1 %58, label %135, label %95
59: ; preds = %20, %59
%60 = phi i64 [ %21, %20 ], [ %93, %59 ]
%61 = phi <4 x float> [ zeroinitializer, %20 ], [ %92, %59 ]
%62 = getelementptr inbounds float, float* %1, i64 %60
%63 = getelementptr inbounds i32, i32* %2, i64 %60
%64 = load i32, i32* %63
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %3, i64 %65
%67 = load float, float* %66
%68 = add nsw i64 %60, 1
%69 = getelementptr inbounds i32, i32* %2, i64 %68
%70 = load i32, i32* %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %3, i64 %71
%73 = load float, float* %72
%74 = add nsw i64 %60, 2
%75 = getelementptr inbounds i32, i32* %2, i64 %74
%76 = load i32, i32* %75
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %3, i64 %77
%79 = load float, float* %78
%80 = add nsw i64 %60, 3
%81 = bitcast float* %62 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = getelementptr inbounds i32, i32* %2, i64 %80
%84 = load i32, i32* %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %3, i64 %85
%87 = load float, float* %86
%88 = insertelement <4 x float> poison, float %67, i64 0
%89 = insertelement <4 x float> %88, float %73, i64 1
%90 = insertelement <4 x float> %89, float %79, i64 2
%91 = insertelement <4 x float> %90, float %87, i64 3
%92 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %82, <4 x float> %91, <4 x float> %61)
%93 = add nsw i64 %60, 4
%94 = icmp slt i64 %93, %22
br i1 %94, label %59, label %23
95: ; preds = %54, %95
%96 = phi i64 [ %133, %95 ], [ %56, %54 ]
%97 = phi float [ %132, %95 ], [ %57, %54 ]
%98 = getelementptr inbounds float, float* %1, i64 %96
%99 = load float, float* %98
%100 = getelementptr inbounds i32, i32* %2, i64 %96
%101 = load i32, i32* %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %3, i64 %102
%104 = load float, float* %103
%105 = tail call float @llvm.fmuladd.f32(float %99, float %104, float %97)
%106 = add nsw i64 %96, 1
%107 = getelementptr inbounds float, float* %1, i64 %106
%108 = load float, float* %107
%109 = getelementptr inbounds i32, i32* %2, i64 %106
%110 = load i32, i32* %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %3, i64 %111
%113 = load float, float* %112
%114 = tail call float @llvm.fmuladd.f32(float %108, float %113, float %105)
%115 = add nsw i64 %96, 2
%116 = getelementptr inbounds float, float* %1, i64 %115
%117 = load float, float* %116
%118 = getelementptr inbounds i32, i32* %2, i64 %115
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %3, i64 %120
%122 = load float, float* %121
%123 = tail call float @llvm.fmuladd.f32(float %117, float %122, float %114)
%124 = add nsw i64 %96, 3
%125 = getelementptr inbounds float, float* %1, i64 %124
%126 = load float, float* %125
%127 = getelementptr inbounds i32, i32* %2, i64 %124
%128 = load i32, i32* %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %3, i64 %129
%131 = load float, float* %130
%132 = tail call float @llvm.fmuladd.f32(float %126, float %131, float %123)
%133 = add nsw i64 %96, 4
%134 = icmp eq i64 %133, %33
br i1 %134, label %135, label %95
135: ; preds = %54, %95, %26
%136 = phi float [ %30, %26 ], [ %55, %54 ], [ %132, %95 ]
%137 = extractelement <4 x float> %28, i64 1
%138 = fadd float %137, %136
%139 = shufflevector <4 x float> %28, <4 x float> poison, <4 x i32> <i32 undef, i32 undef, i32 3, i32 undef>
%140 = fadd <4 x float> %28, %139
%141 = extractelement <4 x float> %140, i64 2
%142 = fadd float %141, %138
%143 = getelementptr inbounds float, float* %5, i64 %14
store float %142, float* %143
%144 = icmp eq i64 %15, %9
br i1 %144, label %11, label %12
}