#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void vec_add(size_t n, double *x, double *y) {
  for (size_t i = 0; i < n; i++) {
    x[i] += y[i];
  }
}


x86 assembly (clang, -O0):
<vec_add>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1156 <vec_add+0x56>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <vec_add+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<vec_add>:
test   %rdi,%rdi
je     1287 <vec_add+0x187>
cmp    $0x4,%rdi
jb     1129 <vec_add+0x29>
lea    (%rdx,%rdi,8),%rax
cmp    %rsi,%rax
jbe    11c3 <vec_add+0xc3>
lea    (%rsi,%rdi,8),%rax
cmp    %rdx,%rax
jbe    11c3 <vec_add+0xc3>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
add    %rdi,%r8
mov    %rdi,%rcx
and    $0x3,%rcx
je     1159 <vec_add+0x59>
nopl   (%rax)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1140 <vec_add+0x40>
cmp    $0x3,%r8
jb     1287 <vec_add+0x187>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
addsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x10(%rdx,%rax,8),%xmm0
addsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rax,8)
movsd  0x18(%rdx,%rax,8),%xmm0
addsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1170 <vec_add+0x70>
jmp    1287 <vec_add+0x187>
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1288 <vec_add+0x188>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
movupd (%rsi,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rsi,%rcx,8),%xmm1
movupd 0x30(%rsi,%rcx,8),%xmm3
movupd %xmm2,(%rsi,%rcx,8)
movupd %xmm0,0x10(%rsi,%rcx,8)
movupd 0x20(%rdx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x30(%rdx,%rcx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rsi,%rcx,8)
movupd %xmm1,0x30(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r9
jne    11f0 <vec_add+0xf0>
test   $0x1,%r8b
je     127e <vec_add+0x17e>
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
movupd (%rsi,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsi,%rcx,8)
movupd %xmm0,0x10(%rsi,%rcx,8)
cmp    %rdi,%rax
jne    112b <vec_add+0x2b>
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1255 <vec_add+0x155>
jmp    127e <vec_add+0x17e>

LLVM IR (-O0):
define void @vec_add(i64 %0, double* %1, double* %2) {
%4 = alloca i64
%5 = alloca double*
%6 = alloca double*
%7 = alloca i64
store i64 %0, i64* %4
store double* %1, double** %5
store double* %2, double** %6
store i64 0, i64* %7
br label %8
8: ; preds = %22, %3
%9 = load i64, i64* %7
%10 = load i64, i64* %4
%11 = icmp ult i64 %9, %10
br i1 %11, label %12, label %25
12: ; preds = %8
%13 = load double*, double** %6
%14 = load i64, i64* %7
%15 = getelementptr inbounds double, double* %13, i64 %14
%16 = load double, double* %15
%17 = load double*, double** %5
%18 = load i64, i64* %7
%19 = getelementptr inbounds double, double* %17, i64 %18
%20 = load double, double* %19
%21 = fadd double %20, %16
store double %21, double* %19
br label %22
22: ; preds = %12
%23 = load i64, i64* %7
%24 = add i64 %23, 1
store i64 %24, i64* %7
br label %8
25: ; preds = %8
ret void
}

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