void daxpy_(int n, double da, double *dx, double *dy) {
  int i, m;
  if (n <= 0 || da == 0) {
    return;
  }
  m = n % 4;
  if (m != 0) {
    for (i = 0; i < m; ++i) {
      dy[i] += da * dx[i];
    }
    if (n < 4) {
      return;
    }
  }
  for (i = m; i < n; i += 4) {
    dy[i] += da * dx[i];
    dy[i + 1] += da * dx[i + 1];
    dy[i + 2] += da * dx[i + 2];
    dy[i + 3] += da * dx[i + 3];
  }
}


x86 assembly (clang, -O0):
<daxpy_>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1136 <daxpy_+0x36>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    113b <daxpy_+0x3b>
jp     113b <daxpy_+0x3b>
jmp    12a2 <daxpy_+0x1a2>
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
je     11b4 <daxpy_+0xb4>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11a0 <daxpy_+0xa0>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    115a <daxpy_+0x5a>
cmpl   $0x4,-0x4(%rbp)
jge    11af <daxpy_+0xaf>
jmp    12a2 <daxpy_+0x1a2>
jmp    11b4 <daxpy_+0xb4>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a2 <daxpy_+0x1a2>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
jmp    11ba <daxpy_+0xba>
pop    %rbp
ret

x86 assembly (clang, -O2):
<daxpy_>:
push   %r14
push   %rbx
test   %edi,%edi
jle    134e <daxpy_+0x24e>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    111b <daxpy_+0x1b>
jnp    134e <daxpy_+0x24e>
mov    %edi,%r10d
and    $0x3,%r10d
je     1170 <daxpy_+0x70>
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
cmp    $0x1,%r10d
je     1166 <daxpy_+0x66>
movsd  0x8(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx),%xmm1
movsd  %xmm1,0x8(%rdx)
cmp    $0x2,%r10d
je     1166 <daxpy_+0x66>
movsd  0x10(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx),%xmm1
movsd  %xmm1,0x10(%rdx)
cmp    $0x3,%edi
jg     1179 <daxpy_+0x79>
jmp    134e <daxpy_+0x24e>
cmp    $0x4,%edi
jb     134e <daxpy_+0x24e>
mov    %edi,%r11d
lea    0x4(%r10),%rax
cmp    %r11,%rax
mov    %r11,%r8
cmova  %rax,%r8
mov    %r10,%rcx
not    %rcx
add    %rcx,%r8
cmp    $0x4,%r8
jae    11a1 <daxpy_+0xa1>
mov    %r10,%rdi
jmp    12f0 <daxpy_+0x1f0>
cmp    %r11,%rax
cmovbe %r11,%rax
lea    (%rdx,%r10,8),%rdi
add    %rcx,%rax
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
and    %rax,%rcx
or     %r10,%rcx
lea    (%rsi,%rcx,8),%rax
add    $0x20,%rax
cmp    %rax,%rdi
jae    11e5 <daxpy_+0xe5>
lea    (%rdx,%rcx,8),%rax
add    $0x20,%rax
lea    (%rsi,%r10,8),%rcx
cmp    %rax,%rcx
jae    11e5 <daxpy_+0xe5>
mov    %r10,%rdi
jmp    12f0 <daxpy_+0x1f0>
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
lea    (%r10,%r9,4),%rdi
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %ecx,%ecx
mov    %r9,%r14
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rbx
or     %r10,%rbx
lea    0x0(,%rbx,8),%rax
or     $0x20,%rax
movsd  (%rsi,%rbx,8),%xmm5
movsd  0x8(%rsi,%rbx,8),%xmm2
movsd  0x10(%rsi,%rbx,8),%xmm3
movsd  0x18(%rsi,%rbx,8),%xmm4
movhpd (%rsi,%rax,1),%xmm5
movsd  (%rdx,%rbx,8),%xmm6
movsd  0x8(%rdx,%rbx,8),%xmm7
movsd  0x10(%rdx,%rbx,8),%xmm1
movsd  0x18(%rdx,%rbx,8),%xmm9
movhpd (%rdx,%rax,1),%xmm6
mulpd  %xmm8,%xmm5
addpd  %xmm6,%xmm5
movhpd 0x28(%rsi,%rbx,8),%xmm2
movhpd 0x28(%rdx,%rbx,8),%xmm7
mulpd  %xmm8,%xmm2
addpd  %xmm7,%xmm2
movhpd 0x30(%rsi,%rbx,8),%xmm3
movhpd 0x30(%rdx,%rbx,8),%xmm1
mulpd  %xmm8,%xmm3
addpd  %xmm1,%xmm3
movhpd 0x38(%rsi,%rbx,8),%xmm4
movhpd 0x38(%rdx,%rbx,8),%xmm9
mulpd  %xmm8,%xmm4
addpd  %xmm9,%xmm4
movapd %xmm5,%xmm1
unpcklpd %xmm2,%xmm1
movhlps %xmm5,%xmm2
movapd %xmm3,%xmm5
unpcklpd %xmm4,%xmm5
movhlps %xmm3,%xmm4
movups %xmm4,0x30(%rdx,%rbx,8)
movupd %xmm5,0x10(%rdx,%rbx,8)
movups %xmm2,0x20(%rdx,%rbx,8)
movupd %xmm1,(%rdx,%rbx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r14
jne    1210 <daxpy_+0x110>
cmp    %r9,%r8
je     134e <daxpy_+0x24e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rdi,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rdi,8)
movsd  0x10(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rdi,8)
movsd  0x18(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdx,%rdi,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rdi,8)
add    $0x4,%rdi
cmp    %r11,%rdi
jb     12f0 <daxpy_+0x1f0>
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @daxpy_(i32 %0, double %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca double
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %5
store double %1, double* %6
store double* %2, double** %7
store double* %3, double** %8
%11 = load i32, i32* %5
%12 = icmp sle i32 %11, 0
br i1 %12, label %16, label %13
13: ; preds = %4
%14 = load double, double* %6
%15 = fcmp oeq double %14, 0.000000e+00
br i1 %15, label %16, label %17
16: ; preds = %13, %4
br label %112
17: ; preds = %13
%18 = load i32, i32* %5
%19 = srem i32 %18, 4
store i32 %19, i32* %10
%20 = load i32, i32* %10
%21 = icmp ne i32 %20, 0
br i1 %21, label %22, label %48
22: ; preds = %17
store i32 0, i32* %9
br label %23
23: ; preds = %40, %22
%24 = load i32, i32* %9
%25 = load i32, i32* %10
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %43
27: ; preds = %23
%28 = load double, double* %6
%29 = load double*, double** %7
%30 = load i32, i32* %9
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = load double*, double** %8
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = call double @llvm.fmuladd.f64(double %28, double %33, double %38)
store double %39, double* %37
br label %40
40: ; preds = %27
%41 = load i32, i32* %9
%42 = add nsw i32 %41, 1
store i32 %42, i32* %9
br label %23
43: ; preds = %23
%44 = load i32, i32* %5
%45 = icmp slt i32 %44, 4
br i1 %45, label %46, label %47
46: ; preds = %43
br label %112
47: ; preds = %43
br label %48
48: ; preds = %47, %17
%49 = load i32, i32* %10
store i32 %49, i32* %9
br label %50
50: ; preds = %109, %48
%51 = load i32, i32* %9
%52 = load i32, i32* %5
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %112
54: ; preds = %50
%55 = load double, double* %6
%56 = load double*, double** %7
%57 = load i32, i32* %9
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
%60 = load double, double* %59
%61 = load double*, double** %8
%62 = load i32, i32* %9
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %61, i64 %63
%65 = load double, double* %64
%66 = call double @llvm.fmuladd.f64(double %55, double %60, double %65)
store double %66, double* %64
%67 = load double, double* %6
%68 = load double*, double** %7
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %68, i64 %71
%73 = load double, double* %72
%74 = load double*, double** %8
%75 = load i32, i32* %9
%76 = add nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %74, i64 %77
%79 = load double, double* %78
%80 = call double @llvm.fmuladd.f64(double %67, double %73, double %79)
store double %80, double* %78
%81 = load double, double* %6
%82 = load double*, double** %7
%83 = load i32, i32* %9
%84 = add nsw i32 %83, 2
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %82, i64 %85
%87 = load double, double* %86
%88 = load double*, double** %8
%89 = load i32, i32* %9
%90 = add nsw i32 %89, 2
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %88, i64 %91
%93 = load double, double* %92
%94 = call double @llvm.fmuladd.f64(double %81, double %87, double %93)
store double %94, double* %92
%95 = load double, double* %6
%96 = load double*, double** %7
%97 = load i32, i32* %9
%98 = add nsw i32 %97, 3
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %96, i64 %99
%101 = load double, double* %100
%102 = load double*, double** %8
%103 = load i32, i32* %9
%104 = add nsw i32 %103, 3
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %102, i64 %105
%107 = load double, double* %106
%108 = call double @llvm.fmuladd.f64(double %95, double %101, double %107)
store double %108, double* %106
br label %109
109: ; preds = %54
%110 = load i32, i32* %9
%111 = add nsw i32 %110, 4
store i32 %111, i32* %9
br label %50
112: ; preds = %16, %46, %50
ret void
}

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