void ZVaxpy22(int n, double y0[], double y1[], double alpha[], double x0[],
              double x1[]) {
  register double ar00, ar01, ar10, ar11;
  register double ai00, ai01, ai10, ai11;
  register double xr0i, xr1i;
  register double xi0i, xi1i;
  int ii;
  ar00 = alpha[0];
  ai00 = alpha[1];
  ar01 = alpha[2];
  ai01 = alpha[3];
  ar10 = alpha[4];
  ai10 = alpha[5];
  ar11 = alpha[6];
  ai11 = alpha[7];
  for (ii = 0; ii < n; ii++) {
    xr0i = x0[2 * ii];
    xi0i = x0[2 * ii + 1];
    xr1i = x1[2 * ii];
    xi1i = x1[2 * ii + 1];
    y0[2 * ii] += (ar00 * xr0i - ai00 * xi0i) + (ar01 * xr1i - ai01 * xi1i);
    y0[2 * ii + 1] += (ar00 * xi0i + ai00 * xr0i) + (ar01 * xi1i + ai01 * xr1i);
    y1[2 * ii] += (ar10 * xr0i - ai10 * xi0i) + (ar11 * xr1i - ai11 * xi1i);
    y1[2 * ii + 1] += (ar10 * xi0i + ai10 * xr0i) + (ar11 * xi1i + ai11 * xr1i);
  }
  return;
}


x86 assembly (clang, -O0):
<ZVaxpy22>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1401 <ZVaxpy22+0x301>
mov    -0x28(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm3
movsd  -0x60(%rbp),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0x60(%rbp),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1198 <ZVaxpy22+0x98>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZVaxpy22>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
test   %edi,%edi
jle    1590 <ZVaxpy22+0x490>
movsd  (%rcx),%xmm15
movsd  0x8(%rcx),%xmm5
movsd  0x10(%rcx),%xmm13
movsd  0x18(%rcx),%xmm7
movsd  0x20(%rcx),%xmm8
movsd  0x28(%rcx),%xmm9
movsd  0x30(%rcx),%xmm10
movsd  0x38(%rcx),%xmm11
movapd 0xeb2(%rip),%xmm0
movapd %xmm5,%xmm1
xorpd  %xmm0,%xmm1
movapd %xmm7,%xmm2
xorpd  %xmm0,%xmm2
movapd %xmm9,%xmm3
xorpd  %xmm0,%xmm3
xorpd  %xmm11,%xmm0
mov    %edi,%eax
cmp    $0x1,%edi
jne    117a <ZVaxpy22+0x7a>
xor    %ecx,%ecx
jmp    14bc <ZVaxpy22+0x3bc>
mov    %rax,%rcx
shl    $0x4,%rcx
lea    (%rsi,%rcx,1),%rbx
lea    (%rdx,%rcx,1),%rbp
lea    (%r8,%rcx,1),%rdi
add    %r9,%rcx
cmp    %rsi,%rbp
seta   -0x80(%rsp)
cmp    %rdx,%rbx
seta   %r14b
cmp    %rsi,%rdi
seta   %r12b
cmp    %r8,%rbx
seta   %r13b
cmp    %rsi,%rcx
seta   %r10b
cmp    %r9,%rbx
seta   %r15b
cmp    %rdx,%rdi
seta   %r11b
cmp    %r8,%rbp
seta   %dil
cmp    %rdx,%rcx
seta   %bl
cmp    %r9,%rbp
seta   %bpl
xor    %ecx,%ecx
test   %r14b,-0x80(%rsp)
jne    14bc <ZVaxpy22+0x3bc>
and    %r13b,%r12b
jne    14bc <ZVaxpy22+0x3bc>
and    %r15b,%r10b
jne    14bc <ZVaxpy22+0x3bc>
and    %dil,%r11b
jne    14bc <ZVaxpy22+0x3bc>
and    %bpl,%bl
jne    14bc <ZVaxpy22+0x3bc>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm1,-0x50(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,-0x80(%rsp)
movapd %xmm15,0x40(%rsp)
unpcklpd %xmm15,%xmm15
movapd %xmm2,-0x60(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x80(%rsp)
movapd %xmm13,0x20(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm5,0x30(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,0x90(%rsp)
movapd %xmm7,0x10(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x70(%rsp)
movapd %xmm3,-0x70(%rsp)
unpcklpd %xmm3,%xmm3
movapd %xmm3,0x60(%rsp)
movapd %xmm8,(%rsp)
movapd %xmm8,%xmm4
unpcklpd %xmm8,%xmm4
movapd %xmm0,-0x40(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x50(%rsp)
movapd %xmm10,-0x20(%rsp)
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
movapd %xmm9,-0x10(%rsp)
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
movapd %xmm11,-0x30(%rsp)
movapd %xmm11,%xmm5
unpcklpd %xmm11,%xmm5
xor    %edi,%edi
mov    %rcx,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r8,%rdi,1),%xmm11
movupd 0x10(%r8,%rdi,1),%xmm1
movapd %xmm11,%xmm9
unpcklpd %xmm1,%xmm9
unpckhpd %xmm1,%xmm11
movupd (%r9,%rdi,1),%xmm12
movupd 0x10(%r9,%rdi,1),%xmm1
movapd %xmm12,%xmm10
unpcklpd %xmm1,%xmm10
unpckhpd %xmm1,%xmm12
movapd %xmm11,%xmm1
mulpd  -0x80(%rsp),%xmm1
movapd %xmm15,%xmm0
mulpd  %xmm9,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm12,%xmm1
mulpd  0x80(%rsp),%xmm1
movapd %xmm13,%xmm2
mulpd  %xmm10,%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd (%rsi,%rdi,1),%xmm14
movupd 0x10(%rsi,%rdi,1),%xmm1
movapd %xmm14,%xmm0
unpcklpd %xmm1,%xmm0
addpd  %xmm2,%xmm0
unpckhpd %xmm1,%xmm14
movapd 0x90(%rsp),%xmm1
mulpd  %xmm9,%xmm1
movapd %xmm15,%xmm2
mulpd  %xmm11,%xmm2
addpd  %xmm1,%xmm2
movapd 0x70(%rsp),%xmm1
mulpd  %xmm10,%xmm1
movapd %xmm13,%xmm8
mulpd  %xmm12,%xmm8
addpd  %xmm1,%xmm8
addpd  %xmm2,%xmm8
addpd  %xmm14,%xmm8
movapd %xmm0,%xmm1
unpckhpd %xmm8,%xmm1
unpcklpd %xmm8,%xmm0
movupd %xmm0,(%rsi,%rdi,1)
movupd %xmm1,0x10(%rsi,%rdi,1)
movapd %xmm11,%xmm0
mulpd  0x60(%rsp),%xmm0
movapd %xmm4,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm12,%xmm0
mulpd  0x50(%rsp),%xmm0
movapd %xmm6,%xmm2
mulpd  %xmm10,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%rdx,%rdi,1),%xmm3
movupd 0x10(%rdx,%rdi,1),%xmm1
movapd %xmm3,%xmm0
unpcklpd %xmm1,%xmm0
addpd  %xmm2,%xmm0
unpckhpd %xmm1,%xmm3
mulpd  %xmm7,%xmm9
mulpd  %xmm4,%xmm11
addpd  %xmm9,%xmm11
mulpd  %xmm5,%xmm10
mulpd  %xmm6,%xmm12
addpd  %xmm10,%xmm12
addpd  %xmm11,%xmm12
addpd  %xmm3,%xmm12
movapd %xmm0,%xmm1
unpckhpd %xmm12,%xmm1
unpcklpd %xmm12,%xmm0
movupd %xmm0,(%rdx,%rdi,1)
movupd %xmm1,0x10(%rdx,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%r10
jne    12e0 <ZVaxpy22+0x1e0>
cmp    %rax,%rcx
movapd 0x40(%rsp),%xmm15
movapd 0x30(%rsp),%xmm5
movapd 0x20(%rsp),%xmm13
movapd 0x10(%rsp),%xmm7
movapd (%rsp),%xmm8
movapd -0x10(%rsp),%xmm9
movapd -0x20(%rsp),%xmm10
movapd -0x30(%rsp),%xmm11
movapd -0x40(%rsp),%xmm0
movapd -0x50(%rsp),%xmm1
movapd -0x60(%rsp),%xmm2
movapd -0x70(%rsp),%xmm3
je     1590 <ZVaxpy22+0x490>
unpcklpd %xmm1,%xmm5
unpcklpd %xmm15,%xmm15
unpcklpd %xmm2,%xmm7
unpcklpd %xmm13,%xmm13
unpcklpd %xmm3,%xmm9
unpcklpd %xmm8,%xmm8
unpcklpd %xmm0,%xmm11
unpcklpd %xmm10,%xmm10
sub    %rcx,%rax
shl    $0x4,%rcx
nopl   0x0(%rax)
movupd (%r8,%rcx,1),%xmm2
movupd (%r9,%rcx,1),%xmm0
movapd %xmm2,%xmm1
mulpd  %xmm5,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm15,%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm0,%xmm1
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm13,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd (%rsi,%rcx,1),%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rsi,%rcx,1)
movapd %xmm8,%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm9,%xmm2
shufpd $0x1,%xmm2,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm10,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm11,%xmm0
shufpd $0x1,%xmm0,%xmm0
addpd  %xmm1,%xmm0
addpd  %xmm2,%xmm0
movupd (%rdx,%rcx,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,1)
add    $0x10,%rcx
add    $0xffffffffffffffff,%rax
jne    14f0 <ZVaxpy22+0x3f0>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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