void ZVaxpy12(int n, double y0[], double alpha[], double x0[], double x1[]) {
  register double ar00, ar01;
  register double ai00, ai01;
  register double xr0i, xr1i;
  register double xi0i, xi1i;
  int ii;
  ar00 = alpha[0];
  ai00 = alpha[1];
  ar01 = alpha[2];
  ai01 = alpha[3];
  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);
  }
  return;
}


x86 assembly (clang, -O0):
<ZVaxpy12>:
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    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a8 <ZVaxpy12+0x1a8>
mov    -0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
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    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x58(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1155 <ZVaxpy12+0x55>
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZVaxpy12>:
push   %rbx
test   %edi,%edi
jle    1335 <ZVaxpy12+0x235>
movsd  (%rdx),%xmm10
movsd  0x8(%rdx),%xmm12
movsd  0x10(%rdx),%xmm11
movsd  0x18(%rdx),%xmm13
movapd 0xed8(%rip),%xmm0
movapd %xmm12,%xmm1
xorpd  %xmm0,%xmm1
xorpd  %xmm13,%xmm0
mov    %edi,%eax
cmp    $0x1,%edi
jne    1144 <ZVaxpy12+0x44>
xor    %edx,%edx
jmp    12ba <ZVaxpy12+0x1ba>
mov    %rax,%rdx
shl    $0x4,%rdx
lea    (%rsi,%rdx,1),%rdi
lea    (%rcx,%rdx,1),%r9
add    %r8,%rdx
cmp    %rsi,%r9
seta   %r11b
cmp    %rcx,%rdi
seta   %bl
cmp    %rsi,%rdx
seta   %r10b
cmp    %r8,%rdi
seta   %r9b
xor    %edx,%edx
test   %bl,%r11b
jne    12ba <ZVaxpy12+0x1ba>
and    %r9b,%r10b
jne    12ba <ZVaxpy12+0x1ba>
mov    %eax,%edx
and    $0xfffffffe,%edx
movapd %xmm1,-0x50(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,-0x10(%rsp)
movapd %xmm10,%xmm14
unpcklpd %xmm10,%xmm14
movapd %xmm0,-0x40(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,-0x20(%rsp)
movapd %xmm11,%xmm15
unpcklpd %xmm11,%xmm15
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
movapd %xmm0,-0x30(%rsp)
movapd %xmm13,%xmm9
unpcklpd %xmm13,%xmm9
xor    %edi,%edi
mov    %rdx,%r9
nopl   (%rax)
movupd (%rcx,%rdi,1),%xmm6
movupd 0x10(%rcx,%rdi,1),%xmm4
movapd %xmm6,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm4,%xmm6
movupd (%r8,%rdi,1),%xmm4
movupd 0x10(%r8,%rdi,1),%xmm8
movapd %xmm4,%xmm5
unpcklpd %xmm8,%xmm5
unpckhpd %xmm8,%xmm4
movapd %xmm6,%xmm1
mulpd  -0x10(%rsp),%xmm1
movapd %xmm14,%xmm7
mulpd  %xmm0,%xmm7
addpd  %xmm1,%xmm7
movapd %xmm4,%xmm1
mulpd  -0x20(%rsp),%xmm1
movapd %xmm15,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm7,%xmm2
movupd (%rsi,%rdi,1),%xmm3
movupd 0x10(%rsi,%rdi,1),%xmm7
movapd %xmm3,%xmm1
unpcklpd %xmm7,%xmm1
addpd  %xmm2,%xmm1
unpckhpd %xmm7,%xmm3
mulpd  -0x30(%rsp),%xmm0
mulpd  %xmm14,%xmm6
addpd  %xmm0,%xmm6
mulpd  %xmm9,%xmm5
mulpd  %xmm15,%xmm4
addpd  %xmm5,%xmm4
addpd  %xmm6,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm1,%xmm0
unpckhpd %xmm4,%xmm0
unpcklpd %xmm4,%xmm1
movupd %xmm1,(%rsi,%rdi,1)
movupd %xmm0,0x10(%rsi,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%r9
jne    11e0 <ZVaxpy12+0xe0>
cmp    %rax,%rdx
movapd -0x40(%rsp),%xmm0
movapd -0x50(%rsp),%xmm1
je     1335 <ZVaxpy12+0x235>
unpcklpd %xmm1,%xmm12
unpcklpd %xmm10,%xmm10
unpcklpd %xmm0,%xmm13
unpcklpd %xmm11,%xmm11
sub    %rdx,%rax
shl    $0x4,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rcx,%rdx,1),%xmm0
movupd (%r8,%rdx,1),%xmm1
movapd %xmm10,%xmm2
mulpd  %xmm0,%xmm2
mulpd  %xmm12,%xmm0
shufpd $0x1,%xmm0,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm11,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm13,%xmm1
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movupd (%rsi,%rdx,1),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rsi,%rdx,1)
add    $0x10,%rdx
add    $0xffffffffffffffff,%rax
jne    12e0 <ZVaxpy12+0x1e0>
pop    %rbx
ret

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

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