#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 */
struct timespec {
  double tv_nsec;
  scalar_t__ tv_sec;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_REALTIME;
unsigned int atoi(char *);
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(unsigned int);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char **argv) {
  int i;
  struct timespec cgt1, cgt2;
  double ncgt;
  if (argc < 2) {
    printf("Faltan no componentes del vector\n");
    exit(-1);
  }
  unsigned int N = atoi(argv[1]);
  double *v1, *v2, *v3;
  v1 = (double *)malloc(N * sizeof(double));
  v2 = (double *)malloc(N * sizeof(double));
  v3 = (double *)malloc(N * sizeof(double));
  for (i = 0; i < N; i++) {
    v1[i] = N * 0.1 + i * 0.1;
    v2[i] = N * 0.1 - i * 0.1;
  }
  clock_gettime(CLOCK_REALTIME, &cgt1);
  for (i = 0; i < N; i++)
    v3[i] = v1[i] + v2[i];
  clock_gettime(CLOCK_REALTIME, &cgt2);
  ncgt = (double)(cgt2.tv_sec - cgt1.tv_sec) +
         (double)((cgt2.tv_nsec - cgt1.tv_nsec) / (1.e+9));
  printf("Tiempo(seg.):%11.9f\t / Tamaño Vectores:%u\n", ncgt, N);
  free(v1);
  free(v2);
  free(v3);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    1198 <main+0x38>
lea    0xe89(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    127b <main+0x11b>
mov    -0x44(%rbp),%eax
cvtsi2sd %rax,%xmm0
movslq -0x14(%rbp),%rcx
mov    %ecx,%eax
cvtsi2sd %eax,%xmm1
movsd  0xdfd(%rip),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
cvtsi2sd %rax,%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  0xdd3(%rip),%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xdb0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11e5 <main+0x85>
mov    0x2d5e(%rip),%rax
mov    (%rax),%edi
lea    -0x28(%rbp),%rsi
call   1040 <clock_gettime@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    12d5 <main+0x175>
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1294 <main+0x134>
mov    0x2d04(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1040 <clock_gettime@plt>
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
cvtsi2sd %rax,%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
movsd  0xcfa(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x44(%rbp),%esi
lea    0xd10(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
cmp    $0x1,%edi
jle    15ba <main+0x44a>
mov    0x8(%rsi),%rdi
call   1080 <atoi@plt>
mov    %eax,%r14d
lea    0x0(,%r14,8),%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
test   %r14d,%r14d
je     129f <main+0x12f>
mov    %r14d,%ebp
cvtsi2sd %rbp,%xmm5
cmp    $0x4,%r14d
jb     11e8 <main+0x78>
lea    (%rbx,%rbp,8),%rax
cmp    %rax,%r15
jae    12b5 <main+0x145>
lea    (%r15,%rbp,8),%rax
cmp    %rax,%rbx
jae    12b5 <main+0x145>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1228 <main+0xb8>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xe3b(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm1
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r15,%rax,8)
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
je     1368 <main+0x1f8>
movsd  0xe07(%rip),%xmm1
mulsd  %xmm1,%xmm5
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r15,%rax,8)
movapd %xmm5,%xmm2
subsd  %xmm0,%xmm2
lea    0x1(%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm2,(%rbx,%rax,8)
mulsd  %xmm1,%xmm0
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
movapd %xmm5,%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rbp,%rax
jne    1240 <main+0xd0>
jmp    1368 <main+0x1f8>
mov    0x2d3a(%rip),%rax
mov    (%rax),%edi
mov    %rsp,%rsi
call   1050 <clock_gettime@plt>
jmp    1536 <main+0x3c6>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
lea    0x0(,%rbp,8),%rcx
and    $0xffffffffffffffe0,%rcx
movdqa 0xd2a(%rip),%xmm2
xor    %edx,%edx
movdqa 0xd2f(%rip),%xmm8
movapd 0xd37(%rip),%xmm4
mulpd  %xmm4,%xmm3
movdqa 0xd3a(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm2,%xmm6
cvtdq2pd %xmm2,%xmm7
paddd  %xmm8,%xmm6
cvtdq2pd %xmm6,%xmm6
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm6
movapd %xmm3,%xmm1
addpd  %xmm7,%xmm1
movapd %xmm3,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm1,(%r15,%rdx,1)
movupd %xmm0,0x10(%r15,%rdx,1)
movapd %xmm3,%xmm0
subpd  %xmm7,%xmm0
movapd %xmm3,%xmm1
subpd  %xmm6,%xmm1
movupd %xmm0,(%rbx,%rdx,1)
movupd %xmm1,0x10(%rbx,%rdx,1)
paddd  %xmm9,%xmm2
add    $0x20,%rdx
cmp    %rdx,%rcx
jne    1300 <main+0x190>
cmp    %rbp,%rax
jne    11ea <main+0x7a>
mov    0x2c71(%rip),%rax
mov    (%rax),%edi
mov    %rsp,%rsi
call   1050 <clock_gettime@plt>
test   %r14d,%r14d
je     1536 <main+0x3c6>
cmp    $0x4,%r14d
jae    138f <main+0x21f>
xor    %eax,%eax
jmp    1492 <main+0x322>
lea    (%r12,%rbp,8),%rax
lea    (%r15,%rbp,8),%rcx
lea    (%rbx,%rbp,8),%rdx
cmp    %rcx,%r12
setb   %sil
cmp    %rax,%r15
setb   %dil
cmp    %rdx,%r12
setb   %cl
cmp    %rax,%rbx
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    1492 <main+0x322>
and    %dl,%cl
jne    1492 <main+0x322>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15aa <main+0x43a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm0,0x10(%r12,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
movupd 0x30(%r15,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r12,%rcx,8)
movupd %xmm0,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13f0 <main+0x280>
test   $0x1,%dl
je     1489 <main+0x319>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm0,0x10(%r12,%rcx,8)
cmp    %rbp,%rax
je     1536 <main+0x3c6>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     14cb <main+0x35b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    14b0 <main+0x340>
cmp    $0x3,%rcx
jb     1536 <main+0x3c6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
addsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r12,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
addsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    14e0 <main+0x370>
mov    0x2aa3(%rip),%rax
mov    (%rax),%edi
lea    0x10(%rsp),%rsi
call   1050 <clock_gettime@plt>
mov    0x18(%rsp),%rax
sub    0x8(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
movsd  0x10(%rsp),%xmm0
subsd  (%rsp),%xmm0
divsd  0xada(%rip),%xmm0
addsd  %xmm1,%xmm0
lea    0xad7(%rip),%rdi
mov    %r14d,%esi
mov    $0x1,%al
call   1060 <printf@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    145c <main+0x2ec>
jmp    1489 <main+0x319>
lea    0xabb(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
%struct.timespec = type { double, i64 }
@.str = [34 x i8] c"Faltan no componentes del vector\0A\00"
@CLOCK_REALTIME = global i32 0
@.str.1 = [44 x i8] c"Tiempo(seg.):%11.9f\09 / Tama\C3\B1o Vectores:%u\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca %struct.timespec
%8 = alloca %struct.timespec
%9 = alloca double
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%14 = load i32, i32* %4
%15 = icmp slt i32 %14, 2
br i1 %15, label %16, label %19
16: ; preds = %2
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
%18 = call i32 @exit(i32 -1)
unreachable
19: ; preds = %2
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 1
%22 = load i8*, i8** %21
%23 = call i32 @atoi(i8* %22)
store i32 %23, i32* %10
%24 = load i32, i32* %10
%25 = zext i32 %24 to i64
%26 = mul i64 %25, 8
%27 = trunc i64 %26 to i32
%28 = call i64 @malloc(i32 %27)
%29 = inttoptr i64 %28 to double*
store double* %29, double** %11
%30 = load i32, i32* %10
%31 = zext i32 %30 to i64
%32 = mul i64 %31, 8
%33 = trunc i64 %32 to i32
%34 = call i64 @malloc(i32 %33)
%35 = inttoptr i64 %34 to double*
store double* %35, double** %12
%36 = load i32, i32* %10
%37 = zext i32 %36 to i64
%38 = mul i64 %37, 8
%39 = trunc i64 %38 to i32
%40 = call i64 @malloc(i32 %39)
%41 = inttoptr i64 %40 to double*
store double* %41, double** %13
store i32 0, i32* %6
br label %42
42: ; preds = %68, %19
%43 = load i32, i32* %6
%44 = load i32, i32* %10
%45 = icmp ult i32 %43, %44
br i1 %45, label %46, label %71
46: ; preds = %42
%47 = load i32, i32* %10
%48 = uitofp i32 %47 to double
%49 = load i32, i32* %6
%50 = sitofp i32 %49 to double
%51 = fmul double %50, 1.000000e-01
%52 = call double @llvm.fmuladd.f64(double %48, double 1.000000e-01, double %51)
%53 = load double*, double** %11
%54 = load i32, i32* %6
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
store double %52, double* %56
%57 = load i32, i32* %10
%58 = uitofp i32 %57 to double
%59 = load i32, i32* %6
%60 = sitofp i32 %59 to double
%61 = fmul double %60, 1.000000e-01
%62 = fneg double %61
%63 = call double @llvm.fmuladd.f64(double %58, double 1.000000e-01, double %62)
%64 = load double*, double** %12
%65 = load i32, i32* %6
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
store double %63, double* %67
br label %68
68: ; preds = %46
%69 = load i32, i32* %6
%70 = add nsw i32 %69, 1
store i32 %70, i32* %6
br label %42
71: ; preds = %42
%72 = load i32, i32* @CLOCK_REALTIME
%73 = call i32 @clock_gettime(i32 %72, %struct.timespec* %7)
store i32 0, i32* %6
br label %74
74: ; preds = %94, %71
%75 = load i32, i32* %6
%76 = load i32, i32* %10
%77 = icmp ult i32 %75, %76
br i1 %77, label %78, label %97
78: ; preds = %74
%79 = load double*, double** %11
%80 = load i32, i32* %6
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
%83 = load double, double* %82
%84 = load double*, double** %12
%85 = load i32, i32* %6
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %84, i64 %86
%88 = load double, double* %87
%89 = fadd double %83, %88
%90 = load double*, double** %13
%91 = load i32, i32* %6
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
store double %89, double* %93
br label %94
94: ; preds = %78
%95 = load i32, i32* %6
%96 = add nsw i32 %95, 1
store i32 %96, i32* %6
br label %74
97: ; preds = %74
%98 = load i32, i32* @CLOCK_REALTIME
%99 = call i32 @clock_gettime(i32 %98, %struct.timespec* %8)
%100 = getelementptr inbounds %struct.timespec, %struct.timespec* %8, i32 0, i32 1
%101 = load i64, i64* %100
%102 = getelementptr inbounds %struct.timespec, %struct.timespec* %7, i32 0, i32 1
%103 = load i64, i64* %102
%104 = sub nsw i64 %101, %103
%105 = sitofp i64 %104 to double
%106 = getelementptr inbounds %struct.timespec, %struct.timespec* %8, i32 0, i32 0
%107 = load double, double* %106
%108 = getelementptr inbounds %struct.timespec, %struct.timespec* %7, i32 0, i32 0
%109 = load double, double* %108
%110 = fsub double %107, %109
%111 = fdiv double %110, 1.000000e+09
%112 = fadd double %105, %111
store double %112, double* %9
%113 = load double, double* %9
%114 = load i32, i32* %10
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), double %113, i32 %114)
%116 = load double*, double** %11
%117 = call i32 @free(double* %116)
%118 = load double*, double** %12
%119 = call i32 @free(double* %118)
%120 = load double*, double** %13
%121 = call i32 @free(double* %120)
ret i32 0
}

LLVM IR (-O2):
%struct.timespec = type { double, i64 }
@CLOCK_REALTIME = global i32 0
@.str.1 = [44 x i8] c"Tiempo(seg.):%11.9f\09 / Tama\C3\B1o Vectores:%u\0A\00"
@str = [33 x i8] c"Faltan no componentes del vector\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.timespec
%4 = alloca %struct.timespec
%5 = bitcast %struct.timespec* %3 to i8*
%6 = bitcast %struct.timespec* %4 to i8*
%7 = icmp slt i32 %0, 2
br i1 %7, label %8, label %11
8: ; preds = %2
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%10 = tail call i32 @exit(i32 -1)
unreachable
11: ; preds = %2
%12 = getelementptr inbounds i8*, i8** %1, i64 1
%13 = load i8*, i8** %12
%14 = tail call i32 @atoi(i8* %13)
%15 = shl i32 %14, 3
%16 = tail call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to double*
%18 = inttoptr i64 %16 to i8*
%19 = tail call i64 @malloc(i32 %15)
%20 = inttoptr i64 %19 to double*
%21 = inttoptr i64 %19 to i8*
%22 = tail call i64 @malloc(i32 %15)
%23 = inttoptr i64 %22 to double*
%24 = inttoptr i64 %22 to i8*
%25 = icmp eq i32 %14, 0
br i1 %25, label %26, label %29
26: ; preds = %11
%27 = load i32, i32* @CLOCK_REALTIME
%28 = call i32 @clock_gettime(i32 %27, %struct.timespec* %3)
br label %262
29: ; preds = %11
%30 = uitofp i32 %14 to double
%31 = zext i32 %14 to i64
%32 = icmp ult i32 %14, 4
br i1 %32, label %74, label %33
33: ; preds = %29
%34 = getelementptr double, double* %17, i64 %31
%35 = bitcast double* %34 to i8*
%36 = getelementptr double, double* %20, i64 %31
%37 = bitcast double* %36 to i8*
%38 = icmp ult i8* %18, %37
%39 = icmp ult i8* %21, %35
%40 = and i1 %38, %39
br i1 %40, label %74, label %41
41: ; preds = %33
%42 = and i64 %31, 4294967292
%43 = insertelement <2 x double> poison, double %30, i64 0
%44 = shufflevector <2 x double> %43, <2 x double> poison, <2 x i32> zeroinitializer
%45 = insertelement <2 x double> poison, double %30, i64 0
%46 = shufflevector <2 x double> %45, <2 x double> poison, <2 x i32> zeroinitializer
br label %47
47: ; preds = %47, %41
%48 = phi i64 [ 0, %41 ], [ %69, %47 ]
%49 = phi <2 x i32> [ <i32 0, i32 1>, %41 ], [ %70, %47 ]
%50 = add <2 x i32> %49, <i32 2, i32 2>
%51 = sitofp <2 x i32> %49 to <2 x double>
%52 = sitofp <2 x i32> %50 to <2 x double>
%53 = fmul <2 x double> %51, <double 1.000000e-01, double 1.000000e-01>
%54 = fmul <2 x double> %52, <double 1.000000e-01, double 1.000000e-01>
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %53)
%56 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %54)
%57 = getelementptr inbounds double, double* %17, i64 %48
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> %55, <2 x double>* %58
%59 = getelementptr inbounds double, double* %57, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %56, <2 x double>* %60
%61 = fneg <2 x double> %53
%62 = fneg <2 x double> %54
%63 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %61)
%64 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %62)
%65 = getelementptr inbounds double, double* %20, i64 %48
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %63, <2 x double>* %66
%67 = getelementptr inbounds double, double* %65, i64 2
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> %64, <2 x double>* %68
%69 = add nuw i64 %48, 4
%70 = add <2 x i32> %49, <i32 4, i32 4>
%71 = icmp eq i64 %69, %42
br i1 %71, label %72, label %47
72: ; preds = %47
%73 = icmp eq i64 %42, %31
br i1 %73, label %114, label %74
74: ; preds = %33, %29, %72
%75 = phi i64 [ 0, %33 ], [ 0, %29 ], [ %42, %72 ]
%76 = xor i64 %75, -1
%77 = and i64 %31, 1
%78 = icmp eq i64 %77, 0
br i1 %78, label %89, label %79
79: ; preds = %74
%80 = trunc i64 %75 to i32
%81 = sitofp i32 %80 to double
%82 = fmul double %81, 1.000000e-01
%83 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %82)
%84 = getelementptr inbounds double, double* %17, i64 %75
store double %83, double* %84
%85 = fneg double %82
%86 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %85)
%87 = getelementptr inbounds double, double* %20, i64 %75
store double %86, double* %87
%88 = or i64 %75, 1
br label %89
89: ; preds = %79, %74
%90 = phi i64 [ %75, %74 ], [ %88, %79 ]
%91 = sub nsw i64 0, %31
%92 = icmp eq i64 %76, %91
br i1 %92, label %114, label %93
93: ; preds = %89, %93
%94 = phi i64 [ %112, %93 ], [ %90, %89 ]
%95 = trunc i64 %94 to i32
%96 = sitofp i32 %95 to double
%97 = fmul double %96, 1.000000e-01
%98 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %97)
%99 = getelementptr inbounds double, double* %17, i64 %94
store double %98, double* %99
%100 = fneg double %97
%101 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %100)
%102 = getelementptr inbounds double, double* %20, i64 %94
store double %101, double* %102
%103 = add nuw nsw i64 %94, 1
%104 = trunc i64 %103 to i32
%105 = sitofp i32 %104 to double
%106 = fmul double %105, 1.000000e-01
%107 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %106)
%108 = getelementptr inbounds double, double* %17, i64 %103
store double %107, double* %108
%109 = fneg double %106
%110 = tail call double @llvm.fmuladd.f64(double %30, double 1.000000e-01, double %109)
%111 = getelementptr inbounds double, double* %20, i64 %103
store double %110, double* %111
%112 = add nuw nsw i64 %94, 2
%113 = icmp eq i64 %112, %31
br i1 %113, label %114, label %93
114: ; preds = %89, %93, %72
%115 = load i32, i32* @CLOCK_REALTIME
%116 = call i32 @clock_gettime(i32 %115, %struct.timespec* %3)
br i1 %25, label %262, label %117
117: ; preds = %114
%118 = zext i32 %14 to i64
%119 = icmp ult i32 %14, 4
br i1 %119, label %210, label %120
120: ; preds = %117
%121 = getelementptr double, double* %23, i64 %31
%122 = bitcast double* %121 to i8*
%123 = getelementptr double, double* %17, i64 %31
%124 = bitcast double* %123 to i8*
%125 = getelementptr double, double* %20, i64 %31
%126 = bitcast double* %125 to i8*
%127 = icmp ult i8* %24, %124
%128 = icmp ult i8* %18, %122
%129 = and i1 %127, %128
%130 = icmp ult i8* %24, %126
%131 = icmp ult i8* %21, %122
%132 = and i1 %130, %131
%133 = or i1 %129, %132
br i1 %133, label %210, label %134
134: ; preds = %120
%135 = and i64 %31, 4294967292
%136 = add nsw i64 %135, -4
%137 = lshr exact i64 %136, 2
%138 = add nuw nsw i64 %137, 1
%139 = and i64 %138, 1
%140 = icmp eq i64 %136, 0
br i1 %140, label %186, label %141
141: ; preds = %134
%142 = and i64 %138, 9223372036854775806
br label %143
143: ; preds = %143, %141
%144 = phi i64 [ 0, %141 ], [ %183, %143 ]
%145 = phi i64 [ 0, %141 ], [ %184, %143 ]
%146 = getelementptr inbounds double, double* %17, i64 %144
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = getelementptr inbounds double, double* %146, i64 2
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = getelementptr inbounds double, double* %20, i64 %144
%153 = bitcast double* %152 to <2 x double>*
%154 = load <2 x double>, <2 x double>* %153
%155 = getelementptr inbounds double, double* %152, i64 2
%156 = bitcast double* %155 to <2 x double>*
%157 = load <2 x double>, <2 x double>* %156
%158 = fadd <2 x double> %148, %154
%159 = fadd <2 x double> %151, %157
%160 = getelementptr inbounds double, double* %23, i64 %144
%161 = bitcast double* %160 to <2 x double>*
store <2 x double> %158, <2 x double>* %161
%162 = getelementptr inbounds double, double* %160, i64 2
%163 = bitcast double* %162 to <2 x double>*
store <2 x double> %159, <2 x double>* %163
%164 = or i64 %144, 4
%165 = getelementptr inbounds double, double* %17, i64 %164
%166 = bitcast double* %165 to <2 x double>*
%167 = load <2 x double>, <2 x double>* %166
%168 = getelementptr inbounds double, double* %165, i64 2
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds double, double* %20, i64 %164
%172 = bitcast double* %171 to <2 x double>*
%173 = load <2 x double>, <2 x double>* %172
%174 = getelementptr inbounds double, double* %171, i64 2
%175 = bitcast double* %174 to <2 x double>*
%176 = load <2 x double>, <2 x double>* %175
%177 = fadd <2 x double> %167, %173
%178 = fadd <2 x double> %170, %176
%179 = getelementptr inbounds double, double* %23, i64 %164
%180 = bitcast double* %179 to <2 x double>*
store <2 x double> %177, <2 x double>* %180
%181 = getelementptr inbounds double, double* %179, i64 2
%182 = bitcast double* %181 to <2 x double>*
store <2 x double> %178, <2 x double>* %182
%183 = add nuw i64 %144, 8
%184 = add i64 %145, 2
%185 = icmp eq i64 %184, %142
br i1 %185, label %186, label %143
186: ; preds = %143, %134
%187 = phi i64 [ 0, %134 ], [ %183, %143 ]
%188 = icmp eq i64 %139, 0
br i1 %188, label %208, label %189
189: ; preds = %186
%190 = getelementptr inbounds double, double* %17, i64 %187
%191 = bitcast double* %190 to <2 x double>*
%192 = load <2 x double>, <2 x double>* %191
%193 = getelementptr inbounds double, double* %190, i64 2
%194 = bitcast double* %193 to <2 x double>*
%195 = load <2 x double>, <2 x double>* %194
%196 = getelementptr inbounds double, double* %20, i64 %187
%197 = bitcast double* %196 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = getelementptr inbounds double, double* %196, i64 2
%200 = bitcast double* %199 to <2 x double>*
%201 = load <2 x double>, <2 x double>* %200
%202 = fadd <2 x double> %192, %198
%203 = fadd <2 x double> %195, %201
%204 = getelementptr inbounds double, double* %23, i64 %187
%205 = bitcast double* %204 to <2 x double>*
store <2 x double> %202, <2 x double>* %205
%206 = getelementptr inbounds double, double* %204, i64 2
%207 = bitcast double* %206 to <2 x double>*
store <2 x double> %203, <2 x double>* %207
br label %208
208: ; preds = %186, %189
%209 = icmp eq i64 %135, %31
br i1 %209, label %262, label %210
210: ; preds = %120, %117, %208
%211 = phi i64 [ 0, %120 ], [ 0, %117 ], [ %135, %208 ]
%212 = xor i64 %211, -1
%213 = add nsw i64 %212, %31
%214 = and i64 %31, 3
%215 = icmp eq i64 %214, 0
br i1 %215, label %228, label %216
216: ; preds = %210, %216
%217 = phi i64 [ %225, %216 ], [ %211, %210 ]
%218 = phi i64 [ %226, %216 ], [ 0, %210 ]
%219 = getelementptr inbounds double, double* %17, i64 %217
%220 = load double, double* %219
%221 = getelementptr inbounds double, double* %20, i64 %217
%222 = load double, double* %221
%223 = fadd double %220, %222
%224 = getelementptr inbounds double, double* %23, i64 %217
store double %223, double* %224
%225 = add nuw nsw i64 %217, 1
%226 = add i64 %218, 1
%227 = icmp eq i64 %226, %214
br i1 %227, label %228, label %216
228: ; preds = %216, %210
%229 = phi i64 [ %211, %210 ], [ %225, %216 ]
%230 = icmp ult i64 %213, 3
br i1 %230, label %262, label %231
231: ; preds = %228, %231
%232 = phi i64 [ %260, %231 ], [ %229, %228 ]
%233 = getelementptr inbounds double, double* %17, i64 %232
%234 = load double, double* %233
%235 = getelementptr inbounds double, double* %20, i64 %232
%236 = load double, double* %235
%237 = fadd double %234, %236
%238 = getelementptr inbounds double, double* %23, i64 %232
store double %237, double* %238
%239 = add nuw nsw i64 %232, 1
%240 = getelementptr inbounds double, double* %17, i64 %239
%241 = load double, double* %240
%242 = getelementptr inbounds double, double* %20, i64 %239
%243 = load double, double* %242
%244 = fadd double %241, %243
%245 = getelementptr inbounds double, double* %23, i64 %239
store double %244, double* %245
%246 = add nuw nsw i64 %232, 2
%247 = getelementptr inbounds double, double* %17, i64 %246
%248 = load double, double* %247
%249 = getelementptr inbounds double, double* %20, i64 %246
%250 = load double, double* %249
%251 = fadd double %248, %250
%252 = getelementptr inbounds double, double* %23, i64 %246
store double %251, double* %252
%253 = add nuw nsw i64 %232, 3
%254 = getelementptr inbounds double, double* %17, i64 %253
%255 = load double, double* %254
%256 = getelementptr inbounds double, double* %20, i64 %253
%257 = load double, double* %256
%258 = fadd double %255, %257
%259 = getelementptr inbounds double, double* %23, i64 %253
store double %258, double* %259
%260 = add nuw nsw i64 %232, 4
%261 = icmp eq i64 %260, %118
br i1 %261, label %262, label %231
262: ; preds = %228, %231, %208, %26, %114
%263 = load i32, i32* @CLOCK_REALTIME
%264 = call i32 @clock_gettime(i32 %263, %struct.timespec* %4)
%265 = getelementptr inbounds %struct.timespec, %struct.timespec* %4, i64 0, i32 1
%266 = load i64, i64* %265
%267 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 1
%268 = load i64, i64* %267
%269 = sub nsw i64 %266, %268
%270 = sitofp i64 %269 to double
%271 = getelementptr inbounds %struct.timespec, %struct.timespec* %4, i64 0, i32 0
%272 = load double, double* %271
%273 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%274 = load double, double* %273
%275 = fsub double %272, %274
%276 = fdiv double %275, 1.000000e+09
%277 = fadd double %276, %270
%278 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), double %277, i32 %14)
%279 = call i32 @free(double* %17)
%280 = call i32 @free(double* %20)
%281 = call i32 @free(double* %23)
ret i32 0
}