void daxpy_seq(int n, double alpha, double *x, double *y, int p) {
  int i, nc;
  if (n >= 4) {
    nc = n - (n % 4);
    if (p == 1) {
      for (i = 0; i < nc; i += 4) {
        y[i] += alpha * x[i];
        y[i + 1] += alpha * x[i + 1];
        y[i + 2] += alpha * x[i + 2];
        y[i + 3] += alpha * x[i + 3];
      }
    } else {
#pragma omp parallel for schedule(static) private(i) shared(x, y, nc, alpha)
      for (i = 0; i < nc; i += 4) {
        y[i] += alpha * x[i];
        y[i + 1] += alpha * x[i + 1];
        y[i + 2] += alpha * x[i + 2];
        y[i + 3] += alpha * x[i + 3];
      }
    }
    if (nc != n) {
      for (i = nc; i < n; i++)
        y[i] += alpha * x[i];
    }
  } else {
    for (i = 0; i < n; i++)
      y[i] += alpha * x[i];
  }
}


x86 assembly (clang, -O0):
<daxpy_seq>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
cmpl   $0x4,-0x4(%rbp)
jl     138e <daxpy_seq+0x28e>
mov    -0x4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0x30(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x24(%rbp)
jne    1238 <daxpy_seq+0x138>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1233 <daxpy_seq+0x133>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%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    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    114b <daxpy_seq+0x4b>
jmp    132c <daxpy_seq+0x22c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1327 <daxpy_seq+0x227>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%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    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x28(%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    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    123f <daxpy_seq+0x13f>
jmp    132c <daxpy_seq+0x22c>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
je     1389 <daxpy_seq+0x289>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1384 <daxpy_seq+0x284>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    133e <daxpy_seq+0x23e>
jmp    1389 <daxpy_seq+0x289>
jmp    13e0 <daxpy_seq+0x2e0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13db <daxpy_seq+0x2db>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1395 <daxpy_seq+0x295>
jmp    13e0 <daxpy_seq+0x2e0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<daxpy_seq>:
push   %r15
push   %r14
push   %rbx
cmp    $0x3,%edi
jle    1133 <daxpy_seq+0x33>
mov    %edi,%r8d
and    $0xfffffffc,%r8d
cmp    $0x1,%ecx
jne    1184 <daxpy_seq+0x84>
test   %r8d,%r8d
je     149e <daxpy_seq+0x39e>
mov    %r8d,%r11d
lea    -0x1(%r11),%r9
cmp    $0x3,%r9
jne    11a1 <daxpy_seq+0xa1>
xor    %eax,%eax
jmp    12e0 <daxpy_seq+0x1e0>
test   %edi,%edi
jle    1642 <daxpy_seq+0x542>
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
cmp    $0x1,%edi
je     1642 <daxpy_seq+0x542>
movsd  0x8(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx),%xmm1
movsd  %xmm1,0x8(%rdx)
cmp    $0x2,%edi
je     1642 <daxpy_seq+0x542>
mulsd  0x10(%rsi),%xmm0
addsd  0x10(%rdx),%xmm0
movsd  %xmm0,0x10(%rdx)
jmp    1642 <daxpy_seq+0x542>
test   %r8d,%r8d
je     149e <daxpy_seq+0x39e>
mov    %r8d,%r11d
lea    -0x1(%r11),%r9
cmp    $0x3,%r9
jne    11ba <daxpy_seq+0xba>
xor    %eax,%eax
jmp    1440 <daxpy_seq+0x340>
lea    (%rsi,%r11,8),%rax
cmp    %rdx,%rax
jbe    11db <daxpy_seq+0xdb>
lea    (%rdx,%r11,8),%rax
cmp    %rsi,%rax
jbe    11db <daxpy_seq+0xdb>
xor    %eax,%eax
jmp    12e0 <daxpy_seq+0x1e0>
lea    (%rsi,%r11,8),%rax
cmp    %rdx,%rax
jbe    1343 <daxpy_seq+0x243>
lea    (%rdx,%r11,8),%rax
cmp    %rsi,%rax
jbe    1343 <daxpy_seq+0x243>
xor    %eax,%eax
jmp    1440 <daxpy_seq+0x340>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
lea    0x0(,%r10,4),%rax
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %ecx,%ecx
mov    %r10,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,1),%xmm2
movsd  0x8(%rsi,%rcx,1),%xmm3
movsd  0x10(%rsi,%rcx,1),%xmm5
movsd  0x18(%rsi,%rcx,1),%xmm4
movhpd 0x20(%rsi,%rcx,1),%xmm2
movsd  (%rdx,%rcx,1),%xmm6
movsd  0x8(%rdx,%rcx,1),%xmm7
movsd  0x10(%rdx,%rcx,1),%xmm1
movsd  0x18(%rdx,%rcx,1),%xmm9
movhpd 0x20(%rdx,%rcx,1),%xmm6
mulpd  %xmm8,%xmm2
addpd  %xmm6,%xmm2
movhpd 0x28(%rsi,%rcx,1),%xmm3
movhpd 0x28(%rdx,%rcx,1),%xmm7
mulpd  %xmm8,%xmm3
addpd  %xmm7,%xmm3
movhpd 0x30(%rsi,%rcx,1),%xmm5
movhpd 0x30(%rdx,%rcx,1),%xmm1
mulpd  %xmm8,%xmm5
addpd  %xmm1,%xmm5
movhpd 0x38(%rsi,%rcx,1),%xmm4
movhpd 0x38(%rdx,%rcx,1),%xmm9
mulpd  %xmm8,%xmm4
addpd  %xmm9,%xmm4
movapd %xmm5,%xmm1
unpcklpd %xmm4,%xmm1
movapd %xmm2,%xmm6
unpcklpd %xmm3,%xmm6
movhlps %xmm5,%xmm4
movhlps %xmm2,%xmm3
movups %xmm3,0x20(%rdx,%rcx,1)
movups %xmm4,0x30(%rdx,%rcx,1)
movupd %xmm6,(%rdx,%rcx,1)
movupd %xmm1,0x10(%rdx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1210 <daxpy_seq+0x110>
cmp    %r10,%r9
je     149e <daxpy_seq+0x39e>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %r11,%rax
jb     12e0 <daxpy_seq+0x1e0>
jmp    149e <daxpy_seq+0x39e>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
lea    0x0(,%r10,4),%rax
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %ecx,%ecx
mov    %r10,%rbx
nopl   0x0(%rax)
movsd  (%rsi,%rcx,1),%xmm2
movsd  0x8(%rsi,%rcx,1),%xmm3
movsd  0x10(%rsi,%rcx,1),%xmm5
movsd  0x18(%rsi,%rcx,1),%xmm4
movhpd 0x20(%rsi,%rcx,1),%xmm2
movsd  (%rdx,%rcx,1),%xmm6
movsd  0x8(%rdx,%rcx,1),%xmm7
movsd  0x10(%rdx,%rcx,1),%xmm1
movsd  0x18(%rdx,%rcx,1),%xmm9
movhpd 0x20(%rdx,%rcx,1),%xmm6
mulpd  %xmm8,%xmm2
addpd  %xmm6,%xmm2
movhpd 0x28(%rsi,%rcx,1),%xmm3
movhpd 0x28(%rdx,%rcx,1),%xmm7
mulpd  %xmm8,%xmm3
addpd  %xmm7,%xmm3
movhpd 0x30(%rsi,%rcx,1),%xmm5
movhpd 0x30(%rdx,%rcx,1),%xmm1
mulpd  %xmm8,%xmm5
addpd  %xmm1,%xmm5
movhpd 0x38(%rsi,%rcx,1),%xmm4
movhpd 0x38(%rdx,%rcx,1),%xmm9
mulpd  %xmm8,%xmm4
addpd  %xmm9,%xmm4
movapd %xmm5,%xmm1
unpcklpd %xmm4,%xmm1
movapd %xmm2,%xmm6
unpcklpd %xmm3,%xmm6
movhlps %xmm5,%xmm4
movhlps %xmm2,%xmm3
movups %xmm3,0x20(%rdx,%rcx,1)
movups %xmm4,0x30(%rdx,%rcx,1)
movupd %xmm6,(%rdx,%rcx,1)
movupd %xmm1,0x10(%rdx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1370 <daxpy_seq+0x270>
cmp    %r10,%r9
je     149e <daxpy_seq+0x39e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %r11,%rax
jb     1440 <daxpy_seq+0x340>
test   $0x3,%dil
je     1642 <daxpy_seq+0x542>
cmp    %edi,%r8d
jge    1642 <daxpy_seq+0x542>
movslq %r8d,%rax
movslq %edi,%r10
mov    %r10,%r8
sub    %rax,%r8
cmp    $0x4,%r8
jb     15e5 <daxpy_seq+0x4e5>
lea    (%rdx,%rax,8),%rcx
lea    (%rsi,%r10,8),%rbx
cmp    %rbx,%rcx
jae    14e5 <daxpy_seq+0x3e5>
lea    (%rdx,%r10,8),%rcx
lea    (%rsi,%rax,8),%rbx
cmp    %rcx,%rbx
jb     15e5 <daxpy_seq+0x4e5>
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r9),%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1648 <daxpy_seq+0x548>
mov    %r11,%r14
and    $0xfffffffffffffffe,%r14
lea    (%rdx,%rax,8),%rbx
add    $0x30,%rbx
lea    (%rsi,%rax,8),%r15
add    $0x30,%r15
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%r15,%rcx,8),%xmm2
movupd -0x20(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rbx,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rbx,%rcx,8),%xmm2
movupd -0x10(%rbx,%rcx,8),%xmm5
movupd (%rbx,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rbx,%rcx,8)
movupd %xmm3,-0x20(%rbx,%rcx,8)
movupd -0x10(%r15,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rbx,%rcx,8)
movupd %xmm3,(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r14
jne    1530 <daxpy_seq+0x430>
test   $0x1,%r11b
je     15dd <daxpy_seq+0x4dd>
add    %rax,%rcx
movupd (%rsi,%rcx,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm3
movupd (%rdx,%rcx,8),%xmm4
movupd 0x10(%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rcx,8)
movupd %xmm3,0x10(%rdx,%rcx,8)
cmp    %r9,%r8
je     1642 <daxpy_seq+0x542>
add    %r9,%rax
sub    %eax,%edi
mov    %rax,%rcx
not    %rcx
test   $0x1,%dil
je     160a <daxpy_seq+0x50a>
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rax
add    %r10,%rcx
je     1642 <daxpy_seq+0x542>
nop
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1610 <daxpy_seq+0x510>
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %ecx,%ecx
test   $0x1,%r11b
jne    15a9 <daxpy_seq+0x4a9>
jmp    15dd <daxpy_seq+0x4dd>

LLVM IR (-O0):
define void @daxpy_seq(i32 %0, double %1, double* %2, double* %3, i32 %4) {
%6 = alloca i32
%7 = alloca double
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %6
store double %1, double* %7
store double* %2, double** %8
store double* %3, double** %9
store i32 %4, i32* %10
%13 = load i32, i32* %6
%14 = icmp sge i32 %13, 4
br i1 %14, label %15, label %178
15: ; preds = %5
%16 = load i32, i32* %6
%17 = load i32, i32* %6
%18 = srem i32 %17, 4
%19 = sub nsw i32 %16, %18
store i32 %19, i32* %12
%20 = load i32, i32* %10
%21 = icmp eq i32 %20, 1
br i1 %21, label %22, label %86
22: ; preds = %15
store i32 0, i32* %11
br label %23
23: ; preds = %82, %22
%24 = load i32, i32* %11
%25 = load i32, i32* %12
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %85
27: ; preds = %23
%28 = load double, double* %7
%29 = load double*, double** %8
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = load double*, double** %9
%35 = load i32, i32* %11
%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
%40 = load double, double* %7
%41 = load double*, double** %8
%42 = load i32, i32* %11
%43 = add nsw i32 %42, 1
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %41, i64 %44
%46 = load double, double* %45
%47 = load double*, double** %9
%48 = load i32, i32* %11
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %47, i64 %50
%52 = load double, double* %51
%53 = call double @llvm.fmuladd.f64(double %40, double %46, double %52)
store double %53, double* %51
%54 = load double, double* %7
%55 = load double*, double** %8
%56 = load i32, i32* %11
%57 = add nsw i32 %56, 2
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %55, i64 %58
%60 = load double, double* %59
%61 = load double*, double** %9
%62 = load i32, i32* %11
%63 = add nsw i32 %62, 2
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %61, i64 %64
%66 = load double, double* %65
%67 = call double @llvm.fmuladd.f64(double %54, double %60, double %66)
store double %67, double* %65
%68 = load double, double* %7
%69 = load double*, double** %8
%70 = load i32, i32* %11
%71 = add nsw i32 %70, 3
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %69, i64 %72
%74 = load double, double* %73
%75 = load double*, double** %9
%76 = load i32, i32* %11
%77 = add nsw i32 %76, 3
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %75, i64 %78
%80 = load double, double* %79
%81 = call double @llvm.fmuladd.f64(double %68, double %74, double %80)
store double %81, double* %79
br label %82
82: ; preds = %27
%83 = load i32, i32* %11
%84 = add nsw i32 %83, 4
store i32 %84, i32* %11
br label %23
85: ; preds = %23
br label %150
86: ; preds = %15
store i32 0, i32* %11
br label %87
87: ; preds = %146, %86
%88 = load i32, i32* %11
%89 = load i32, i32* %12
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %149
91: ; preds = %87
%92 = load double, double* %7
%93 = load double*, double** %8
%94 = load i32, i32* %11
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = load double*, double** %9
%99 = load i32, i32* %11
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
%102 = load double, double* %101
%103 = call double @llvm.fmuladd.f64(double %92, double %97, double %102)
store double %103, double* %101
%104 = load double, double* %7
%105 = load double*, double** %8
%106 = load i32, i32* %11
%107 = add nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %105, i64 %108
%110 = load double, double* %109
%111 = load double*, double** %9
%112 = load i32, i32* %11
%113 = add nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %111, i64 %114
%116 = load double, double* %115
%117 = call double @llvm.fmuladd.f64(double %104, double %110, double %116)
store double %117, double* %115
%118 = load double, double* %7
%119 = load double*, double** %8
%120 = load i32, i32* %11
%121 = add nsw i32 %120, 2
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %119, i64 %122
%124 = load double, double* %123
%125 = load double*, double** %9
%126 = load i32, i32* %11
%127 = add nsw i32 %126, 2
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %125, i64 %128
%130 = load double, double* %129
%131 = call double @llvm.fmuladd.f64(double %118, double %124, double %130)
store double %131, double* %129
%132 = load double, double* %7
%133 = load double*, double** %8
%134 = load i32, i32* %11
%135 = add nsw i32 %134, 3
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %133, i64 %136
%138 = load double, double* %137
%139 = load double*, double** %9
%140 = load i32, i32* %11
%141 = add nsw i32 %140, 3
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %139, i64 %142
%144 = load double, double* %143
%145 = call double @llvm.fmuladd.f64(double %132, double %138, double %144)
store double %145, double* %143
br label %146
146: ; preds = %91
%147 = load i32, i32* %11
%148 = add nsw i32 %147, 4
store i32 %148, i32* %11
br label %87
149: ; preds = %87
br label %150
150: ; preds = %149, %85
%151 = load i32, i32* %12
%152 = load i32, i32* %6
%153 = icmp ne i32 %151, %152
br i1 %153, label %154, label %177
154: ; preds = %150
%155 = load i32, i32* %12
store i32 %155, i32* %11
br label %156
156: ; preds = %173, %154
%157 = load i32, i32* %11
%158 = load i32, i32* %6
%159 = icmp slt i32 %157, %158
br i1 %159, label %160, label %176
160: ; preds = %156
%161 = load double, double* %7
%162 = load double*, double** %8
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = load double*, double** %9
%168 = load i32, i32* %11
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
%171 = load double, double* %170
%172 = call double @llvm.fmuladd.f64(double %161, double %166, double %171)
store double %172, double* %170
br label %173
173: ; preds = %160
%174 = load i32, i32* %11
%175 = add nsw i32 %174, 1
store i32 %175, i32* %11
br label %156
176: ; preds = %156
br label %177
177: ; preds = %176, %150
br label %200
178: ; preds = %5
store i32 0, i32* %11
br label %179
179: ; preds = %196, %178
%180 = load i32, i32* %11
%181 = load i32, i32* %6
%182 = icmp slt i32 %180, %181
br i1 %182, label %183, label %199
183: ; preds = %179
%184 = load double, double* %7
%185 = load double*, double** %8
%186 = load i32, i32* %11
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %185, i64 %187
%189 = load double, double* %188
%190 = load double*, double** %9
%191 = load i32, i32* %11
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %190, i64 %192
%194 = load double, double* %193
%195 = call double @llvm.fmuladd.f64(double %184, double %189, double %194)
store double %195, double* %193
br label %196
196: ; preds = %183
%197 = load i32, i32* %11
%198 = add nsw i32 %197, 1
store i32 %198, i32* %11
br label %179
199: ; preds = %179
br label %200
200: ; preds = %199, %177
ret void
}

LLVM IR (-O2):
define void @daxpy_seq(i32 %0, double %1, double* nocapture %2, double* nocapture %3, i32 %4) {
%6 = icmp sgt i32 %0, 3
br i1 %6, label %9, label %7
7: ; preds = %5
%8 = icmp sgt i32 %0, 0
br i1 %8, label %377, label %395
9: ; preds = %5
%10 = and i32 %0, 3
%11 = and i32 %0, -4
%12 = icmp eq i32 %4, 1
%13 = icmp eq i32 %11, 0
br i1 %12, label %105, label %14
14: ; preds = %9
br i1 %13, label %250, label %15
15: ; preds = %14
%16 = zext i32 %11 to i64
%17 = add nsw i64 %16, -1
%18 = lshr i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = icmp eq i64 %17, 3
br i1 %20, label %103, label %21
21: ; preds = %15
%22 = getelementptr double, double* %3, i64 %16
%23 = getelementptr double, double* %2, i64 %16
%24 = icmp ugt double* %23, %3
%25 = icmp ugt double* %22, %2
%26 = and i1 %24, %25
br i1 %26, label %103, label %27
27: ; preds = %21
%28 = and i64 %19, 9223372036854775806
%29 = shl i64 %28, 2
%30 = insertelement <2 x double> poison, double %1, i64 0
%31 = shufflevector <2 x double> %30, <2 x double> poison, <2 x i32> zeroinitializer
br label %32
32: ; preds = %32, %27
%33 = phi i64 [ 0, %27 ], [ %99, %32 ]
%34 = shl i64 %33, 2
%35 = or i64 %34, 4
%36 = getelementptr inbounds double, double* %2, i64 %34
%37 = getelementptr inbounds double, double* %2, i64 %35
%38 = load double, double* %36
%39 = load double, double* %37
%40 = insertelement <2 x double> poison, double %38, i64 0
%41 = insertelement <2 x double> %40, double %39, i64 1
%42 = getelementptr inbounds double, double* %3, i64 %34
%43 = getelementptr inbounds double, double* %3, i64 %35
%44 = load double, double* %42
%45 = load double, double* %43
%46 = insertelement <2 x double> poison, double %44, i64 0
%47 = insertelement <2 x double> %46, double %45, i64 1
%48 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %41, <2 x double> %47)
%49 = or i64 %34, 1
%50 = or i64 %34, 5
%51 = getelementptr inbounds double, double* %2, i64 %49
%52 = getelementptr inbounds double, double* %2, i64 %50
%53 = load double, double* %51
%54 = load double, double* %52
%55 = insertelement <2 x double> poison, double %53, i64 0
%56 = insertelement <2 x double> %55, double %54, i64 1
%57 = getelementptr inbounds double, double* %3, i64 %49
%58 = getelementptr inbounds double, double* %3, i64 %50
%59 = load double, double* %57
%60 = load double, double* %58
%61 = insertelement <2 x double> poison, double %59, i64 0
%62 = insertelement <2 x double> %61, double %60, i64 1
%63 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %56, <2 x double> %62)
%64 = or i64 %34, 2
%65 = or i64 %34, 6
%66 = getelementptr inbounds double, double* %2, i64 %64
%67 = getelementptr inbounds double, double* %2, i64 %65
%68 = load double, double* %66
%69 = load double, double* %67
%70 = insertelement <2 x double> poison, double %68, i64 0
%71 = insertelement <2 x double> %70, double %69, i64 1
%72 = getelementptr inbounds double, double* %3, i64 %64
%73 = getelementptr inbounds double, double* %3, i64 %65
%74 = load double, double* %72
%75 = load double, double* %73
%76 = insertelement <2 x double> poison, double %74, i64 0
%77 = insertelement <2 x double> %76, double %75, i64 1
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %71, <2 x double> %77)
%79 = or i64 %34, 3
%80 = or i64 %34, 7
%81 = getelementptr inbounds double, double* %2, i64 %79
%82 = getelementptr inbounds double, double* %2, i64 %80
%83 = load double, double* %81
%84 = load double, double* %82
%85 = insertelement <2 x double> poison, double %83, i64 0
%86 = insertelement <2 x double> %85, double %84, i64 1
%87 = getelementptr inbounds double, double* %3, i64 %79
%88 = getelementptr inbounds double, double* %3, i64 %80
%89 = load double, double* %87
%90 = load double, double* %88
%91 = insertelement <2 x double> poison, double %89, i64 0
%92 = insertelement <2 x double> %91, double %90, i64 1
%93 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %86, <2 x double> %92)
%94 = getelementptr inbounds double, double* %87, i64 -3
%95 = bitcast double* %94 to <8 x double>*
%96 = shufflevector <2 x double> %48, <2 x double> %63, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%97 = shufflevector <2 x double> %78, <2 x double> %93, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%98 = shufflevector <4 x double> %96, <4 x double> %97, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %98, <8 x double>* %95
%99 = add nuw i64 %33, 2
%100 = icmp eq i64 %99, %28
br i1 %100, label %101, label %32
101: ; preds = %32
%102 = icmp eq i64 %19, %28
br i1 %102, label %250, label %103
103: ; preds = %21, %15, %101
%104 = phi i64 [ 0, %21 ], [ 0, %15 ], [ %29, %101 ]
br label %223
105: ; preds = %9
br i1 %13, label %250, label %106
106: ; preds = %105
%107 = zext i32 %11 to i64
%108 = add nsw i64 %107, -1
%109 = lshr i64 %108, 2
%110 = add nuw nsw i64 %109, 1
%111 = icmp eq i64 %108, 3
br i1 %111, label %194, label %112
112: ; preds = %106
%113 = getelementptr double, double* %3, i64 %107
%114 = getelementptr double, double* %2, i64 %107
%115 = icmp ugt double* %114, %3
%116 = icmp ugt double* %113, %2
%117 = and i1 %115, %116
br i1 %117, label %194, label %118
118: ; preds = %112
%119 = and i64 %110, 9223372036854775806
%120 = shl i64 %119, 2
%121 = insertelement <2 x double> poison, double %1, i64 0
%122 = shufflevector <2 x double> %121, <2 x double> poison, <2 x i32> zeroinitializer
br label %123
123: ; preds = %123, %118
%124 = phi i64 [ 0, %118 ], [ %190, %123 ]
%125 = shl i64 %124, 2
%126 = or i64 %125, 4
%127 = getelementptr inbounds double, double* %2, i64 %125
%128 = getelementptr inbounds double, double* %2, i64 %126
%129 = load double, double* %127
%130 = load double, double* %128
%131 = insertelement <2 x double> poison, double %129, i64 0
%132 = insertelement <2 x double> %131, double %130, i64 1
%133 = getelementptr inbounds double, double* %3, i64 %125
%134 = getelementptr inbounds double, double* %3, i64 %126
%135 = load double, double* %133
%136 = load double, double* %134
%137 = insertelement <2 x double> poison, double %135, i64 0
%138 = insertelement <2 x double> %137, double %136, i64 1
%139 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %122, <2 x double> %132, <2 x double> %138)
%140 = or i64 %125, 1
%141 = or i64 %125, 5
%142 = getelementptr inbounds double, double* %2, i64 %140
%143 = getelementptr inbounds double, double* %2, i64 %141
%144 = load double, double* %142
%145 = load double, double* %143
%146 = insertelement <2 x double> poison, double %144, i64 0
%147 = insertelement <2 x double> %146, double %145, i64 1
%148 = getelementptr inbounds double, double* %3, i64 %140
%149 = getelementptr inbounds double, double* %3, i64 %141
%150 = load double, double* %148
%151 = load double, double* %149
%152 = insertelement <2 x double> poison, double %150, i64 0
%153 = insertelement <2 x double> %152, double %151, i64 1
%154 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %122, <2 x double> %147, <2 x double> %153)
%155 = or i64 %125, 2
%156 = or i64 %125, 6
%157 = getelementptr inbounds double, double* %2, i64 %155
%158 = getelementptr inbounds double, double* %2, i64 %156
%159 = load double, double* %157
%160 = load double, double* %158
%161 = insertelement <2 x double> poison, double %159, i64 0
%162 = insertelement <2 x double> %161, double %160, i64 1
%163 = getelementptr inbounds double, double* %3, i64 %155
%164 = getelementptr inbounds double, double* %3, i64 %156
%165 = load double, double* %163
%166 = load double, double* %164
%167 = insertelement <2 x double> poison, double %165, i64 0
%168 = insertelement <2 x double> %167, double %166, i64 1
%169 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %122, <2 x double> %162, <2 x double> %168)
%170 = or i64 %125, 3
%171 = or i64 %125, 7
%172 = getelementptr inbounds double, double* %2, i64 %170
%173 = getelementptr inbounds double, double* %2, i64 %171
%174 = load double, double* %172
%175 = load double, double* %173
%176 = insertelement <2 x double> poison, double %174, i64 0
%177 = insertelement <2 x double> %176, double %175, i64 1
%178 = getelementptr inbounds double, double* %3, i64 %170
%179 = getelementptr inbounds double, double* %3, i64 %171
%180 = load double, double* %178
%181 = load double, double* %179
%182 = insertelement <2 x double> poison, double %180, i64 0
%183 = insertelement <2 x double> %182, double %181, i64 1
%184 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %122, <2 x double> %177, <2 x double> %183)
%185 = getelementptr inbounds double, double* %178, i64 -3
%186 = bitcast double* %185 to <8 x double>*
%187 = shufflevector <2 x double> %139, <2 x double> %154, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%188 = shufflevector <2 x double> %169, <2 x double> %184, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%189 = shufflevector <4 x double> %187, <4 x double> %188, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %189, <8 x double>* %186
%190 = add nuw i64 %124, 2
%191 = icmp eq i64 %190, %119
br i1 %191, label %192, label %123
192: ; preds = %123
%193 = icmp eq i64 %110, %119
br i1 %193, label %250, label %194
194: ; preds = %112, %106, %192
%195 = phi i64 [ 0, %112 ], [ 0, %106 ], [ %120, %192 ]
br label %196
196: ; preds = %194, %196
%197 = phi i64 [ %221, %196 ], [ %195, %194 ]
%198 = getelementptr inbounds double, double* %2, i64 %197
%199 = load double, double* %198
%200 = getelementptr inbounds double, double* %3, i64 %197
%201 = load double, double* %200
%202 = tail call double @llvm.fmuladd.f64(double %1, double %199, double %201)
store double %202, double* %200
%203 = or i64 %197, 1
%204 = getelementptr inbounds double, double* %2, i64 %203
%205 = load double, double* %204
%206 = getelementptr inbounds double, double* %3, i64 %203
%207 = load double, double* %206
%208 = tail call double @llvm.fmuladd.f64(double %1, double %205, double %207)
store double %208, double* %206
%209 = or i64 %197, 2
%210 = getelementptr inbounds double, double* %2, i64 %209
%211 = load double, double* %210
%212 = getelementptr inbounds double, double* %3, i64 %209
%213 = load double, double* %212
%214 = tail call double @llvm.fmuladd.f64(double %1, double %211, double %213)
store double %214, double* %212
%215 = or i64 %197, 3
%216 = getelementptr inbounds double, double* %2, i64 %215
%217 = load double, double* %216
%218 = getelementptr inbounds double, double* %3, i64 %215
%219 = load double, double* %218
%220 = tail call double @llvm.fmuladd.f64(double %1, double %217, double %219)
store double %220, double* %218
%221 = add nuw nsw i64 %197, 4
%222 = icmp ult i64 %221, %107
br i1 %222, label %196, label %250
223: ; preds = %103, %223
%224 = phi i64 [ %248, %223 ], [ %104, %103 ]
%225 = getelementptr inbounds double, double* %2, i64 %224
%226 = load double, double* %225
%227 = getelementptr inbounds double, double* %3, i64 %224
%228 = load double, double* %227
%229 = tail call double @llvm.fmuladd.f64(double %1, double %226, double %228)
store double %229, double* %227
%230 = or i64 %224, 1
%231 = getelementptr inbounds double, double* %2, i64 %230
%232 = load double, double* %231
%233 = getelementptr inbounds double, double* %3, i64 %230
%234 = load double, double* %233
%235 = tail call double @llvm.fmuladd.f64(double %1, double %232, double %234)
store double %235, double* %233
%236 = or i64 %224, 2
%237 = getelementptr inbounds double, double* %2, i64 %236
%238 = load double, double* %237
%239 = getelementptr inbounds double, double* %3, i64 %236
%240 = load double, double* %239
%241 = tail call double @llvm.fmuladd.f64(double %1, double %238, double %240)
store double %241, double* %239
%242 = or i64 %224, 3
%243 = getelementptr inbounds double, double* %2, i64 %242
%244 = load double, double* %243
%245 = getelementptr inbounds double, double* %3, i64 %242
%246 = load double, double* %245
%247 = tail call double @llvm.fmuladd.f64(double %1, double %244, double %246)
store double %247, double* %245
%248 = add nuw nsw i64 %224, 4
%249 = icmp ult i64 %248, %16
br i1 %249, label %223, label %250
250: ; preds = %223, %196, %101, %192, %14, %105
%251 = icmp ne i32 %10, 0
%252 = icmp slt i32 %11, %0
%253 = and i1 %251, %252
br i1 %253, label %254, label %395
254: ; preds = %250
%255 = sext i32 %11 to i64
%256 = sext i32 %0 to i64
%257 = sub nsw i64 %256, %255
%258 = icmp ult i64 %257, 4
br i1 %258, label %345, label %259
259: ; preds = %254
%260 = getelementptr double, double* %3, i64 %255
%261 = getelementptr double, double* %3, i64 %256
%262 = getelementptr double, double* %2, i64 %255
%263 = getelementptr double, double* %2, i64 %256
%264 = icmp ult double* %260, %263
%265 = icmp ult double* %262, %261
%266 = and i1 %264, %265
br i1 %266, label %345, label %267
267: ; preds = %259
%268 = and i64 %257, -4
%269 = add nsw i64 %268, %255
%270 = insertelement <2 x double> poison, double %1, i64 0
%271 = shufflevector <2 x double> %270, <2 x double> poison, <2 x i32> zeroinitializer
%272 = insertelement <2 x double> poison, double %1, i64 0
%273 = shufflevector <2 x double> %272, <2 x double> poison, <2 x i32> zeroinitializer
%274 = add nsw i64 %268, -4
%275 = lshr exact i64 %274, 2
%276 = add nuw nsw i64 %275, 1
%277 = and i64 %276, 1
%278 = icmp eq i64 %274, 0
br i1 %278, label %322, label %279
279: ; preds = %267
%280 = and i64 %276, 9223372036854775806
br label %281
281: ; preds = %281, %279
%282 = phi i64 [ 0, %279 ], [ %319, %281 ]
%283 = phi i64 [ 0, %279 ], [ %320, %281 ]
%284 = add i64 %282, %255
%285 = getelementptr inbounds double, double* %2, i64 %284
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = getelementptr inbounds double, double* %285, i64 2
%289 = bitcast double* %288 to <2 x double>*
%290 = load <2 x double>, <2 x double>* %289
%291 = getelementptr inbounds double, double* %3, i64 %284
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = getelementptr inbounds double, double* %291, i64 2
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %271, <2 x double> %287, <2 x double> %293)
%298 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %273, <2 x double> %290, <2 x double> %296)
%299 = bitcast double* %291 to <2 x double>*
store <2 x double> %297, <2 x double>* %299
%300 = bitcast double* %294 to <2 x double>*
store <2 x double> %298, <2 x double>* %300
%301 = or i64 %282, 4
%302 = add i64 %301, %255
%303 = getelementptr inbounds double, double* %2, i64 %302
%304 = bitcast double* %303 to <2 x double>*
%305 = load <2 x double>, <2 x double>* %304
%306 = getelementptr inbounds double, double* %303, i64 2
%307 = bitcast double* %306 to <2 x double>*
%308 = load <2 x double>, <2 x double>* %307
%309 = getelementptr inbounds double, double* %3, i64 %302
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = getelementptr inbounds double, double* %309, i64 2
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %271, <2 x double> %305, <2 x double> %311)
%316 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %273, <2 x double> %308, <2 x double> %314)
%317 = bitcast double* %309 to <2 x double>*
store <2 x double> %315, <2 x double>* %317
%318 = bitcast double* %312 to <2 x double>*
store <2 x double> %316, <2 x double>* %318
%319 = add nuw i64 %282, 8
%320 = add i64 %283, 2
%321 = icmp eq i64 %320, %280
br i1 %321, label %322, label %281
322: ; preds = %281, %267
%323 = phi i64 [ 0, %267 ], [ %319, %281 ]
%324 = icmp eq i64 %277, 0
br i1 %324, label %343, label %325
325: ; preds = %322
%326 = add i64 %323, %255
%327 = getelementptr inbounds double, double* %2, i64 %326
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = getelementptr inbounds double, double* %327, i64 2
%331 = bitcast double* %330 to <2 x double>*
%332 = load <2 x double>, <2 x double>* %331
%333 = getelementptr inbounds double, double* %3, i64 %326
%334 = bitcast double* %333 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = getelementptr inbounds double, double* %333, i64 2
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %271, <2 x double> %329, <2 x double> %335)
%340 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %273, <2 x double> %332, <2 x double> %338)
%341 = bitcast double* %333 to <2 x double>*
store <2 x double> %339, <2 x double>* %341
%342 = bitcast double* %336 to <2 x double>*
store <2 x double> %340, <2 x double>* %342
br label %343
343: ; preds = %322, %325
%344 = icmp eq i64 %257, %268
br i1 %344, label %395, label %345
345: ; preds = %259, %254, %343
%346 = phi i64 [ %255, %259 ], [ %255, %254 ], [ %269, %343 ]
%347 = sub nsw i64 %256, %346
%348 = xor i64 %346, -1
%349 = and i64 %347, 1
%350 = icmp eq i64 %349, 0
br i1 %350, label %358, label %351
351: ; preds = %345
%352 = getelementptr inbounds double, double* %2, i64 %346
%353 = load double, double* %352
%354 = getelementptr inbounds double, double* %3, i64 %346
%355 = load double, double* %354
%356 = tail call double @llvm.fmuladd.f64(double %1, double %353, double %355)
store double %356, double* %354
%357 = add nsw i64 %346, 1
br label %358
358: ; preds = %351, %345
%359 = phi i64 [ %346, %345 ], [ %357, %351 ]
%360 = sub nsw i64 0, %256
%361 = icmp eq i64 %348, %360
br i1 %361, label %395, label %362
362: ; preds = %358, %362
%363 = phi i64 [ %375, %362 ], [ %359, %358 ]
%364 = getelementptr inbounds double, double* %2, i64 %363
%365 = load double, double* %364
%366 = getelementptr inbounds double, double* %3, i64 %363
%367 = load double, double* %366
%368 = tail call double @llvm.fmuladd.f64(double %1, double %365, double %367)
store double %368, double* %366
%369 = add nsw i64 %363, 1
%370 = getelementptr inbounds double, double* %2, i64 %369
%371 = load double, double* %370
%372 = getelementptr inbounds double, double* %3, i64 %369
%373 = load double, double* %372
%374 = tail call double @llvm.fmuladd.f64(double %1, double %371, double %373)
store double %374, double* %372
%375 = add nsw i64 %363, 2
%376 = icmp eq i64 %375, %256
br i1 %376, label %395, label %362
377: ; preds = %7
%378 = load double, double* %2
%379 = load double, double* %3
%380 = tail call double @llvm.fmuladd.f64(double %1, double %378, double %379)
store double %380, double* %3
%381 = icmp eq i32 %0, 1
br i1 %381, label %395, label %382
382: ; preds = %377
%383 = getelementptr inbounds double, double* %2, i64 1
%384 = load double, double* %383
%385 = getelementptr inbounds double, double* %3, i64 1
%386 = load double, double* %385
%387 = tail call double @llvm.fmuladd.f64(double %1, double %384, double %386)
store double %387, double* %385
%388 = icmp eq i32 %0, 2
br i1 %388, label %395, label %389
389: ; preds = %382
%390 = getelementptr inbounds double, double* %2, i64 2
%391 = load double, double* %390
%392 = getelementptr inbounds double, double* %3, i64 2
%393 = load double, double* %392
%394 = tail call double @llvm.fmuladd.f64(double %1, double %391, double %393)
store double %394, double* %392
br label %395
395: ; preds = %377, %382, %389, %358, %362, %343, %7, %250
ret void
}