void ZVaxpy32(int n, double y0[], double y1[], double y2[], double alpha[],
              double x0[], double x1[]) {
  register double ar00, ar01, ar10, ar11, ar20, ar21;
  register double ai00, ai01, ai10, ai11, ai20, ai21;
  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];
  ar20 = alpha[8];
  ai20 = alpha[9];
  ar21 = alpha[10];
  ai21 = alpha[11];
  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);
    y2[2 * ii] += (ar20 * xr0i - ai20 * xi0i) + (ar21 * xr1i - ai21 * xi1i);
    y2[2 * ii + 1] += (ar20 * xi0i + ai20 * xr0i) + (ar21 * xi1i + ai21 * xr1i);
  }
  return;
}


x86 assembly (clang, -O0):
<ZVaxpy32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    0x10(%rbp),%rax
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    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1562 <ZVaxpy32+0x462>
mov    -0x30(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa8(%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  -0xa0(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm2
mulsd  -0xb0(%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    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%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  -0x98(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa8(%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  -0xa0(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
mulsd  -0xb0(%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    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  -0xb0(%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    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    11da <ZVaxpy32+0xda>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZVaxpy32>:
test   %edi,%edi
jle    12dc <ZVaxpy32+0x1dc>
mov    0x8(%rsp),%r10
movsd  0x8(%r8),%xmm1
movsd  0x18(%r8),%xmm3
movsd  0x28(%r8),%xmm5
movsd  0x38(%r8),%xmm7
movsd  0x48(%r8),%xmm14
movsd  0x58(%r8),%xmm15
movapd 0xec7(%rip),%xmm4
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movapd %xmm3,%xmm11
xorpd  %xmm4,%xmm11
movapd %xmm5,%xmm12
xorpd  %xmm4,%xmm12
movapd %xmm7,%xmm13
xorpd  %xmm4,%xmm13
movapd %xmm14,%xmm10
xorpd  %xmm4,%xmm10
xorpd  %xmm15,%xmm4
mov    %edi,%edi
movsd  (%r8),%xmm6
movsd  0x10(%r8),%xmm8
movsd  0x20(%r8),%xmm0
movsd  0x30(%r8),%xmm9
unpcklpd %xmm6,%xmm6
movapd %xmm6,-0x28(%rsp)
unpcklpd %xmm2,%xmm1
movapd %xmm1,-0x18(%rsp)
unpcklpd %xmm8,%xmm8
unpcklpd %xmm11,%xmm3
movapd %xmm3,%xmm11
unpcklpd %xmm0,%xmm0
unpcklpd %xmm12,%xmm5
movapd %xmm5,%xmm12
unpcklpd %xmm9,%xmm9
unpcklpd %xmm13,%xmm7
movapd %xmm7,%xmm13
movsd  0x40(%r8),%xmm2
unpcklpd %xmm2,%xmm2
unpcklpd %xmm10,%xmm14
movapd %xmm14,%xmm10
movsd  0x50(%r8),%xmm3
unpcklpd %xmm3,%xmm3
unpcklpd %xmm4,%xmm15
shl    $0x4,%rdi
xor    %eax,%eax
movupd (%r9,%rax,1),%xmm6
movupd (%r10,%rax,1),%xmm5
movapd %xmm6,%xmm4
mulpd  -0x18(%rsp),%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd -0x28(%rsp),%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm5,%xmm4
mulpd  %xmm11,%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm8,%xmm14
mulpd  %xmm5,%xmm14
addpd  %xmm4,%xmm14
addpd  %xmm7,%xmm14
movupd (%rsi,%rax,1),%xmm4
addpd  %xmm14,%xmm4
movupd %xmm4,(%rsi,%rax,1)
movapd %xmm6,%xmm4
mulpd  %xmm12,%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm0,%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm5,%xmm4
mulpd  %xmm13,%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm9,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm4,%xmm1
addpd  %xmm7,%xmm1
movupd (%rdx,%rax,1),%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,(%rdx,%rax,1)
movapd %xmm2,%xmm1
mulpd  %xmm6,%xmm1
mulpd  %xmm10,%xmm6
shufpd $0x1,%xmm6,%xmm6
addpd  %xmm1,%xmm6
movapd %xmm3,%xmm1
mulpd  %xmm5,%xmm1
mulpd  %xmm15,%xmm5
shufpd $0x1,%xmm5,%xmm5
addpd  %xmm1,%xmm5
addpd  %xmm6,%xmm5
movupd (%rcx,%rax,1),%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,(%rcx,%rax,1)
add    $0x10,%rax
cmp    %rax,%rdi
jne    11f0 <ZVaxpy32+0xf0>
ret

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

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