void my_daxpyz(int n, double da, const double *dx, int incx, const double *dy,
               int incy, double *dz, int incz) {
  int i, ix, iy;
  int m;
  if (n <= 0)
    return;
  if (incx != 1 || incy != 1) {
    ix = 1;
    iy = 1;
    if (incx < 0)
      ix = (-n + 1) * incx + 1;
    if (incy < 0)
      iy = (-n + 1) * incy + 1;
    for (i = 0; i < n; i++) {
      dz[iy] = dy[iy] + da * dx[ix];
      ix = ix + incx;
      iy = iy + incy;
    }
  } else {
    m = n % 4;
    if (m != 0) {
      for (i = 0; i < m; i++)
        dz[i] = dy[i] + da * dx[i];
      if (n < 4)
        return;
    }
    for (i = m; i < n; i += 4) {
      dz[i] = dy[i] + da * dx[i];
      dz[i + 1] = dy[i + 1] + da * dx[i + 1];
      dz[i + 2] = dy[i + 2] + da * dx[i + 2];
      dz[i + 3] = dy[i + 3] + da * dx[i + 3];
    }
  }
}


x86 assembly (clang, -O0):
<my_daxpyz>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1131 <my_daxpyz+0x31>
jmp    139a <my_daxpyz+0x29a>
cmpl   $0x1,-0x1c(%rbp)
jne    1145 <my_daxpyz+0x45>
cmpl   $0x1,-0x2c(%rbp)
je     11f7 <my_daxpyz+0xf7>
movl   $0x1,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    116f <my_daxpyz+0x6f>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
add    $0x1,%eax
imul   -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    118b <my_daxpyz+0x8b>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
add    $0x1,%eax
imul   -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f2 <my_daxpyz+0xf2>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1192 <my_daxpyz+0x92>
jmp    139a <my_daxpyz+0x29a>
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     1278 <my_daxpyz+0x178>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1264 <my_daxpyz+0x164>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1216 <my_daxpyz+0x116>
cmpl   $0x4,-0x4(%rbp)
jge    1273 <my_daxpyz+0x173>
jmp    139a <my_daxpyz+0x29a>
jmp    1278 <my_daxpyz+0x178>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1395 <my_daxpyz+0x295>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x3c(%rbp)
jmp    127e <my_daxpyz+0x17e>
jmp    139a <my_daxpyz+0x29a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<my_daxpyz>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    1572 <my_daxpyz+0x472>
cmp    $0x1,%edx
jne    117d <my_daxpyz+0x7d>
cmp    $0x1,%r8d
jne    117d <my_daxpyz+0x7d>
mov    %edi,%r8d
and    $0x3,%r8d
je     135c <my_daxpyz+0x25c>
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx),%xmm1
movsd  %xmm1,(%r9)
cmp    $0x1,%r8d
je     116f <my_daxpyz+0x6f>
movsd  0x8(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx),%xmm1
movsd  %xmm1,0x8(%r9)
cmp    $0x2,%r8d
je     116f <my_daxpyz+0x6f>
movsd  0x10(%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx),%xmm1
movsd  %xmm1,0x10(%r9)
cmp    $0x3,%edi
jg     1365 <my_daxpyz+0x265>
jmp    1572 <my_daxpyz+0x472>
mov    $0x1,%eax
mov    $0x1,%ebp
sub    %edi,%ebp
mov    %ebp,%ebx
imul   %r8d,%ebx
add    $0x1,%ebx
test   %r8d,%r8d
cmovns %eax,%ebx
imul   %edx,%ebp
add    $0x1,%ebp
test   %edx,%edx
cmovns %eax,%ebp
movslq %ebx,%rbx
movslq %r8d,%r12
movslq %ebp,%r15
movslq %edx,%r10
lea    -0x1(%rdi),%r14d
xor    %r11d,%r11d
cmp    $0x3,%r14d
jb     12c7 <my_daxpyz+0x1c7>
cmp    $0x1,%r8d
jne    12c7 <my_daxpyz+0x1c7>
cmp    $0x1,%edx
jne    12c7 <my_daxpyz+0x1c7>
lea    (%r9,%rbx,8),%r8
lea    (%rbx,%r14,1),%rdx
lea    (%r9,%rdx,8),%rbp
add    $0x8,%rbp
lea    (%rcx,%rbx,8),%rax
mov    %rax,-0x10(%rsp)
lea    0x8(%rcx,%rdx,8),%rax
lea    (%rsi,%r15,8),%rdx
mov    %rdx,-0x8(%rsp)
lea    (%r15,%r14,1),%r13
lea    (%rsi,%r13,8),%r13
add    $0x8,%r13
cmp    %rax,%r8
setb   -0x11(%rsp)
cmp    %rbp,-0x10(%rsp)
setb   %dl
cmp    %r13,%r8
setb   %al
cmp    %rbp,-0x8(%rsp)
setb   %bpl
test   %dl,-0x11(%rsp)
jne    12c7 <my_daxpyz+0x1c7>
and    %bpl,%al
jne    12c7 <my_daxpyz+0x1c7>
add    $0x1,%r14
mov    %r14,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%r8
imul   %r10,%r8
add    %r15,%r8
mov    %r11,%rdx
imul   %r12,%rdx
add    %rbx,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    0x10(,%rbx,8),%rax
mov    %r12,%r13
shl    $0x5,%r13
lea    (%rsi,%r15,8),%rbx
add    $0x10,%rbx
mov    %r10,%r15
shl    $0x5,%r15
mov    %r11,%rbp
movupd -0x10(%rcx,%rax,1),%xmm2
movupd (%rcx,%rax,1),%xmm3
movupd -0x10(%rbx),%xmm4
movupd (%rbx),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%r9,%rax,1)
movupd %xmm5,(%r9,%rax,1)
add    %r13,%rax
add    %r15,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1280 <my_daxpyz+0x180>
cmp    %r11,%r14
jne    12cd <my_daxpyz+0x1cd>
jmp    1572 <my_daxpyz+0x472>
mov    %r15,%r8
mov    %rbx,%rdx
mov    %edi,%ebx
sub    %r11d,%ebx
mov    %r11d,%eax
not    %eax
test   $0x1,%bl
je     12fb <my_daxpyz+0x1fb>
movsd  (%rsi,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%r9,%rdx,8)
add    %r10,%r8
add    %r12,%rdx
add    $0x1,%r11d
add    %edi,%eax
je     1572 <my_daxpyz+0x472>
lea    (%r8,%r10,1),%rbx
shl    $0x4,%r10
lea    (%rdx,%r12,1),%rax
shl    $0x4,%r12
sub    %r11d,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%r9,%rdx,8)
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%r9,%rax,8)
add    %r10,%rsi
add    %r12,%rcx
add    %r12,%r9
add    $0xfffffffe,%edi
jne    1320 <my_daxpyz+0x220>
jmp    1572 <my_daxpyz+0x472>
cmp    $0x4,%edi
jb     1572 <my_daxpyz+0x472>
mov    %edi,%r14d
lea    0x4(%r8),%rax
cmp    %r14,%rax
mov    %r14,%r11
cmova  %rax,%r11
mov    %r8,%rdx
not    %rdx
add    %rdx,%r11
cmp    $0x4,%r11
jae    138d <my_daxpyz+0x28d>
mov    %r8,%rdx
jmp    1510 <my_daxpyz+0x410>
cmp    %r14,%rax
cmovbe %r14,%rax
lea    (%r9,%r8,8),%rdi
add    %rdx,%rax
movabs $0x1ffffffffffffffc,%rdx
ff ff 1f
and    %rax,%rdx
or     %r8,%rdx
lea    (%r9,%rdx,8),%rbp
add    $0x20,%rbp
lea    (%rcx,%r8,8),%rax
lea    (%rcx,%rdx,8),%rbx
add    $0x20,%rbx
lea    (%rsi,%r8,8),%r10
lea    (%rsi,%rdx,8),%rdx
add    $0x20,%rdx
cmp    %rbx,%rdi
setb   %r15b
cmp    %rbp,%rax
setb   %bl
cmp    %rdx,%rdi
setb   %al
cmp    %rbp,%r10
setb   %dl
test   %bl,%r15b
jne    14fe <my_daxpyz+0x3fe>
and    %dl,%al
jne    14f9 <my_daxpyz+0x3f9>
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r10
and    $0xfffffffffffffffe,%r10
lea    (%r8,%r10,4),%rdx
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %eax,%eax
mov    %r10,%rdi
nopw   0x0(%rax,%rax,1)
mov    %rax,%rbx
or     %r8,%rbx
lea    0x0(,%rbx,8),%rbp
or     $0x20,%rbp
movsd  (%rcx,%rbx,8),%xmm7
movsd  0x8(%rcx,%rbx,8),%xmm1
movsd  0x10(%rcx,%rbx,8),%xmm6
movsd  0x18(%rcx,%rbx,8),%xmm9
movhpd (%rcx,%rbp,1),%xmm7
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,%rbp,1),%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm7,%xmm5
movhpd 0x28(%rcx,%rbx,8),%xmm1
movhpd 0x28(%rsi,%rbx,8),%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm1,%xmm2
movhpd 0x30(%rcx,%rbx,8),%xmm6
movhpd 0x30(%rsi,%rbx,8),%xmm3
mulpd  %xmm8,%xmm3
addpd  %xmm6,%xmm3
movhpd 0x38(%rcx,%rbx,8),%xmm9
movhpd 0x38(%rsi,%rbx,8),%xmm4
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(%r9,%rbx,8)
movupd %xmm5,0x10(%r9,%rbx,8)
movups %xmm2,0x20(%r9,%rbx,8)
movupd %xmm1,(%r9,%rbx,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1420 <my_daxpyz+0x320>
cmp    %r10,%r11
jne    1510 <my_daxpyz+0x410>
jmp    1572 <my_daxpyz+0x472>
mov    %r8,%rdx
jmp    1510 <my_daxpyz+0x410>
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%r9,%rdx,8)
movsd  0x8(%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r9,%rdx,8)
movsd  0x10(%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx,%rdx,8),%xmm1
movsd  %xmm1,0x10(%r9,%rdx,8)
movsd  0x18(%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rcx,%rdx,8),%xmm1
movsd  %xmm1,0x18(%r9,%rdx,8)
add    $0x4,%rdx
cmp    %r14,%rdx
jb     1510 <my_daxpyz+0x410>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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