void ca_harmonic_trap_forces(const double *positions, double q, double kx,
                             double ky, double kz, double phi, double dt,
                             int num_ptcls, double *forces) {
  double cphi = cos(phi);
  double sphi = sin(phi);
  double alpha = q * dt;
  double x, y, z;
  int i;
  for (i = 0; i < num_ptcls; ++i) {
    x = positions[i * 3 + 0];
    y = positions[i * 3 + 1];
    z = positions[i * 3 + 2];
    forces[i * 3 + 0] +=
        alpha * ((-kx * ((cphi) * (cphi)) - ky * ((sphi) * (sphi))) * x +
                 cphi * sphi * (ky - kx) * y);
    forces[i * 3 + 1] +=
        alpha * (cphi * sphi * (ky - kx) * x +
                 (-kx * ((sphi) * (sphi)) - ky * ((cphi) * (cphi))) * y);
    forces[i * 3 + 2] += -alpha * kz * z;
  }
}


x86 assembly (clang, -O0):
<ca_harmonic_trap_forces>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
mov    %esi,-0x3c(%rbp)
mov    %rdx,-0x48(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    137e <ca_harmonic_trap_forces+0x25e>
mov    -0x8(%rbp),%rax
imul   $0x3,-0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x50(%rbp),%xmm3
mulsd  -0x50(%rbp),%xmm3
movsd  -0x20(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm4
mulsd  -0x58(%rbp),%xmm4
mulsd  %xmm4,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm4
subsd  -0x18(%rbp),%xmm4
mulsd  %xmm4,%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x48(%rbp),%rax
imul   $0x3,-0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  -0x58(%rbp),%xmm2
movsd  -0x20(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x58(%rbp),%xmm5
mulsd  -0x58(%rbp),%xmm5
movsd  -0x20(%rbp),%xmm4
movsd  -0x50(%rbp),%xmm6
mulsd  -0x50(%rbp),%xmm6
mulsd  %xmm6,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x48(%rbp),%rax
imul   $0x3,-0x7c(%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  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x48(%rbp),%rax
imul   $0x3,-0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1188 <ca_harmonic_trap_forces+0x68>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ca_harmonic_trap_forces>:
push   %rbp
push   %r14
push   %rbx
sub    $0x50,%rsp
mov    %rdx,%rbx
mov    %esi,%ebp
movsd  %xmm5,0x20(%rsp)
movsd  %xmm4,0x38(%rsp)
movsd  %xmm3,0x30(%rsp)
movsd  %xmm2,0x28(%rsp)
movapd %xmm1,0x40(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %rdi,%r14
movapd %xmm4,%xmm0
call   1040 <cos@plt>
movapd %xmm0,(%rsp)
movsd  0x38(%rsp),%xmm0
call   1030 <sin@plt>
movapd (%rsp),%xmm12
movapd 0x10(%rsp),%xmm13
test   %ebp,%ebp
jle    1298 <ca_harmonic_trap_forces+0x178>
mulsd  0x20(%rsp),%xmm13
movapd 0xe6f(%rip),%xmm11
movsd  0x28(%rsp),%xmm2
movapd %xmm2,%xmm3
movapd 0x40(%rsp),%xmm1
subsd  %xmm1,%xmm3
xorpd  %xmm11,%xmm1
movapd %xmm12,%xmm4
mulsd  %xmm12,%xmm4
mulsd  %xmm0,%xmm12
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm1,%xmm14
mulsd  %xmm4,%xmm14
subsd  %xmm5,%xmm14
mulsd  %xmm3,%xmm12
mulsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm0
subsd  %xmm4,%xmm0
xorpd  %xmm13,%xmm11
mulsd  0x30(%rsp),%xmm11
mov    %ebp,%eax
cmp    $0x1,%ebp
je     121d <ca_harmonic_trap_forces+0xfd>
lea    0x0(,%rax,8),%rcx
lea    (%rcx,%rcx,2),%rcx
lea    (%r14,%rcx,1),%rdx
cmp    %rbx,%rdx
jbe    12a1 <ca_harmonic_trap_forces+0x181>
add    %rbx,%rcx
cmp    %r14,%rcx
jbe    12a1 <ca_harmonic_trap_forces+0x181>
xor    %ecx,%ecx
unpcklpd %xmm12,%xmm14
unpcklpd %xmm0,%xmm12
unpcklpd %xmm13,%xmm13
lea    (%rcx,%rcx,2),%rdx
lea    0x10(,%rdx,8),%rdx
sub    %rcx,%rax
nopl   (%rax)
movsd  -0x10(%r14,%rdx,1),%xmm0
movsd  -0x8(%r14,%rdx,1),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm12,%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm14,%xmm0
addpd  %xmm1,%xmm0
mulpd  %xmm13,%xmm0
movupd -0x10(%rbx,%rdx,1),%xmm1
addpd  %xmm0,%xmm1
movsd  (%r14,%rdx,1),%xmm0
mulsd  %xmm11,%xmm0
movupd %xmm1,-0x10(%rbx,%rdx,1)
addsd  (%rbx,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rdx,1)
add    $0x18,%rdx
add    $0xffffffffffffffff,%rax
jne    1240 <ca_harmonic_trap_forces+0x120>
add    $0x50,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm12,(%rsp)
unpcklpd %xmm12,%xmm12
movapd %xmm14,%xmm8
unpcklpd %xmm14,%xmm8
movapd %xmm13,0x10(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
movapd %xmm11,%xmm10
unpcklpd %xmm11,%xmm10
xor    %edx,%edx
mov    %rcx,%rsi
movupd (%r14,%rdx,1),%xmm6
movupd 0x10(%r14,%rdx,1),%xmm7
movupd 0x20(%r14,%rdx,1),%xmm1
movapd %xmm7,%xmm4
movsd  %xmm6,%xmm4
shufpd $0x1,%xmm1,%xmm6
movsd  %xmm7,%xmm1
mulpd  %xmm10,%xmm1
movapd %xmm12,%xmm3
mulpd  %xmm6,%xmm3
movapd %xmm8,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm3,%xmm7
movupd (%rbx,%rdx,1),%xmm3
movupd 0x10(%rbx,%rdx,1),%xmm15
movupd 0x20(%rbx,%rdx,1),%xmm2
movapd %xmm15,%xmm5
movsd  %xmm3,%xmm5
shufpd $0x1,%xmm2,%xmm3
movsd  %xmm15,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm13,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm9,%xmm6
mulpd  %xmm12,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm2,%xmm1
shufpd $0x2,%xmm7,%xmm2
unpcklpd %xmm4,%xmm7
movupd %xmm7,(%rbx,%rdx,1)
movupd %xmm2,0x10(%rbx,%rdx,1)
movupd %xmm1,0x20(%rbx,%rdx,1)
add    $0x30,%rdx
add    $0xfffffffffffffffe,%rsi
jne    12e0 <ca_harmonic_trap_forces+0x1c0>
cmp    %rax,%rcx
movapd 0x10(%rsp),%xmm13
movapd (%rsp),%xmm12
je     1298 <ca_harmonic_trap_forces+0x178>
jmp    121f <ca_harmonic_trap_forces+0xff>

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

LLVM IR (-O2):
define void @ca_harmonic_trap_forces(double* nocapture %0, double %1, double %2, double %3, double %4, double %5, double %6, i32 %7, double* nocapture %8) {
%10 = tail call double @cos(double %5)
%11 = tail call double @sin(double %5)
%12 = fmul double %1, %6
%13 = icmp sgt i32 %7, 0
br i1 %13, label %14, label %116
14: ; preds = %9
%15 = fneg double %2
%16 = fmul double %10, %10
%17 = fmul double %11, %11
%18 = fneg double %17
%19 = fmul double %18, %3
%20 = tail call double @llvm.fmuladd.f64(double %15, double %16, double %19)
%21 = fmul double %10, %11
%22 = fsub double %3, %2
%23 = fmul double %22, %21
%24 = fneg double %16
%25 = fmul double %24, %3
%26 = tail call double @llvm.fmuladd.f64(double %15, double %17, double %25)
%27 = fneg double %12
%28 = fmul double %27, %4
%29 = zext i32 %7 to i64
%30 = icmp eq i32 %7, 1
br i1 %30, label %81, label %31
31: ; preds = %14
%32 = mul nuw nsw i64 %29, 3
%33 = getelementptr double, double* %8, i64 %32
%34 = getelementptr double, double* %0, i64 %32
%35 = icmp ugt double* %34, %8
%36 = icmp ugt double* %33, %0
%37 = and i1 %35, %36
br i1 %37, label %81, label %38
38: ; preds = %31
%39 = and i64 %29, 4294967294
%40 = insertelement <2 x double> poison, double %23, i64 0
%41 = shufflevector <2 x double> %40, <2 x double> poison, <2 x i32> zeroinitializer
%42 = insertelement <2 x double> poison, double %20, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x double> poison, double %12, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x double> poison, double %26, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %28, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
br label %50
50: ; preds = %50, %38
%51 = phi i64 [ 0, %38 ], [ %77, %50 ]
%52 = mul nuw nsw i64 %51, 3
%53 = getelementptr inbounds double, double* %0, i64 %52
%54 = bitcast double* %53 to <6 x double>*
%55 = load <6 x double>, <6 x double>* %54
%56 = shufflevector <6 x double> %55, <6 x double> poison, <2 x i32> <i32 0, i32 3>
%57 = shufflevector <6 x double> %55, <6 x double> poison, <2 x i32> <i32 1, i32 4>
%58 = shufflevector <6 x double> %55, <6 x double> poison, <2 x i32> <i32 2, i32 5>
%59 = fmul <2 x double> %41, %57
%60 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %43, <2 x double> %56, <2 x double> %59)
%61 = getelementptr inbounds double, double* %8, i64 %52
%62 = bitcast double* %61 to <6 x double>*
%63 = load <6 x double>, <6 x double>* %62
%64 = shufflevector <6 x double> %63, <6 x double> poison, <2 x i32> <i32 0, i32 3>
%65 = shufflevector <6 x double> %63, <6 x double> poison, <2 x i32> <i32 1, i32 4>
%66 = shufflevector <6 x double> %63, <6 x double> poison, <2 x i32> <i32 2, i32 5>
%67 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %45, <2 x double> %60, <2 x double> %64)
%68 = fmul <2 x double> %47, %57
%69 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %41, <2 x double> %56, <2 x double> %68)
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %45, <2 x double> %69, <2 x double> %65)
%71 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %49, <2 x double> %58, <2 x double> %66)
%72 = getelementptr inbounds double, double* %8, i64 %52
%73 = bitcast double* %72 to <6 x double>*
%74 = shufflevector <2 x double> %67, <2 x double> %70, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%75 = shufflevector <2 x double> %71, <2 x double> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%76 = shufflevector <4 x double> %74, <4 x double> %75, <6 x i32> <i32 0, i32 2, i32 4, i32 1, i32 3, i32 5>
store <6 x double> %76, <6 x double>* %73
%77 = add nuw i64 %51, 2
%78 = icmp eq i64 %77, %39
br i1 %78, label %79, label %50
79: ; preds = %50
%80 = icmp eq i64 %39, %29
br i1 %80, label %116, label %81
81: ; preds = %31, %14, %79
%82 = phi i64 [ 0, %31 ], [ 0, %14 ], [ %39, %79 ]
%83 = insertelement <2 x double> poison, double %23, i64 0
%84 = insertelement <2 x double> %83, double %26, i64 1
%85 = insertelement <2 x double> poison, double %20, i64 0
%86 = insertelement <2 x double> %85, double %23, i64 1
%87 = insertelement <2 x double> poison, double %12, i64 0
%88 = shufflevector <2 x double> %87, <2 x double> poison, <2 x i32> zeroinitializer
br label %89
89: ; preds = %81, %89
%90 = phi i64 [ %114, %89 ], [ %82, %81 ]
%91 = mul nuw nsw i64 %90, 3
%92 = getelementptr inbounds double, double* %0, i64 %91
%93 = load double, double* %92
%94 = add nuw nsw i64 %91, 1
%95 = getelementptr inbounds double, double* %0, i64 %94
%96 = load double, double* %95
%97 = add nuw nsw i64 %91, 2
%98 = getelementptr inbounds double, double* %0, i64 %97
%99 = load double, double* %98
%100 = getelementptr inbounds double, double* %8, i64 %91
%101 = insertelement <2 x double> poison, double %96, i64 0
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> zeroinitializer
%103 = fmul <2 x double> %84, %102
%104 = insertelement <2 x double> poison, double %93, i64 0
%105 = shufflevector <2 x double> %104, <2 x double> poison, <2 x i32> zeroinitializer
%106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %86, <2 x double> %105, <2 x double> %103)
%107 = bitcast double* %100 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %88, <2 x double> %106, <2 x double> %108)
%110 = bitcast double* %100 to <2 x double>*
store <2 x double> %109, <2 x double>* %110
%111 = getelementptr inbounds double, double* %8, i64 %97
%112 = load double, double* %111
%113 = tail call double @llvm.fmuladd.f64(double %28, double %99, double %112)
store double %113, double* %111
%114 = add nuw nsw i64 %90, 1
%115 = icmp eq i64 %114, %29
br i1 %115, label %116, label %89
116: ; preds = %89, %79, %9
ret void
}