void ZVaxpy21(int n, double y0[], double y1[], double alpha[], double x0[]) {
  register double ar00, ar10;
  register double ai00, ai10;
  register double xr0i;
  register double xi0i;
  int ii;
  ar00 = alpha[0];
  ai00 = alpha[1];
  ar10 = alpha[2];
  ai10 = alpha[3];
  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);
  }
  return;
}


x86 assembly (clang, -O0):
<ZVaxpy21>:
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    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a0 <ZVaxpy21+0x1a0>
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x58(%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    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x58(%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    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1155 <ZVaxpy21+0x55>
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZVaxpy21>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
jle    137d <ZVaxpy21+0x27d>
movsd  (%rcx),%xmm10
movsd  0x8(%rcx),%xmm11
movsd  0x10(%rcx),%xmm15
movsd  0x18(%rcx),%xmm3
movapd 0xed3(%rip),%xmm12
movapd %xmm11,%xmm0
xorpd  %xmm12,%xmm0
xorpd  %xmm3,%xmm12
mov    %edi,%eax
cmp    $0x1,%edi
jne    114a <ZVaxpy21+0x4a>
xor    %ecx,%ecx
jmp    12ff <ZVaxpy21+0x1ff>
mov    %rax,%rcx
shl    $0x4,%rcx
lea    (%rsi,%rcx,1),%rdi
lea    (%rdx,%rcx,1),%rbx
add    %r8,%rcx
cmp    %rsi,%rbx
seta   %r14b
cmp    %rdx,%rdi
seta   %r15b
cmp    %rsi,%rcx
seta   %bpl
cmp    %r8,%rdi
seta   %r10b
cmp    %rdx,%rcx
seta   %r9b
cmp    %r8,%rbx
seta   %r11b
xor    %ecx,%ecx
test   %r15b,%r14b
jne    12ff <ZVaxpy21+0x1ff>
and    %r10b,%bpl
jne    12ff <ZVaxpy21+0x1ff>
and    %r11b,%r9b
jne    12ff <ZVaxpy21+0x1ff>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,-0x48(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,-0x18(%rsp)
movapd %xmm10,%xmm14
unpcklpd %xmm10,%xmm14
movapd %xmm11,%xmm0
unpcklpd %xmm11,%xmm0
movapd %xmm0,-0x28(%rsp)
movapd %xmm12,-0x38(%rsp)
unpcklpd %xmm12,%xmm12
movapd %xmm15,%xmm2
unpcklpd %xmm15,%xmm2
movapd %xmm3,%xmm13
unpcklpd %xmm3,%xmm13
xor    %edi,%edi
mov    %rcx,%r9
nopw   0x0(%rax,%rax,1)
movupd (%r8,%rdi,1),%xmm5
movupd 0x10(%r8,%rdi,1),%xmm0
movapd %xmm5,%xmm4
unpcklpd %xmm0,%xmm4
unpckhpd %xmm0,%xmm5
movapd %xmm5,%xmm0
mulpd  -0x18(%rsp),%xmm0
movapd %xmm14,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm0,%xmm7
movupd (%rsi,%rdi,1),%xmm9
movupd 0x10(%rsi,%rdi,1),%xmm8
movapd %xmm9,%xmm0
unpcklpd %xmm8,%xmm0
addpd  %xmm7,%xmm0
unpckhpd %xmm8,%xmm9
movapd -0x28(%rsp),%xmm7
mulpd  %xmm4,%xmm7
movapd %xmm14,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
addpd  %xmm9,%xmm6
movapd %xmm0,%xmm7
unpckhpd %xmm6,%xmm7
unpcklpd %xmm6,%xmm0
movupd %xmm0,(%rsi,%rdi,1)
movupd %xmm7,0x10(%rsi,%rdi,1)
movapd %xmm2,%xmm0
mulpd  %xmm5,%xmm0
mulpd  %xmm12,%xmm5
movapd %xmm2,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd (%rdx,%rdi,1),%xmm1
movupd 0x10(%rdx,%rdi,1),%xmm7
movapd %xmm1,%xmm5
unpcklpd %xmm7,%xmm5
addpd  %xmm6,%xmm5
unpckhpd %xmm7,%xmm1
mulpd  %xmm13,%xmm4
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm5,%xmm0
unpckhpd %xmm4,%xmm0
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rdx,%rdi,1)
movupd %xmm0,0x10(%rdx,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%r9
jne    1200 <ZVaxpy21+0x100>
cmp    %rax,%rcx
movapd -0x38(%rsp),%xmm12
movapd -0x48(%rsp),%xmm0
je     137d <ZVaxpy21+0x27d>
unpcklpd %xmm0,%xmm11
unpcklpd %xmm10,%xmm10
unpcklpd %xmm12,%xmm3
unpcklpd %xmm15,%xmm15
sub    %rcx,%rax
shl    $0x4,%rcx
nopw   0x0(%rax,%rax,1)
movupd (%r8,%rcx,1),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm11,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm10,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%rsi,%rcx,1),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rsi,%rcx,1)
movapd %xmm15,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm3,%xmm0
shufpd $0x1,%xmm0,%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%rcx,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,1)
add    $0x10,%rcx
add    $0xffffffffffffffff,%rax
jne    1320 <ZVaxpy21+0x220>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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