#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 tms {
  int dummy;
};
typedef float clock_t;

/* Variables and functions */
int /*<<< orphan*/ free(long *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, double);
int rand();
float times(struct tms *);
int main(int argc, char **argv) {
  int N = 100000000;
  long *array_dinamico = (long *)malloc(N * sizeof(long));
  double tiempo[100];
  double media = 0;
  int i, x, aleatorio;
  for (i = 0; i < N; i++) {
    array_dinamico[i] = i;
  }
  for (x = 0; x < 100; x++) {
    aleatorio = rand() % N;
    printf("El numero buscado es: %d\n", aleatorio);
    struct tms buf;
    clock_t t1 = times(&buf);
    for (i = 0; i < N; i++) {
      if (array_dinamico[i] == aleatorio) {
        break;
      }
    }
    clock_t t2 = times(&buf);
    tiempo[x] = (float)t2 - t1;
    printf("El tiempo usado para la busqueda ha sido: %f\n", tiempo[x]);
  }
  for (x = 0; x < 100; x++) {
    media += tiempo[x];
  }
  media = media / 100;
  printf("La media de tiempo de todas las busquedas es: %f\n", media);
  free(array_dinamico);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x360,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x5f5e100,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
movl   $0x0,-0x34c(%rbp)
mov    -0x34c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d1 <main+0x81>
movslq -0x34c(%rbp),%rdx
mov    -0x20(%rbp),%rax
movslq -0x34c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
jmp    1198 <main+0x48>
movl   $0x0,-0x350(%rbp)
cmpl   $0x64,-0x350(%rbp)
jge    12df <main+0x18f>
mov    $0x0,%al
call   1070 <rand@plt>
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x354(%rbp)
cvtsi2sdl -0x354(%rbp),%xmm0
lea    0xe00(%rip),%rdi
call   1040 <printf@plt>
lea    -0x358(%rbp),%rdi
call   1060 <times@plt>
movss  %xmm0,-0x35c(%rbp)
ff
movl   $0x0,-0x34c(%rbp)
mov    -0x34c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1277 <main+0x127>
mov    -0x20(%rbp),%rax
movslq -0x34c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x354(%rbp),%rcx
cmp    %rcx,%rax
jne    125e <main+0x10e>
jmp    1277 <main+0x127>
jmp    1263 <main+0x113>
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
jmp    122b <main+0xdb>
lea    -0x358(%rbp),%rdi
call   1060 <times@plt>
movss  %xmm0,-0x360(%rbp)
ff
movss  -0x360(%rbp),%xmm0
ff
subss  -0x35c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movslq -0x350(%rbp),%rax
movsd  %xmm0,-0x340(%rbp,%rax,8)
ff ff
movslq -0x350(%rbp),%rax
movsd  -0x340(%rbp,%rax,8),%xmm0
ff ff
lea    0xd5c(%rip),%rdi
call   1040 <printf@plt>
mov    -0x350(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x350(%rbp)
jmp    11db <main+0x8b>
movl   $0x0,-0x350(%rbp)
cmpl   $0x64,-0x350(%rbp)
jge    132a <main+0x1da>
movslq -0x350(%rbp),%rax
movsd  -0x340(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x348(%rbp),%xmm0
ff
movsd  %xmm0,-0x348(%rbp)
ff
mov    -0x350(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x350(%rbp)
jmp    12e9 <main+0x199>
movsd  -0x348(%rbp),%xmm0
ff
movsd  0xcc6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
movsd  -0x348(%rbp),%xmm0
ff
lea    0xcfb(%rip),%rdi
call   1040 <printf@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x360,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x330,%rsp
mov    $0x2faf0800,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
movdqa 0xe8b(%rip),%xmm0
mov    $0x12,%eax
movdqa 0xe8d(%rip),%xmm8
movdqa 0xe94(%rip),%xmm9
movdqa 0xe9b(%rip),%xmm10
movdqa 0xea2(%rip),%xmm11
movdqa 0xea9(%rip),%xmm12
movdqa 0xeb1(%rip),%xmm6
movdqa 0xeb9(%rip),%xmm7
movdqa 0xec1(%rip),%xmm1
movdqa 0xec9(%rip),%xmm2
movdqa 0xed1(%rip),%xmm3
nop
movdqa %xmm0,%xmm4
paddq  %xmm8,%xmm4
movdqu %xmm0,-0x90(%r13,%rax,8)
ff ff ff
movdqu %xmm4,-0x80(%r13,%rax,8)
movdqa %xmm0,%xmm4
paddq  %xmm9,%xmm4
movdqa %xmm0,%xmm5
paddq  %xmm10,%xmm5
movdqu %xmm4,-0x70(%r13,%rax,8)
movdqu %xmm5,-0x60(%r13,%rax,8)
movdqa %xmm0,%xmm4
paddq  %xmm11,%xmm4
movdqa %xmm0,%xmm5
paddq  %xmm12,%xmm5
movdqu %xmm4,-0x50(%r13,%rax,8)
movdqu %xmm5,-0x40(%r13,%rax,8)
movdqa %xmm0,%xmm4
paddq  %xmm6,%xmm4
movdqa %xmm0,%xmm5
paddq  %xmm7,%xmm5
movdqu %xmm4,-0x30(%r13,%rax,8)
movdqu %xmm5,-0x20(%r13,%rax,8)
movdqa %xmm0,%xmm4
paddq  %xmm1,%xmm4
movdqa %xmm0,%xmm5
paddq  %xmm2,%xmm5
movdqu %xmm4,-0x10(%r13,%rax,8)
movdqu %xmm5,0x0(%r13,%rax,8)
paddq  %xmm3,%xmm0
add    $0x14,%rax
cmp    $0x5f5e112,%rax
jne    11d0 <main+0x80>
lea    0xe37(%rip),%r14
lea    0x8(%rsp),%r15
lea    0xe45(%rip),%r12
xor    %ebx,%ebx
nop
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x55e63b89,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x39,%rcx
add    %edx,%ecx
imul   $0x5f5e100,%ecx,%ecx
sub    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    %r14,%rdi
call   1040 <printf@plt>
mov    %r15,%rdi
call   1060 <times@plt>
movss  %xmm0,0x4(%rsp)
mov    %r15,%rdi
call   1060 <times@plt>
subss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp,%rbx,8)
mov    %r12,%rdi
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x64,%rbx
jne    1290 <main+0x140>
pxor   %xmm0,%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  -0x10(%rsp,%rax,8),%xmm0
addsd  -0x8(%rsp,%rax,8),%xmm0
addsd  (%rsp,%rax,8),%xmm0
addsd  0x8(%rsp,%rax,8),%xmm0
addsd  0x10(%rsp,%rax,8),%xmm0
add    $0x5,%rax
cmp    $0x68,%rax
jne    1310 <main+0x1c0>
divsd  0xd71(%rip),%xmm0
lea    0xdba(%rip),%rdi
call   1040 <printf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x330,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
%struct.tms = type { i32 }
@.str = [26 x i8] c"El numero buscado es: %d\0A\00"
@.str.1 = [46 x i8] c"El tiempo usado para la busqueda ha sido: %f\0A\00"
@.str.2 = [50 x i8] c"La media de tiempo de todas las busquedas es: %f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i64*
%8 = alloca [100 x double]
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca %struct.tms
%14 = alloca float
%15 = alloca float
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 100000000, i32* %6
%16 = load i32, i32* %6
%17 = sext i32 %16 to i64
%18 = mul i64 %17, 8
%19 = trunc i64 %18 to i32
%20 = call i64 @malloc(i32 %19)
%21 = inttoptr i64 %20 to i64*
store i64* %21, i64** %7
store double 0.000000e+00, double* %9
store i32 0, i32* %10
br label %22
22: ; preds = %33, %2
%23 = load i32, i32* %10
%24 = load i32, i32* %6
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %36
26: ; preds = %22
%27 = load i32, i32* %10
%28 = sext i32 %27 to i64
%29 = load i64*, i64** %7
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i64, i64* %29, i64 %31
store i64 %28, i64* %32
br label %33
33: ; preds = %26
%34 = load i32, i32* %10
%35 = add nsw i32 %34, 1
store i32 %35, i32* %10
br label %22
36: ; preds = %22
store i32 0, i32* %11
br label %37
37: ; preds = %80, %36
%38 = load i32, i32* %11
%39 = icmp slt i32 %38, 100
br i1 %39, label %40, label %83
40: ; preds = %37
%41 = call i32 (...) @rand()
%42 = load i32, i32* %6
%43 = srem i32 %41, %42
store i32 %43, i32* %12
%44 = load i32, i32* %12
%45 = sitofp i32 %44 to double
%46 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), double %45)
%47 = call float @times(%struct.tms* %13)
store float %47, float* %14
store i32 0, i32* %10
br label %48
48: ; preds = %63, %40
%49 = load i32, i32* %10
%50 = load i32, i32* %6
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %66
52: ; preds = %48
%53 = load i64*, i64** %7
%54 = load i32, i32* %10
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i64, i64* %53, i64 %55
%57 = load i64, i64* %56
%58 = load i32, i32* %12
%59 = sext i32 %58 to i64
%60 = icmp eq i64 %57, %59
br i1 %60, label %61, label %62
61: ; preds = %52
br label %66
62: ; preds = %52
br label %63
63: ; preds = %62
%64 = load i32, i32* %10
%65 = add nsw i32 %64, 1
store i32 %65, i32* %10
br label %48
66: ; preds = %61, %48
%67 = call float @times(%struct.tms* %13)
store float %67, float* %15
%68 = load float, float* %15
%69 = load float, float* %14
%70 = fsub float %68, %69
%71 = fpext float %70 to double
%72 = load i32, i32* %11
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [100 x double], [100 x double]* %8, i64 0, i64 %73
store double %71, double* %74
%75 = load i32, i32* %11
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [100 x double], [100 x double]* %8, i64 0, i64 %76
%78 = load double, double* %77
%79 = call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), double %78)
br label %80
80: ; preds = %66
%81 = load i32, i32* %11
%82 = add nsw i32 %81, 1
store i32 %82, i32* %11
br label %37
83: ; preds = %37
store i32 0, i32* %11
br label %84
84: ; preds = %94, %83
%85 = load i32, i32* %11
%86 = icmp slt i32 %85, 100
br i1 %86, label %87, label %97
87: ; preds = %84
%88 = load i32, i32* %11
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [100 x double], [100 x double]* %8, i64 0, i64 %89
%91 = load double, double* %90
%92 = load double, double* %9
%93 = fadd double %92, %91
store double %93, double* %9
br label %94
94: ; preds = %87
%95 = load i32, i32* %11
%96 = add nsw i32 %95, 1
store i32 %96, i32* %11
br label %84
97: ; preds = %84
%98 = load double, double* %9
%99 = fdiv double %98, 1.000000e+02
store double %99, double* %9
%100 = load double, double* %9
%101 = call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0), double %100)
%102 = load i64*, i64** %7
%103 = call i32 @free(i64* %102)
ret i32 0
}

LLVM IR (-O2):
%struct.tms = type { i32 }
@.str = [26 x i8] c"El numero buscado es: %d\0A\00"
@.str.1 = [46 x i8] c"El tiempo usado para la busqueda ha sido: %f\0A\00"
@.str.2 = [50 x i8] c"La media de tiempo de todas las busquedas es: %f\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [100 x double]
%4 = alloca %struct.tms
%5 = tail call i64 @malloc(i32 800000000)
%6 = inttoptr i64 %5 to i64*
%7 = bitcast [100 x double]* %3 to i8*
br label %8
8: ; preds = %8, %2
%9 = phi i64 [ 0, %2 ], [ %44, %8 ]
%10 = phi <2 x i64> [ <i64 0, i64 1>, %2 ], [ %45, %8 ]
%11 = add <2 x i64> %10, <i64 2, i64 2>
%12 = getelementptr inbounds i64, i64* %6, i64 %9
%13 = bitcast i64* %12 to <2 x i64>*
store <2 x i64> %10, <2 x i64>* %13
%14 = getelementptr inbounds i64, i64* %12, i64 2
%15 = bitcast i64* %14 to <2 x i64>*
store <2 x i64> %11, <2 x i64>* %15
%16 = add nuw nsw i64 %9, 4
%17 = add <2 x i64> %10, <i64 4, i64 4>
%18 = add <2 x i64> %10, <i64 6, i64 6>
%19 = getelementptr inbounds i64, i64* %6, i64 %16
%20 = bitcast i64* %19 to <2 x i64>*
store <2 x i64> %17, <2 x i64>* %20
%21 = getelementptr inbounds i64, i64* %19, i64 2
%22 = bitcast i64* %21 to <2 x i64>*
store <2 x i64> %18, <2 x i64>* %22
%23 = add nuw nsw i64 %9, 8
%24 = add <2 x i64> %10, <i64 8, i64 8>
%25 = add <2 x i64> %10, <i64 10, i64 10>
%26 = getelementptr inbounds i64, i64* %6, i64 %23
%27 = bitcast i64* %26 to <2 x i64>*
store <2 x i64> %24, <2 x i64>* %27
%28 = getelementptr inbounds i64, i64* %26, i64 2
%29 = bitcast i64* %28 to <2 x i64>*
store <2 x i64> %25, <2 x i64>* %29
%30 = add nuw nsw i64 %9, 12
%31 = add <2 x i64> %10, <i64 12, i64 12>
%32 = add <2 x i64> %10, <i64 14, i64 14>
%33 = getelementptr inbounds i64, i64* %6, i64 %30
%34 = bitcast i64* %33 to <2 x i64>*
store <2 x i64> %31, <2 x i64>* %34
%35 = getelementptr inbounds i64, i64* %33, i64 2
%36 = bitcast i64* %35 to <2 x i64>*
store <2 x i64> %32, <2 x i64>* %36
%37 = add nuw nsw i64 %9, 16
%38 = add <2 x i64> %10, <i64 16, i64 16>
%39 = add <2 x i64> %10, <i64 18, i64 18>
%40 = getelementptr inbounds i64, i64* %6, i64 %37
%41 = bitcast i64* %40 to <2 x i64>*
store <2 x i64> %38, <2 x i64>* %41
%42 = getelementptr inbounds i64, i64* %40, i64 2
%43 = bitcast i64* %42 to <2 x i64>*
store <2 x i64> %39, <2 x i64>* %43
%44 = add nuw nsw i64 %9, 20
%45 = add <2 x i64> %10, <i64 20, i64 20>
%46 = icmp eq i64 %44, 100000000
br i1 %46, label %47, label %8
47: ; preds = %8
%48 = bitcast %struct.tms* %4 to i8*
br label %49
49: ; preds = %47, %49
%50 = phi i64 [ 0, %47 ], [ %61, %49 ]
%51 = tail call i32 (...) @rand()
%52 = srem i32 %51, 100000000
%53 = sitofp i32 %52 to double
%54 = tail call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), double %53)
%55 = call float @times(%struct.tms* %4)
%56 = call float @times(%struct.tms* %4)
%57 = fsub float %56, %55
%58 = fpext float %57 to double
%59 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %50
store double %58, double* %59
%60 = tail call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), double %58)
%61 = add nuw nsw i64 %50, 1
%62 = icmp eq i64 %61, 100
br i1 %62, label %63, label %49
63: ; preds = %49, %63
%64 = phi i64 [ %85, %63 ], [ 0, %49 ]
%65 = phi double [ %84, %63 ], [ 0.000000e+00, %49 ]
%66 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %64
%67 = load double, double* %66
%68 = fadd double %65, %67
%69 = add nuw nsw i64 %64, 1
%70 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %69
%71 = load double, double* %70
%72 = fadd double %68, %71
%73 = add nuw nsw i64 %64, 2
%74 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %73
%75 = load double, double* %74
%76 = fadd double %72, %75
%77 = add nuw nsw i64 %64, 3
%78 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %77
%79 = load double, double* %78
%80 = fadd double %76, %79
%81 = add nuw nsw i64 %64, 4
%82 = getelementptr inbounds [100 x double], [100 x double]* %3, i64 0, i64 %81
%83 = load double, double* %82
%84 = fadd double %80, %83
%85 = add nuw nsw i64 %64, 5
%86 = icmp eq i64 %85, 100
br i1 %86, label %87, label %63
87: ; preds = %63
%88 = fdiv double %84, 1.000000e+02
%89 = tail call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0), double %88)
%90 = tail call i32 @free(i64* %6)
ret i32 0
}