void spmv(int r, const double *val, const int *idx, const double *x,
          const int *ptr, double *y) {
  for (int i = 0; i < r; i++) {
    int k;
    double 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
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1285 <spmv+0x185>
movsd  -0x40(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
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    12ac <spmv+0x1ac>
mov    %edi,%r10d
mov    (%r8),%r15d
xor    %r14d,%r14d
jmp    1147 <spmv+0x47>
nopl   (%rax)
unpckhpd %xmm0,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r9,%r11,8)
cmp    %r10,%r14
je     12ac <spmv+0x1ac>
mov    %r14,%r11
mov    %r15d,%edi
mov    0x4(%r8,%r14,4),%r15d
movslq %r15d,%r13
lea    -0x3(%r13),%r14
xorpd  %xmm0,%xmm0
cmp    %r14d,%edi
jge    11f0 <spmv+0xf0>
movslq %edi,%rdi
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm2
movapd %xmm4,%xmm3
movslq (%rdx,%rdi,4),%rbp
movslq 0x4(%rdx,%rdi,4),%rax
movslq 0x8(%rdx,%rdi,4),%r12
movupd (%rsi,%rdi,8),%xmm1
movupd 0x10(%rsi,%rdi,8),%xmm4
movslq 0xc(%rdx,%rdi,4),%rbx
movsd  (%rcx,%rbp,8),%xmm0
movhpd (%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movsd  (%rcx,%r12,8),%xmm1
movhpd (%rcx,%rbx,8),%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm1,%xmm5
addpd  %xmm2,%xmm5
movapd %xmm0,%xmm4
addpd  %xmm3,%xmm4
add    $0x4,%rdi
cmp    %r14,%rdi
jl     1180 <spmv+0x80>
addpd  %xmm3,%xmm0
addpd  %xmm2,%xmm1
jmp    11f4 <spmv+0xf4>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
lea    0x1(%r11),%r14
movapd %xmm0,%xmm2
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     123c <spmv+0x13c>
nopl   0x0(%rax)
movsd  (%rsi,%rbx,8),%xmm3
movslq (%rdx,%rbx,4),%rdi
mulsd  (%rcx,%rdi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    1220 <spmv+0x120>
cmp    $0x3,%r12
jb     1120 <spmv+0x20>
cs nopw 0x0(%rax,%rax,1)
movslq (%rdx,%rbx,4),%rax
movsd  (%rsi,%rbx,8),%xmm3
movsd  0x8(%rsi,%rbx,8),%xmm4
mulsd  (%rcx,%rax,8),%xmm3
addsd  %xmm2,%xmm3
movslq 0x4(%rdx,%rbx,4),%rax
mulsd  (%rcx,%rax,8),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rsi,%rbx,8),%xmm3
movslq 0x8(%rdx,%rbx,4),%rax
mulsd  (%rcx,%rax,8),%xmm3
movsd  0x18(%rsi,%rbx,8),%xmm2
movslq 0xc(%rdx,%rbx,4),%rax
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1250 <spmv+0x150>
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, double* %1, i32* %2, double* %3, i32* %4, double* %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32*
%10 = alloca double*
%11 = alloca i32*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
store i32 %0, i32* %7
store double* %1, double** %8
store i32* %2, i32** %9
store double* %3, double** %10
store i32* %4, i32** %11
store double* %5, double** %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 double 0.000000e+00, double* %15
store double 0.000000e+00, double* %16
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %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 double*, double** %8
%41 = load i32, i32* %14
%42 = add nsw i32 %41, 0
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %40, i64 %43
%45 = load double, double* %44
%46 = load double*, double** %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 double, double* %46, i64 %53
%55 = load double, double* %54
%56 = load double, double* %15
%57 = call double @llvm.fmuladd.f64(double %45, double %55, double %56)
store double %57, double* %15
%58 = load double*, double** %8
%59 = load i32, i32* %14
%60 = add nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %58, i64 %61
%63 = load double, double* %62
%64 = load double*, double** %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 double, double* %64, i64 %71
%73 = load double, double* %72
%74 = load double, double* %16
%75 = call double @llvm.fmuladd.f64(double %63, double %73, double %74)
store double %75, double* %16
%76 = load double*, double** %8
%77 = load i32, i32* %14
%78 = add nsw i32 %77, 2
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %76, i64 %79
%81 = load double, double* %80
%82 = load double*, double** %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 double, double* %82, i64 %89
%91 = load double, double* %90
%92 = load double, double* %17
%93 = call double @llvm.fmuladd.f64(double %81, double %91, double %92)
store double %93, double* %17
%94 = load double*, double** %8
%95 = load i32, i32* %14
%96 = add nsw i32 %95, 3
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %94, i64 %97
%99 = load double, double* %98
%100 = load double*, double** %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 double, double* %100, i64 %107
%109 = load double, double* %108
%110 = load double, double* %18
%111 = call double @llvm.fmuladd.f64(double %99, double %109, double %110)
store double %111, double* %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 double*, double** %8
%127 = load i32, i32* %14
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %126, i64 %128
%130 = load double, double* %129
%131 = load double*, double** %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 double, double* %131, i64 %137
%139 = load double, double* %138
%140 = load double, double* %15
%141 = call double @llvm.fmuladd.f64(double %130, double %139, double %140)
store double %141, double* %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 double, double* %15
%147 = load double, double* %16
%148 = fadd double %146, %147
%149 = load double, double* %17
%150 = load double, double* %18
%151 = fadd double %149, %150
%152 = fadd double %148, %151
%153 = load double*, double** %12
%154 = load i32, i32* %13
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
store double %152, double* %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, double* nocapture %1, i32* nocapture %2, double* nocapture %3, i32* nocapture %4, double* 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 double> @llvm.fmuladd.v4f64(<4 x double> %82, <4 x double> %91, <4 x double> %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 double> [ zeroinitializer, %12 ], [ %24, %23 ]
%29 = icmp slt i32 %27, %17
%30 = extractelement <4 x double> %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 double [ %50, %39 ], [ %30, %31 ]
%42 = phi i64 [ %52, %39 ], [ 0, %31 ]
%43 = getelementptr inbounds double, double* %1, i64 %40
%44 = load double, double* %43
%45 = getelementptr inbounds i32, i32* %2, i64 %40
%46 = load i32, i32* %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %3, i64 %47
%49 = load double, double* %48
%50 = tail call double @llvm.fmuladd.f64(double %44, double %49, double %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 double [ undef, %31 ], [ %50, %39 ]
%56 = phi i64 [ %32, %31 ], [ %51, %39 ]
%57 = phi double [ %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 double> [ zeroinitializer, %20 ], [ %92, %59 ]
%62 = getelementptr inbounds double, double* %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 double, double* %3, i64 %65
%67 = load double, double* %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 double, double* %3, i64 %71
%73 = load double, double* %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 double, double* %3, i64 %77
%79 = load double, double* %78
%80 = add nsw i64 %60, 3
%81 = bitcast double* %62 to <4 x double>*
%82 = load <4 x double>, <4 x double>* %81
%83 = getelementptr inbounds i32, i32* %2, i64 %80
%84 = load i32, i32* %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %3, i64 %85
%87 = load double, double* %86
%88 = insertelement <4 x double> poison, double %67, i64 0
%89 = insertelement <4 x double> %88, double %73, i64 1
%90 = insertelement <4 x double> %89, double %79, i64 2
%91 = insertelement <4 x double> %90, double %87, i64 3
%92 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %82, <4 x double> %91, <4 x double> %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 double [ %132, %95 ], [ %57, %54 ]
%98 = getelementptr inbounds double, double* %1, i64 %96
%99 = load double, double* %98
%100 = getelementptr inbounds i32, i32* %2, i64 %96
%101 = load i32, i32* %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %3, i64 %102
%104 = load double, double* %103
%105 = tail call double @llvm.fmuladd.f64(double %99, double %104, double %97)
%106 = add nsw i64 %96, 1
%107 = getelementptr inbounds double, double* %1, i64 %106
%108 = load double, double* %107
%109 = getelementptr inbounds i32, i32* %2, i64 %106
%110 = load i32, i32* %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %3, i64 %111
%113 = load double, double* %112
%114 = tail call double @llvm.fmuladd.f64(double %108, double %113, double %105)
%115 = add nsw i64 %96, 2
%116 = getelementptr inbounds double, double* %1, i64 %115
%117 = load double, double* %116
%118 = getelementptr inbounds i32, i32* %2, i64 %115
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %3, i64 %120
%122 = load double, double* %121
%123 = tail call double @llvm.fmuladd.f64(double %117, double %122, double %114)
%124 = add nsw i64 %96, 3
%125 = getelementptr inbounds double, double* %1, i64 %124
%126 = load double, double* %125
%127 = getelementptr inbounds i32, i32* %2, i64 %124
%128 = load i32, i32* %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %3, i64 %129
%131 = load double, double* %130
%132 = tail call double @llvm.fmuladd.f64(double %126, double %131, double %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 double [ %30, %26 ], [ %55, %54 ], [ %132, %95 ]
%137 = extractelement <4 x double> %28, i64 1
%138 = fadd double %137, %136
%139 = extractelement <4 x double> %28, i64 2
%140 = extractelement <4 x double> %28, i64 3
%141 = fadd double %139, %140
%142 = fadd double %141, %138
%143 = getelementptr inbounds double, double* %5, i64 %14
store double %142, double* %143
%144 = icmp eq i64 %15, %9
br i1 %144, label %11, label %12
}