void ZVaxpy31(int n, double y0[], double y1[], double y2[], double alpha[],
              double x0[]) {
  register double ar00, ar10, ar20;
  register double ai00, ai10, ai20;
  register double xr0i;
  register double xi0i;
  int ii;
  ar00 = alpha[0];
  ai00 = alpha[1];
  ar10 = alpha[2];
  ai10 = alpha[3];
  ar20 = alpha[4];
  ai20 = alpha[5];
  for (ii = 0; ii < n; ii++) {
    xr0i = x0[2 * ii];
    xi0i = x0[2 * ii + 1];
    y0[2 * ii] += (ar00 * xr0i - ai00 * xi0i);
    y0[2 * ii + 1] += (ar00 * xi0i + ai00 * xr0i);
    y1[2 * ii] += (ar10 * xr0i - ai10 * xi0i);
    y1[2 * ii + 1] += (ar10 * xi0i + ai10 * xr0i);
    y2[2 * ii] += (ar20 * xr0i - ai20 * xi0i);
    y2[2 * ii + 1] += (ar20 * xi0i + ai20 * xr0i);
  }
  return;
}


x86 assembly (clang, -O0):
<ZVaxpy31>:
push   %rbp
mov    %rsp,%rbp
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,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1340 <ZVaxpy31+0x240>
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%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  -0x68(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1175 <ZVaxpy31+0x75>
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZVaxpy31>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %edi,%edi
jle    14ca <ZVaxpy31+0x3ca>
movsd  (%r8),%xmm13
movsd  0x8(%r8),%xmm9
movsd  0x10(%r8),%xmm15
movsd  0x18(%r8),%xmm14
movsd  0x20(%r8),%xmm8
movsd  0x28(%r8),%xmm5
movapd 0xebf(%rip),%xmm0
movapd %xmm9,%xmm1
xorpd  %xmm0,%xmm1
movapd %xmm14,%xmm2
xorpd  %xmm0,%xmm2
xorpd  %xmm5,%xmm0
mov    %edi,%r8d
cmp    $0x1,%edi
jne    1166 <ZVaxpy31+0x66>
xor    %edi,%edi
jmp    141c <ZVaxpy31+0x31c>
mov    %r8,%rdi
shl    $0x4,%rdi
lea    (%rsi,%rdi,1),%rbp
lea    (%rdx,%rdi,1),%rbx
lea    (%rcx,%rdi,1),%r12
add    %r9,%rdi
cmp    %rsi,%rbx
seta   -0x60(%rsp)
cmp    %rdx,%rbp
seta   %r15b
cmp    %rsi,%r12
seta   %al
cmp    %rcx,%rbp
seta   %r14b
cmp    %rsi,%rdi
seta   %r10b
cmp    %r9,%rbp
seta   -0x70(%rsp)
cmp    %rdx,%r12
seta   %r11b
cmp    %rcx,%rbx
seta   -0x80(%rsp)
cmp    %rdx,%rdi
seta   %r13b
cmp    %r9,%rbx
seta   %bl
cmp    %rcx,%rdi
seta   %bpl
cmp    %r9,%r12
seta   %r12b
xor    %edi,%edi
test   %r15b,-0x60(%rsp)
jne    141c <ZVaxpy31+0x31c>
and    %r14b,%al
jne    141c <ZVaxpy31+0x31c>
and    -0x70(%rsp),%r10b
jne    141c <ZVaxpy31+0x31c>
and    -0x80(%rsp),%r11b
jne    141c <ZVaxpy31+0x31c>
and    %bl,%r13b
jne    141c <ZVaxpy31+0x31c>
and    %r12b,%bpl
jne    141c <ZVaxpy31+0x31c>
mov    %r8d,%edi
and    $0xfffffffe,%edi
movapd %xmm1,-0x40(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,-0x60(%rsp)
movapd %xmm13,-0x20(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm9,%xmm1
unpcklpd %xmm9,%xmm1
movapd %xmm1,-0x70(%rsp)
movapd %xmm2,-0x50(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,-0x80(%rsp)
movapd %xmm15,%xmm2
unpcklpd %xmm15,%xmm2
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
movapd %xmm1,0x10(%rsp)
movapd %xmm0,-0x30(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,(%rsp)
movapd %xmm8,%xmm4
unpcklpd %xmm8,%xmm4
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm0,-0x10(%rsp)
xor    %eax,%eax
mov    %rdi,%r10
nopw   0x0(%rax,%rax,1)
movupd (%r9,%rax,1),%xmm11
movupd 0x10(%r9,%rax,1),%xmm12
movapd %xmm11,%xmm10
unpcklpd %xmm12,%xmm10
unpckhpd %xmm12,%xmm11
movapd %xmm11,%xmm6
mulpd  -0x60(%rsp),%xmm6
movapd %xmm13,%xmm0
mulpd  %xmm10,%xmm0
addpd  %xmm6,%xmm0
movupd (%rsi,%rax,1),%xmm1
movupd 0x10(%rsi,%rax,1),%xmm7
movapd %xmm1,%xmm6
unpcklpd %xmm7,%xmm6
addpd  %xmm0,%xmm6
unpckhpd %xmm7,%xmm1
movapd -0x70(%rsp),%xmm0
mulpd  %xmm10,%xmm0
movapd %xmm13,%xmm7
mulpd  %xmm11,%xmm7
addpd  %xmm0,%xmm7
addpd  %xmm1,%xmm7
movapd %xmm6,%xmm0
unpckhpd %xmm7,%xmm0
unpcklpd %xmm7,%xmm6
movupd %xmm6,(%rsi,%rax,1)
movupd %xmm0,0x10(%rsi,%rax,1)
movapd %xmm11,%xmm0
mulpd  -0x80(%rsp),%xmm0
movapd %xmm2,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm0,%xmm1
movupd (%rdx,%rax,1),%xmm0
movupd 0x10(%rdx,%rax,1),%xmm6
movapd %xmm0,%xmm7
unpcklpd %xmm6,%xmm7
addpd  %xmm1,%xmm7
unpckhpd %xmm6,%xmm0
movapd 0x10(%rsp),%xmm1
mulpd  %xmm10,%xmm1
movapd %xmm2,%xmm6
mulpd  %xmm11,%xmm6
addpd  %xmm1,%xmm6
addpd  %xmm0,%xmm6
movapd %xmm7,%xmm0
unpckhpd %xmm6,%xmm0
unpcklpd %xmm6,%xmm7
movupd %xmm7,(%rdx,%rax,1)
movupd %xmm0,0x10(%rdx,%rax,1)
movapd %xmm4,%xmm0
mulpd  %xmm11,%xmm0
mulpd  (%rsp),%xmm11
movapd %xmm4,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm11,%xmm1
movupd (%rcx,%rax,1),%xmm3
movupd 0x10(%rcx,%rax,1),%xmm7
movapd %xmm3,%xmm6
unpcklpd %xmm7,%xmm6
addpd  %xmm1,%xmm6
unpckhpd %xmm7,%xmm3
mulpd  -0x10(%rsp),%xmm10
addpd  %xmm0,%xmm10
addpd  %xmm3,%xmm10
movapd %xmm6,%xmm0
unpckhpd %xmm10,%xmm0
unpcklpd %xmm10,%xmm6
movupd %xmm6,(%rcx,%rax,1)
movupd %xmm0,0x10(%rcx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%r10
jne    12a0 <ZVaxpy31+0x1a0>
cmp    %r8,%rdi
movapd -0x20(%rsp),%xmm13
movapd -0x30(%rsp),%xmm0
movapd -0x40(%rsp),%xmm1
movapd -0x50(%rsp),%xmm2
je     14ca <ZVaxpy31+0x3ca>
unpcklpd %xmm1,%xmm9
unpcklpd %xmm13,%xmm13
unpcklpd %xmm2,%xmm14
unpcklpd %xmm15,%xmm15
unpcklpd %xmm0,%xmm5
unpcklpd %xmm8,%xmm8
sub    %rdi,%r8
shl    $0x4,%rdi
movupd (%r9,%rdi,1),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm9,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm13,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%rsi,%rdi,1),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rsi,%rdi,1)
movapd %xmm0,%xmm1
mulpd  %xmm14,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm15,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%rdx,%rdi,1),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rdx,%rdi,1)
movapd %xmm8,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm5,%xmm0
shufpd $0x1,%xmm0,%xmm0
addpd  %xmm1,%xmm0
movupd (%rcx,%rdi,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rdi,1)
add    $0x10,%rdi
add    $0xffffffffffffffff,%r8
jne    1440 <ZVaxpy31+0x340>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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