int daxpy_(int *n, double *sa, double *sx, int *incx, double *sy, int *incy) {
  long int i, m, ix, iy, nn, iincx, iincy;
  register double ssa;
  nn = *n;
  ssa = *sa;
  iincx = *incx;
  iincy = *incy;
  if (nn > 0 && ssa != 0.0) {
    if (iincx == 1 && iincy == 1) {
      m = nn - 3;
      for (i = 0; i < m; i += 4) {
        sy[i] += ssa * sx[i];
        sy[i + 1] += ssa * sx[i + 1];
        sy[i + 2] += ssa * sx[i + 2];
        sy[i + 3] += ssa * sx[i + 3];
      }
      for (; i < nn; ++i)
        sy[i] += ssa * sx[i];
    } else {
      ix = iincx >= 0 ? 0 : (1 - nn) * iincx;
      iy = iincy >= 0 ? 0 : (1 - nn) * iincy;
      for (i = 0; i < nn; i++) {
        sy[iy] += ssa * sx[ix];
        ix += iincx;
        iy += iincy;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<daxpy_>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x58(%rbp)
jle    139e <daxpy_+0x29e>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1172 <daxpy_+0x72>
jp     1172 <daxpy_+0x72>
jmp    139e <daxpy_+0x29e>
cmpq   $0x1,-0x60(%rbp)
jne    12c9 <daxpy_+0x1c9>
cmpq   $0x1,-0x68(%rbp)
jne    12c9 <daxpy_+0x1c9>
mov    -0x58(%rbp),%rax
sub    $0x3,%rax
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1274 <daxpy_+0x174>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x10(%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x10(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x18(%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
jmp    119c <daxpy_+0x9c>
jmp    1279 <daxpy_+0x179>
mov    -0x38(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    12c4 <daxpy_+0x1c4>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1279 <daxpy_+0x179>
jmp    1399 <daxpy_+0x299>
cmpq   $0x0,-0x60(%rbp)
jl     12df <daxpy_+0x1df>
xor    %eax,%eax
mov    %rax,-0x78(%rbp)
jmp    12f1 <daxpy_+0x1f1>
mov    $0x1,%eax
sub    -0x58(%rbp),%rax
imul   -0x60(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x68(%rbp)
jl     130f <daxpy_+0x20f>
xor    %eax,%eax
mov    %rax,-0x80(%rbp)
jmp    1321 <daxpy_+0x221>
mov    $0x1,%eax
sub    -0x58(%rbp),%rax
imul   -0x68(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    1394 <daxpy_+0x294>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1331 <daxpy_+0x231>
jmp    1399 <daxpy_+0x299>
jmp    139e <daxpy_+0x29e>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<daxpy_>:
push   %r15
push   %r14
push   %r12
push   %rbx
movslq (%rdi),%r12
test   %r12,%r12
jle    1688 <daxpy_+0x588>
movsd  (%rsi),%xmm9
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm9
jne    1129 <daxpy_+0x29>
jnp    1688 <daxpy_+0x588>
movslq (%rcx),%r11
movslq (%r9),%r9
cmp    $0x1,%r11d
jne    1228 <daxpy_+0x128>
cmp    $0x1,%r9d
jne    1228 <daxpy_+0x128>
cmp    $0x4,%r12d
jb     12fe <daxpy_+0x1fe>
lea    -0x3(%r12),%r11
cmp    $0x5,%r11
mov    $0x4,%eax
mov    $0x4,%r10d
cmovge %r11,%r10
add    $0xffffffffffffffff,%r10
cmp    $0x4,%r10
jb     11a2 <daxpy_+0xa2>
cmp    $0x5,%r11
cmovge %r11,%rax
add    $0x3,%rax
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
and    %rax,%rcx
lea    (%rdx,%rcx,8),%rax
cmp    %r8,%rax
jbe    1441 <daxpy_+0x341>
lea    (%r8,%rcx,8),%rax
cmp    %rdx,%rax
jbe    1441 <daxpy_+0x341>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x8(%r8,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x10(%r8,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r8,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x18(%r8,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %r11,%rcx
jl     11b0 <daxpy_+0xb0>
cmp    %r12,%rcx
jl     1309 <daxpy_+0x209>
jmp    1688 <daxpy_+0x588>
mov    $0x1,%esi
sub    %r12,%rsi
mov    %rsi,%rbx
imul   %r9,%rbx
xor    %r10d,%r10d
test   %r9d,%r9d
cmovns %r10,%rbx
imul   %r11,%rsi
test   %r11d,%r11d
cmovns %r10,%rsi
cmp    $0x4,%r12d
jae    13f8 <daxpy_+0x2f8>
mov    %rsi,%r15
mov    %rbx,%rcx
mov    %r10,%rax
not    %rax
test   $0x1,%r12b
je     1289 <daxpy_+0x189>
movsd  (%rdx,%r15,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    %r11,%r15
add    %r9,%rcx
or     $0x1,%r10
add    %r12,%rax
je     1688 <daxpy_+0x588>
sub    %r10,%r12
mov    %r11,%rsi
shl    $0x4,%rsi
shl    $0x3,%r11
lea    (%r11,%r15,8),%rbx
shl    $0x3,%r15
mov    %r9,%rdi
shl    $0x4,%rdi
shl    $0x3,%r9
lea    (%r9,%rcx,8),%rax
shl    $0x3,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%r15,1),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rcx,1),%xmm0
movsd  %xmm0,(%r8,%rcx,1)
movsd  (%rdx,%rbx,1),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rax,1),%xmm0
movsd  %xmm0,(%r8,%rax,1)
add    %rsi,%rdx
add    %rdi,%r8
add    $0xfffffffffffffffe,%r12
jne    12c0 <daxpy_+0x1c0>
jmp    1688 <daxpy_+0x588>
xor    %ecx,%ecx
cmp    %r12,%rcx
jge    1688 <daxpy_+0x588>
mov    %r12,%r11
sub    %rcx,%r11
cmp    $0x4,%r11
jb     161d <daxpy_+0x51d>
lea    (%r8,%rcx,8),%rax
lea    (%rdx,%r12,8),%rsi
cmp    %rsi,%rax
jae    1337 <daxpy_+0x237>
lea    (%r8,%r12,8),%rax
lea    (%rdx,%rcx,8),%rsi
cmp    %rax,%rsi
jb     161d <daxpy_+0x51d>
mov    %r11,%r9
and    $0xfffffffffffffffc,%r9
movapd %xmm9,%xmm1
unpcklpd %xmm9,%xmm1
lea    -0x4(%r9),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     15d5 <daxpy_+0x4d5>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r8,%rcx,8),%rsi
add    $0x30,%rsi
lea    (%rdx,%rcx,8),%r14
add    $0x30,%r14
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x30(%r14,%rdi,8),%xmm0
movupd -0x20(%r14,%rdi,8),%xmm2
mulpd  %xmm1,%xmm0
movupd -0x30(%rsi,%rdi,8),%xmm3
addpd  %xmm0,%xmm3
movupd -0x20(%rsi,%rdi,8),%xmm0
movupd -0x10(%rsi,%rdi,8),%xmm4
movupd (%rsi,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm3,-0x30(%rsi,%rdi,8)
movupd %xmm2,-0x20(%rsi,%rdi,8)
movupd -0x10(%r14,%rdi,8),%xmm0
movupd (%r14,%rdi,8),%xmm2
mulpd  %xmm1,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm0,-0x10(%rsi,%rdi,8)
movupd %xmm2,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1380 <daxpy_+0x280>
jmp    15d7 <daxpy_+0x4d7>
xor    %r10d,%r10d
cmp    $0x1,%r9d
jne    1256 <daxpy_+0x156>
cmp    $0x1,%r11d
jne    1256 <daxpy_+0x156>
lea    (%r8,%rbx,8),%rax
lea    (%rsi,%r12,1),%rcx
lea    (%rdx,%rcx,8),%rcx
cmp    %rcx,%rax
jae    1545 <daxpy_+0x445>
lea    (%rbx,%r12,1),%rax
lea    (%r8,%rax,8),%rax
lea    (%rdx,%rsi,8),%rcx
cmp    %rax,%rcx
jae    1545 <daxpy_+0x445>
xor    %r10d,%r10d
jmp    1256 <daxpy_+0x156>
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
lea    0x0(,%r9,4),%rcx
movapd %xmm9,%xmm8
unpcklpd %xmm9,%xmm8
xor    %edi,%edi
mov    %r9,%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,1),%xmm2
movsd  0x8(%rdx,%rdi,1),%xmm3
movsd  0x10(%rdx,%rdi,1),%xmm5
movsd  0x18(%rdx,%rdi,1),%xmm4
movhpd 0x20(%rdx,%rdi,1),%xmm2
movsd  (%r8,%rdi,1),%xmm6
movsd  0x8(%r8,%rdi,1),%xmm7
movsd  0x10(%r8,%rdi,1),%xmm1
movsd  0x18(%r8,%rdi,1),%xmm0
movhpd 0x20(%r8,%rdi,1),%xmm6
mulpd  %xmm8,%xmm2
addpd  %xmm6,%xmm2
movhpd 0x28(%rdx,%rdi,1),%xmm3
movhpd 0x28(%r8,%rdi,1),%xmm7
mulpd  %xmm8,%xmm3
addpd  %xmm7,%xmm3
movhpd 0x30(%rdx,%rdi,1),%xmm5
movhpd 0x30(%r8,%rdi,1),%xmm1
mulpd  %xmm8,%xmm5
addpd  %xmm1,%xmm5
movhpd 0x38(%rdx,%rdi,1),%xmm4
movhpd 0x38(%r8,%rdi,1),%xmm0
mulpd  %xmm8,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm5,%xmm0
unpcklpd %xmm4,%xmm0
movapd %xmm2,%xmm1
unpcklpd %xmm3,%xmm1
movhlps %xmm5,%xmm4
movhlps %xmm2,%xmm3
movups %xmm3,0x20(%r8,%rdi,1)
movups %xmm4,0x30(%r8,%rdi,1)
movupd %xmm1,(%r8,%rdi,1)
movupd %xmm0,0x10(%r8,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1470 <daxpy_+0x370>
cmp    %r9,%r10
jne    11b0 <daxpy_+0xb0>
jmp    121a <daxpy_+0x11a>
mov    %r12,%r10
and    $0xfffffffffffffffc,%r10
mov    %r10,%r15
imul   %r11,%r15
add    %rsi,%r15
mov    %r10,%rcx
imul   %r9,%rcx
add    %rbx,%rcx
movapd %xmm9,%xmm1
unpcklpd %xmm9,%xmm1
lea    (%r8,%rbx,8),%rbx
add    $0x10,%rbx
mov    %r9,%r14
shl    $0x5,%r14
lea    (%rdx,%rsi,8),%rsi
add    $0x10,%rsi
mov    %r11,%rdi
shl    $0x5,%rdi
mov    %r10,%rax
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rsi),%xmm0
movupd (%rsi),%xmm2
movupd -0x10(%rbx),%xmm3
movupd (%rbx),%xmm4
mulpd  %xmm1,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm0,-0x10(%rbx)
movupd %xmm2,(%rbx)
add    %r14,%rbx
add    %rdi,%rsi
add    $0xfffffffffffffffc,%rax
jne    1590 <daxpy_+0x490>
cmp    %r12,%r10
jne    125c <daxpy_+0x15c>
jmp    1688 <daxpy_+0x588>
xor    %edi,%edi
test   $0x1,%r10b
je     1615 <daxpy_+0x515>
add    %rcx,%rdi
movupd (%rdx,%rdi,8),%xmm0
movupd 0x10(%rdx,%rdi,8),%xmm2
movupd (%r8,%rdi,8),%xmm3
movupd 0x10(%r8,%rdi,8),%xmm4
mulpd  %xmm1,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm0,(%r8,%rdi,8)
movupd %xmm2,0x10(%r8,%rdi,8)
cmp    %r9,%r11
je     1688 <daxpy_+0x588>
add    %r9,%rcx
mov    %r12d,%esi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
test   $0x1,%sil
je     1648 <daxpy_+0x548>
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
add    %r12,%rax
je     1688 <daxpy_+0x588>
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x8(%r8,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    1650 <daxpy_+0x550>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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