#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 nº 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));
  if ((v1 == NULL) || (v2 == NULL) || (v3 == NULL)) {
    printf("Error en la reserva de espacio para los vectores\n");
    exit(-2);
  }
  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\t/ "
         "V1[0]+V2[0]=V3[0](%8.6f+%8.6f=%8.6f)//"
         "V1[%d]+V2[%d]=V3[%d](%8.6f+%8.6f=%8.6f) /\n",
         ncgt, N, v1[0], v2[0], v3[0], N - 1, N - 1, N - 1, v1[N - 1],
         v2[N - 1], v3[N - 1]);
  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)
cmpq   $0x0,-0x50(%rbp)
je     11ff <main+0x9f>
cmpq   $0x0,-0x58(%rbp)
je     11ff <main+0x9f>
cmpq   $0x0,-0x60(%rbp)
jne    1217 <main+0xb7>
lea    0xe2d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0xfffffffe,%edi
call   1080 <exit@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    12b4 <main+0x154>
mov    -0x44(%rbp),%eax
cvtsi2sd %rax,%xmm0
movslq -0x14(%rbp),%rcx
mov    %ecx,%eax
cvtsi2sd %eax,%xmm1
movsd  0xdc4(%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  0xd9a(%rip),%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xd77(%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    121e <main+0xbe>
mov    0x2d25(%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    130e <main+0x1ae>
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    12cd <main+0x16d>
mov    0x2ccb(%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  0xcc1(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x44(%rbp),%esi
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm3
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%edi
sub    $0x1,%edi
mov    %edi,%edi
movsd  (%rax,%rdi,8),%xmm4
mov    -0x58(%rbp),%rax
mov    -0x44(%rbp),%edi
sub    $0x1,%edi
mov    %edi,%edi
movsd  (%rax,%rdi,8),%xmm5
mov    -0x60(%rbp),%rax
mov    -0x44(%rbp),%edi
sub    $0x1,%edi
mov    %edi,%edi
movsd  (%rax,%rdi,8),%xmm6
lea    0xcab(%rip),%rdi
mov    $0x7,%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    1604 <main+0x494>
mov    0x8(%rsi),%rdi
call   1080 <atoi@plt>
mov    %eax,%r12d
lea    0x0(,%r12,8),%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1070 <malloc@plt>
test   %r14,%r14
je     161a <main+0x4aa>
test   %rbx,%rbx
je     161a <main+0x4aa>
mov    %rax,%r15
test   %rax,%rax
je     161a <main+0x4aa>
test   %r12d,%r12d
je     12bf <main+0x14f>
mov    %r12d,%ebp
cvtsi2sd %rbp,%xmm5
cmp    $0x4,%r12d
jb     1203 <main+0x93>
lea    (%rbx,%rbp,8),%rax
cmp    %rax,%r14
jae    12d5 <main+0x165>
lea    (%r14,%rbp,8),%rax
cmp    %rax,%rbx
jae    12d5 <main+0x165>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1243 <main+0xd3>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xe20(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm1
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%rax,8)
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
je     1388 <main+0x218>
movsd  0xdec(%rip),%xmm1
mulsd  %xmm1,%xmm5
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%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(%r14,%rax,8)
movapd %xmm5,%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rbp,%rax
jne    1260 <main+0xf0>
jmp    1388 <main+0x218>
mov    0x2d1a(%rip),%rax
mov    (%rax),%edi
mov    %rsp,%rsi
call   1050 <clock_gettime@plt>
jmp    1556 <main+0x3e6>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
lea    0x0(,%rbp,8),%rcx
and    $0xffffffffffffffe0,%rcx
movdqa 0xd0a(%rip),%xmm2
xor    %edx,%edx
movdqa 0xd0f(%rip),%xmm8
movapd 0xd17(%rip),%xmm4
mulpd  %xmm4,%xmm3
movdqa 0xd1a(%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,(%r14,%rdx,1)
movupd %xmm0,0x10(%r14,%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    1320 <main+0x1b0>
cmp    %rbp,%rax
jne    1205 <main+0x95>
mov    0x2c51(%rip),%rax
mov    (%rax),%edi
mov    %rsp,%rsi
call   1050 <clock_gettime@plt>
test   %r12d,%r12d
je     1556 <main+0x3e6>
cmp    $0x4,%r12d
jae    13af <main+0x23f>
xor    %eax,%eax
jmp    14b2 <main+0x342>
lea    (%r15,%rbp,8),%rax
lea    (%r14,%rbp,8),%rcx
lea    (%rbx,%rbp,8),%rdx
cmp    %rcx,%r15
setb   %sil
cmp    %rax,%r14
setb   %dil
cmp    %rdx,%r15
setb   %cl
cmp    %rax,%rbx
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    14b2 <main+0x342>
and    %dl,%cl
jne    14b2 <main+0x342>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15f4 <main+0x484>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%rcx,8)
movupd %xmm0,0x10(%r15,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm0
movupd 0x30(%r14,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r15,%rcx,8)
movupd %xmm0,0x30(%r15,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1410 <main+0x2a0>
test   $0x1,%dl
je     14a9 <main+0x339>
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%rcx,8)
movupd %xmm0,0x10(%r15,%rcx,8)
cmp    %rbp,%rax
je     1556 <main+0x3e6>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     14eb <main+0x37b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    14d0 <main+0x360>
cmp    $0x3,%rcx
jb     1556 <main+0x3e6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
addsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
addsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1500 <main+0x390>
mov    0x2a83(%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  0xaba(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14),%xmm1
movsd  (%rbx),%xmm2
movsd  (%r15),%xmm3
mov    %r12d,%ecx
add    $0xffffffff,%ecx
movsd  (%r14,%rcx,8),%xmm4
movsd  (%rbx,%rcx,8),%xmm5
movsd  (%r15,%rcx,8),%xmm6
lea    0xa92(%rip),%rdi
mov    %r12d,%esi
mov    %ecx,%edx
mov    %ecx,%r8d
mov    $0x7,%al
call   1060 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%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    147c <main+0x30c>
jmp    14a9 <main+0x339>
lea    0xaf4(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
lea    0xaad(%rip),%rdi
call   1040 <puts@plt>
mov    $0xfffffffe,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
%struct.timespec = type { double, i64 }
@.str = [35 x i8] c"Faltan n\C2\BA componentes del vector\0A\00"
@.str.1 = [50 x i8] c"Error en la reserva de espacio para los vectores\0A\00"
@CLOCK_REALTIME = global i32 0
@.str.2 = [126 x i8] c"Tiempo(seg.):%11.9f\09 / Tama\C3\B1o Vectores:%u\09/ V1[0]+V2[0]=V3[0](%8.6f+%8.6f=%8.6f)//V1[%d]+V2[%d]=V3[%d](%8.6f+%8.6f=%8.6f) /\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 ([35 x i8], [35 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
%42 = load double*, double** %11
%43 = icmp eq double* %42, null
br i1 %43, label %50, label %44
44: ; preds = %19
%45 = load double*, double** %12
%46 = icmp eq double* %45, null
br i1 %46, label %50, label %47
47: ; preds = %44
%48 = load double*, double** %13
%49 = icmp eq double* %48, null
br i1 %49, label %50, label %53
50: ; preds = %47, %44, %19
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.1, i64 0, i64 0))
%52 = call i32 @exit(i32 -2)
unreachable
53: ; preds = %47
store i32 0, i32* %6
br label %54
54: ; preds = %80, %53
%55 = load i32, i32* %6
%56 = load i32, i32* %10
%57 = icmp ult i32 %55, %56
br i1 %57, label %58, label %83
58: ; preds = %54
%59 = load i32, i32* %10
%60 = uitofp i32 %59 to double
%61 = load i32, i32* %6
%62 = sitofp i32 %61 to double
%63 = fmul double %62, 1.000000e-01
%64 = call double @llvm.fmuladd.f64(double %60, double 1.000000e-01, double %63)
%65 = load double*, double** %11
%66 = load i32, i32* %6
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %65, i64 %67
store double %64, double* %68
%69 = load i32, i32* %10
%70 = uitofp i32 %69 to double
%71 = load i32, i32* %6
%72 = sitofp i32 %71 to double
%73 = fmul double %72, 1.000000e-01
%74 = fneg double %73
%75 = call double @llvm.fmuladd.f64(double %70, double 1.000000e-01, double %74)
%76 = load double*, double** %12
%77 = load i32, i32* %6
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
store double %75, double* %79
br label %80
80: ; preds = %58
%81 = load i32, i32* %6
%82 = add nsw i32 %81, 1
store i32 %82, i32* %6
br label %54
83: ; preds = %54
%84 = load i32, i32* @CLOCK_REALTIME
%85 = call i32 @clock_gettime(i32 %84, %struct.timespec* %7)
store i32 0, i32* %6
br label %86
86: ; preds = %106, %83
%87 = load i32, i32* %6
%88 = load i32, i32* %10
%89 = icmp ult i32 %87, %88
br i1 %89, label %90, label %109
90: ; preds = %86
%91 = load double*, double** %11
%92 = load i32, i32* %6
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %91, i64 %93
%95 = load double, double* %94
%96 = load double*, double** %12
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
%100 = load double, double* %99
%101 = fadd double %95, %100
%102 = load double*, double** %13
%103 = load i32, i32* %6
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
store double %101, double* %105
br label %106
106: ; preds = %90
%107 = load i32, i32* %6
%108 = add nsw i32 %107, 1
store i32 %108, i32* %6
br label %86
109: ; preds = %86
%110 = load i32, i32* @CLOCK_REALTIME
%111 = call i32 @clock_gettime(i32 %110, %struct.timespec* %8)
%112 = getelementptr inbounds %struct.timespec, %struct.timespec* %8, i32 0, i32 1
%113 = load i64, i64* %112
%114 = getelementptr inbounds %struct.timespec, %struct.timespec* %7, i32 0, i32 1
%115 = load i64, i64* %114
%116 = sub nsw i64 %113, %115
%117 = sitofp i64 %116 to double
%118 = getelementptr inbounds %struct.timespec, %struct.timespec* %8, i32 0, i32 0
%119 = load double, double* %118
%120 = getelementptr inbounds %struct.timespec, %struct.timespec* %7, i32 0, i32 0
%121 = load double, double* %120
%122 = fsub double %119, %121
%123 = fdiv double %122, 1.000000e+09
%124 = fadd double %117, %123
store double %124, double* %9
%125 = load double, double* %9
%126 = load i32, i32* %10
%127 = load double*, double** %11
%128 = getelementptr inbounds double, double* %127, i64 0
%129 = load double, double* %128
%130 = load double*, double** %12
%131 = getelementptr inbounds double, double* %130, i64 0
%132 = load double, double* %131
%133 = load double*, double** %13
%134 = getelementptr inbounds double, double* %133, i64 0
%135 = load double, double* %134
%136 = load i32, i32* %10
%137 = sub i32 %136, 1
%138 = load i32, i32* %10
%139 = sub i32 %138, 1
%140 = load i32, i32* %10
%141 = sub i32 %140, 1
%142 = load double*, double** %11
%143 = load i32, i32* %10
%144 = sub i32 %143, 1
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds double, double* %142, i64 %145
%147 = load double, double* %146
%148 = load double*, double** %12
%149 = load i32, i32* %10
%150 = sub i32 %149, 1
%151 = zext i32 %150 to i64
%152 = getelementptr inbounds double, double* %148, i64 %151
%153 = load double, double* %152
%154 = load double*, double** %13
%155 = load i32, i32* %10
%156 = sub i32 %155, 1
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
%159 = load double, double* %158
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([126 x i8], [126 x i8]* @.str.2, i64 0, i64 0), double %125, i32 %126, double %129, double %132, double %135, i32 %137, i32 %139, i32 %141, double %147, double %153, double %159)
%161 = load double*, double** %11
%162 = call i32 @free(double* %161)
%163 = load double*, double** %12
%164 = call i32 @free(double* %163)
%165 = load double*, double** %13
%166 = call i32 @free(double* %165)
ret i32 0
}

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