#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 timezone {
  int dummy;
};
struct timeval {
  int tv_usec;
  int tv_sec;
};

/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ dft(double *, double *, double *, double *, double *,
                       double *, int);
int /*<<< orphan*/ dftc(double *, double *, double *, double *, double *,
                        double *, int);
double fabs(double);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ gettimeofday(struct timeval *, struct timezone *);
int /*<<< orphan*/ matrizdft(double *, double *, int);
int /*<<< orphan*/ posix_memalign(void **, int, int);
int /*<<< orphan*/ printf(char *, float);
int rand();
int /*<<< orphan*/ srand(int);
main(int argc, char *argv[]) {
  int tam = 1024;
  if (argc > 1)
    tam = atoi(argv[1]);
  double *xr, *xi;
  double *matrizr, *matrizi;
  double *rr, *ri;
  double *rrc, *ric;
  struct timeval tiempo;
  struct timezone tz;
  unsigned long inicio, fin;
  posix_memalign((void **)&matrizr, 16, tam * tam * sizeof(double));
  posix_memalign((void **)&matrizi, 16, tam * tam * sizeof(double));
  posix_memalign((void **)&xr, 16, tam * sizeof(double));
  posix_memalign((void **)&xi, 16, tam * sizeof(double));
  posix_memalign((void **)&rr, 16, tam * sizeof(double));
  posix_memalign((void **)&ri, 16, tam * sizeof(double));
  posix_memalign((void **)&rrc, 16, tam * sizeof(double));
  posix_memalign((void **)&ric, 16, tam * sizeof(double));
  int i;
  gettimeofday(&tiempo, &tz);
  srand(tiempo.tv_usec);
  for (i = 0; i < tam; i++) {
    xr[i] = 1 ? rand() : i + 1;
    xi[i] = 1 ? rand() : i + 1;
  }
  matrizdft(matrizr, matrizi, tam);
  gettimeofday(&tiempo, &tz);
  inicio = tiempo.tv_sec * 1000000 + tiempo.tv_usec;
  dftc(xr, xi, matrizr, matrizi, rrc, ric, tam);
  gettimeofday(&tiempo, &tz);
  fin = tiempo.tv_sec * 1000000 + tiempo.tv_usec;
  printf("Segundos para el calculo en C:     %f\n",
         (float)(fin - inicio) / 1000000.0);
  gettimeofday(&tiempo, &tz);
  inicio = tiempo.tv_sec * 1000000 + tiempo.tv_usec;
  dft(xr, xi, matrizr, matrizi, rr, ri, tam);
  gettimeofday(&tiempo, &tz);
  fin = tiempo.tv_sec * 1000000 + tiempo.tv_usec;
  printf("Segundos para el calculo con SSE:  %f\n",
         (float)(fin - inicio) / 1000000.0);
  double errorAbsoluto = 0;
  for (i = 0; i < tam; i++) {
    rr[i] = fabs(rrc[i] - rr[i]);
    ri[i] = fabs(ric[i] - ri[i]);
    errorAbsoluto += rr[i] + ri[i];
  }
  free(matrizr);
  free(matrizi);
  free(xr);
  free(xi);
  free(rr);
  free(ri);
  free(rrc);
  free(ric);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x400,-0x14(%rbp)
cmpl   $0x1,-0x8(%rbp)
jle    11da <main+0x3a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x14(%rbp)
lea    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x20(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x28(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x40(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x48(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x50(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x58(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
mov    $0x10,%esi
call   10b0 <posix_memalign@plt>
lea    -0x60(%rbp),%rdi
lea    -0x68(%rbp),%rsi
call   1060 <gettimeofday@plt>
mov    -0x60(%rbp),%edi
call   1070 <srand@plt>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    130a <main+0x16a>
mov    $0x0,%al
call   10c0 <rand@plt>
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   10c0 <rand@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    12c0 <main+0x120>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1040 <matrizdft@plt>
lea    -0x60(%rbp),%rdi
mov    %rdi,-0xa0(%rbp)
lea    -0x68(%rbp),%rsi
mov    %rsi,-0x98(%rbp)
call   1060 <gettimeofday@plt>
mov    -0x60(%rbp),%ecx
mov    -0x5c(%rbp),%eax
imul   $0xf4240,%eax,%eax
add    %ecx,%eax
cltq
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x58(%rbp),%r9
mov    -0x14(%rbp),%r10d
mov    %rsp,%rax
mov    %r10d,(%rax)
call   1090 <dftc@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rsi
call   1060 <gettimeofday@plt>
mov    -0x60(%rbp),%ecx
mov    -0x5c(%rbp),%eax
imul   $0xf4240,%eax,%eax
add    %ecx,%eax
cltq
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x90(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x8c(%rbp)
ff
js     13e7 <main+0x247>
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xc05(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xc16(%rip),%rdi
call   1050 <printf@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rsi
call   1060 <gettimeofday@plt>
mov    -0x60(%rbp),%ecx
mov    -0x5c(%rbp),%eax
imul   $0xf4240,%eax,%eax
add    %ecx,%eax
cltq
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%r8
mov    -0x48(%rbp),%r9
mov    -0x14(%rbp),%r10d
mov    %rsp,%rax
mov    %r10d,(%rax)
call   1080 <dft@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%rsi
call   1060 <gettimeofday@plt>
mov    -0x60(%rbp),%ecx
mov    -0x5c(%rbp),%eax
imul   $0xf4240,%eax,%eax
add    %ecx,%eax
cltq
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xa8(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xa4(%rbp)
ff
js     14d4 <main+0x334>
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xb18(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xb50(%rip),%rdi
call   1050 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15b6 <main+0x416>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xad5(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xaa3(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    150e <main+0x36e>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    $0x400,%r12d
cmp    $0x2,%edi
jl     11c5 <main+0x25>
mov    0x8(%rsi),%rdi
call   10a0 <atoi@plt>
mov    %eax,%r12d
lea    0x0(,%r12,8),%ebx
mov    %ebx,%ebp
imul   %r12d,%ebp
lea    0x28(%rsp),%rdi
mov    $0x10,%esi
mov    %ebp,%edx
call   10b0 <posix_memalign@plt>
lea    0x20(%rsp),%rdi
mov    $0x10,%esi
mov    %ebp,%edx
call   10b0 <posix_memalign@plt>
lea    0x38(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x30(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x60(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x58(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x50(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x48(%rsp),%rdi
mov    $0x10,%esi
mov    %ebx,%edx
call   10b0 <posix_memalign@plt>
lea    0x18(%rsp),%rdi
lea    0x40(%rsp),%rsi
call   1060 <gettimeofday@plt>
mov    0x18(%rsp),%edi
call   1070 <srand@plt>
mov    %r12d,%r13d
test   %r12d,%r12d
jle    12b9 <main+0x119>
xor    %ebx,%ebx
nopl   (%rax)
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x38(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x30(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1280 <main+0xe0>
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    %r12d,%edx
call   1040 <matrizdft@plt>
lea    0x18(%rsp),%r14
lea    0x40(%rsp),%r15
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <gettimeofday@plt>
movslq 0x1c(%rsp),%rax
imul   $0xf4240,%rax,%rax
movslq 0x18(%rsp),%rbx
add    %rax,%rbx
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x50(%rsp),%r8
mov    0x48(%rsp),%r9
mov    %r12d,(%rsp)
call   1090 <dftc@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <gettimeofday@plt>
movslq 0x1c(%rsp),%rax
imul   $0xf4240,%rax,%rcx
movslq 0x18(%rsp),%rax
add    %rcx,%rax
sub    %rbx,%rax
js     1349 <main+0x1a9>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
jmp    1361 <main+0x1c1>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm0
divss  0xc97(%rip),%xmm0
lea    0xcb0(%rip),%rdi
call   1050 <printf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <gettimeofday@plt>
movslq 0x1c(%rsp),%rax
imul   $0xf4240,%rax,%rax
movslq 0x18(%rsp),%rbx
add    %rax,%rbx
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x60(%rsp),%r8
mov    0x58(%rsp),%r9
mov    %r12d,(%rsp)
call   1080 <dft@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <gettimeofday@plt>
movslq 0x1c(%rsp),%rax
imul   $0xf4240,%rax,%rcx
movslq 0x18(%rsp),%rax
add    %rcx,%rax
sub    %rbx,%rax
js     13e9 <main+0x249>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
jmp    1401 <main+0x261>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm0
movss  0xbf7(%rip),%xmm1
divss  %xmm1,%xmm0
lea    0xc33(%rip),%rdi
call   1050 <printf@plt>
test   %r12d,%r12d
jle    147f <main+0x2df>
mov    0x50(%rsp),%rax
mov    0x60(%rsp),%rcx
mov    0x48(%rsp),%rdx
mov    0x58(%rsp),%rsi
cmp    $0x1,%r12d
jne    14e0 <main+0x340>
xor    %edi,%edi
movapd 0xbca(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdi,8),%xmm1
subsd  (%rcx,%rdi,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm1
subsd  (%rsi,%rdi,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r13
jne    1450 <main+0x2b0>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rcx,%r13,8),%rdi
lea    (%rsi,%r13,8),%rbp
lea    (%rax,%r13,8),%rbx
lea    (%rdx,%r13,8),%r10
cmp    %rbp,%rcx
setb   0x17(%rsp)
cmp    %rdi,%rsi
setb   %r12b
cmp    %rbx,%rcx
setb   %r15b
cmp    %rdi,%rax
setb   %r11b
cmp    %r10,%rcx
setb   %r8b
cmp    %rdi,%rdx
setb   %r14b
cmp    %rbx,%rsi
setb   %r9b
cmp    %rbp,%rax
setb   %bl
cmp    %r10,%rsi
setb   %r10b
cmp    %rbp,%rdx
setb   %bpl
xor    %edi,%edi
test   %r12b,0x17(%rsp)
jne    143e <main+0x29e>
and    %r11b,%r15b
jne    143e <main+0x29e>
and    %r14b,%r8b
jne    143e <main+0x29e>
and    %bl,%r9b
jne    143e <main+0x29e>
and    %bpl,%r10b
jne    143e <main+0x29e>
mov    %r13d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%rdi),%rbp
mov    %rbp,%r8
shr    %r8
add    $0x1,%r8
test   %rbp,%rbp
je     1656 <main+0x4b6>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
movapd 0xa7b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rax,%rbp,8),%xmm1
movupd (%rcx,%rbp,8),%xmm2
subpd  %xmm2,%xmm1
andpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rbp,8)
movupd (%rdx,%rbp,8),%xmm1
movupd (%rsi,%rbp,8),%xmm2
subpd  %xmm2,%xmm1
andpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rbp,8)
movupd 0x10(%rax,%rbp,8),%xmm1
movupd 0x10(%rcx,%rbp,8),%xmm2
subpd  %xmm2,%xmm1
andpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rcx,%rbp,8)
movupd 0x10(%rdx,%rbp,8),%xmm1
movupd 0x10(%rsi,%rbp,8),%xmm2
subpd  %xmm2,%xmm1
andpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rsi,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rbx
jne    15a0 <main+0x400>
test   $0x1,%r8b
je     1648 <main+0x4a8>
movupd (%rax,%rbp,8),%xmm0
movupd (%rcx,%rbp,8),%xmm1
subpd  %xmm1,%xmm0
movapd 0x9e8(%rip),%xmm1
andpd  %xmm1,%xmm0
movupd %xmm0,(%rcx,%rbp,8)
movupd (%rdx,%rbp,8),%xmm0
movupd (%rsi,%rbp,8),%xmm2
subpd  %xmm2,%xmm0
andpd  %xmm1,%xmm0
movupd %xmm0,(%rsi,%rbp,8)
cmp    %r13,%rdi
jne    143e <main+0x29e>
jmp    147f <main+0x2df>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    1612 <main+0x472>
jmp    1648 <main+0x4a8>

LLVM IR (-O0):
%struct.timeval = type { i32, i32 }
%struct.timezone = type { i32 }
@.str = [39 x i8] c"Segundos para el calculo en C: %f\0A\00"
@.str.1 = [39 x i8] c"Segundos para el calculo con SSE: %f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%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 %struct.timeval
%16 = alloca %struct.timezone
%17 = alloca i64
%18 = alloca i64
%19 = alloca i32
%20 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 1024, i32* %6
%21 = load i32, i32* %4
%22 = icmp sgt i32 %21, 1
br i1 %22, label %23, label %28
23: ; preds = %2
%24 = load i8**, i8*** %5
%25 = getelementptr inbounds i8*, i8** %24, i64 1
%26 = load i8*, i8** %25
%27 = call i32 @atoi(i8* %26)
store i32 %27, i32* %6
br label %28
28: ; preds = %23, %2
%29 = bitcast double** %9 to i8**
%30 = load i32, i32* %6
%31 = load i32, i32* %6
%32 = mul nsw i32 %30, %31
%33 = sext i32 %32 to i64
%34 = mul i64 %33, 8
%35 = trunc i64 %34 to i32
%36 = call i32 @posix_memalign(i8** %29, i32 16, i32 %35)
%37 = bitcast double** %10 to i8**
%38 = load i32, i32* %6
%39 = load i32, i32* %6
%40 = mul nsw i32 %38, %39
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 8
%43 = trunc i64 %42 to i32
%44 = call i32 @posix_memalign(i8** %37, i32 16, i32 %43)
%45 = bitcast double** %7 to i8**
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = mul i64 %47, 8
%49 = trunc i64 %48 to i32
%50 = call i32 @posix_memalign(i8** %45, i32 16, i32 %49)
%51 = bitcast double** %8 to i8**
%52 = load i32, i32* %6
%53 = sext i32 %52 to i64
%54 = mul i64 %53, 8
%55 = trunc i64 %54 to i32
%56 = call i32 @posix_memalign(i8** %51, i32 16, i32 %55)
%57 = bitcast double** %11 to i8**
%58 = load i32, i32* %6
%59 = sext i32 %58 to i64
%60 = mul i64 %59, 8
%61 = trunc i64 %60 to i32
%62 = call i32 @posix_memalign(i8** %57, i32 16, i32 %61)
%63 = bitcast double** %12 to i8**
%64 = load i32, i32* %6
%65 = sext i32 %64 to i64
%66 = mul i64 %65, 8
%67 = trunc i64 %66 to i32
%68 = call i32 @posix_memalign(i8** %63, i32 16, i32 %67)
%69 = bitcast double** %13 to i8**
%70 = load i32, i32* %6
%71 = sext i32 %70 to i64
%72 = mul i64 %71, 8
%73 = trunc i64 %72 to i32
%74 = call i32 @posix_memalign(i8** %69, i32 16, i32 %73)
%75 = bitcast double** %14 to i8**
%76 = load i32, i32* %6
%77 = sext i32 %76 to i64
%78 = mul i64 %77, 8
%79 = trunc i64 %78 to i32
%80 = call i32 @posix_memalign(i8** %75, i32 16, i32 %79)
%81 = call i32 @gettimeofday(%struct.timeval* %15, %struct.timezone* %16)
%82 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 0
%83 = load i32, i32* %82
%84 = call i32 @srand(i32 %83)
store i32 0, i32* %19
br label %85
85: ; preds = %102, %28
%86 = load i32, i32* %19
%87 = load i32, i32* %6
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %105
89: ; preds = %85
%90 = call i32 (...) @rand()
%91 = sitofp i32 %90 to double
%92 = load double*, double** %7
%93 = load i32, i32* %19
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %92, i64 %94
store double %91, double* %95
%96 = call i32 (...) @rand()
%97 = sitofp i32 %96 to double
%98 = load double*, double** %8
%99 = load i32, i32* %19
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
store double %97, double* %101
br label %102
102: ; preds = %89
%103 = load i32, i32* %19
%104 = add nsw i32 %103, 1
store i32 %104, i32* %19
br label %85
105: ; preds = %85
%106 = load double*, double** %9
%107 = load double*, double** %10
%108 = load i32, i32* %6
%109 = call i32 @matrizdft(double* %106, double* %107, i32 %108)
%110 = call i32 @gettimeofday(%struct.timeval* %15, %struct.timezone* %16)
%111 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 1
%112 = load i32, i32* %111
%113 = mul nsw i32 %112, 1000000
%114 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 0
%115 = load i32, i32* %114
%116 = add nsw i32 %113, %115
%117 = sext i32 %116 to i64
store i64 %117, i64* %17
%118 = load double*, double** %7
%119 = load double*, double** %8
%120 = load double*, double** %9
%121 = load double*, double** %10
%122 = load double*, double** %13
%123 = load double*, double** %14
%124 = load i32, i32* %6
%125 = call i32 @dftc(double* %118, double* %119, double* %120, double* %121, double* %122, double* %123, i32 %124)
%126 = call i32 @gettimeofday(%struct.timeval* %15, %struct.timezone* %16)
%127 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 1
%128 = load i32, i32* %127
%129 = mul nsw i32 %128, 1000000
%130 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 0
%131 = load i32, i32* %130
%132 = add nsw i32 %129, %131
%133 = sext i32 %132 to i64
store i64 %133, i64* %18
%134 = load i64, i64* %18
%135 = load i64, i64* %17
%136 = sub i64 %134, %135
%137 = uitofp i64 %136 to float
%138 = fpext float %137 to double
%139 = fdiv double %138, 1.000000e+06
%140 = fptrunc double %139 to float
%141 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), float %140)
%142 = call i32 @gettimeofday(%struct.timeval* %15, %struct.timezone* %16)
%143 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 1
%144 = load i32, i32* %143
%145 = mul nsw i32 %144, 1000000
%146 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 0
%147 = load i32, i32* %146
%148 = add nsw i32 %145, %147
%149 = sext i32 %148 to i64
store i64 %149, i64* %17
%150 = load double*, double** %7
%151 = load double*, double** %8
%152 = load double*, double** %9
%153 = load double*, double** %10
%154 = load double*, double** %11
%155 = load double*, double** %12
%156 = load i32, i32* %6
%157 = call i32 @dft(double* %150, double* %151, double* %152, double* %153, double* %154, double* %155, i32 %156)
%158 = call i32 @gettimeofday(%struct.timeval* %15, %struct.timezone* %16)
%159 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 1
%160 = load i32, i32* %159
%161 = mul nsw i32 %160, 1000000
%162 = getelementptr inbounds %struct.timeval, %struct.timeval* %15, i32 0, i32 0
%163 = load i32, i32* %162
%164 = add nsw i32 %161, %163
%165 = sext i32 %164 to i64
store i64 %165, i64* %18
%166 = load i64, i64* %18
%167 = load i64, i64* %17
%168 = sub i64 %166, %167
%169 = uitofp i64 %168 to float
%170 = fpext float %169 to double
%171 = fdiv double %170, 1.000000e+06
%172 = fptrunc double %171 to float
%173 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0), float %172)
store double 0.000000e+00, double* %20
store i32 0, i32* %19
br label %174
174: ; preds = %224, %105
%175 = load i32, i32* %19
%176 = load i32, i32* %6
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %227
178: ; preds = %174
%179 = load double*, double** %13
%180 = load i32, i32* %19
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %179, i64 %181
%183 = load double, double* %182
%184 = load double*, double** %11
%185 = load i32, i32* %19
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %184, i64 %186
%188 = load double, double* %187
%189 = fsub double %183, %188
%190 = call double @llvm.fabs.f64(double %189)
%191 = load double*, double** %11
%192 = load i32, i32* %19
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
store double %190, double* %194
%195 = load double*, double** %14
%196 = load i32, i32* %19
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %195, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %12
%201 = load i32, i32* %19
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
%204 = load double, double* %203
%205 = fsub double %199, %204
%206 = call double @llvm.fabs.f64(double %205)
%207 = load double*, double** %12
%208 = load i32, i32* %19
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds double, double* %207, i64 %209
store double %206, double* %210
%211 = load double*, double** %11
%212 = load i32, i32* %19
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = load double*, double** %12
%217 = load i32, i32* %19
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = fadd double %215, %220
%222 = load double, double* %20
%223 = fadd double %222, %221
store double %223, double* %20
br label %224
224: ; preds = %178
%225 = load i32, i32* %19
%226 = add nsw i32 %225, 1
store i32 %226, i32* %19
br label %174
227: ; preds = %174
%228 = load double*, double** %9
%229 = call i32 @free(double* %228)
%230 = load double*, double** %10
%231 = call i32 @free(double* %230)
%232 = load double*, double** %7
%233 = call i32 @free(double* %232)
%234 = load double*, double** %8
%235 = call i32 @free(double* %234)
%236 = load double*, double** %11
%237 = call i32 @free(double* %236)
%238 = load double*, double** %12
%239 = call i32 @free(double* %238)
%240 = load double*, double** %13
%241 = call i32 @free(double* %240)
%242 = load double*, double** %14
%243 = call i32 @free(double* %242)
ret i32 0
}

LLVM IR (-O2):
%struct.timeval = type { i32, i32 }
%struct.timezone = type { i32 }
@.str = [39 x i8] c"Segundos para el calculo en C: %f\0A\00"
@.str.1 = [39 x i8] c"Segundos para el calculo con SSE: %f\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca double*
%4 = alloca double*
%5 = alloca double*
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca %struct.timeval
%12 = alloca %struct.timezone
%13 = icmp sgt i32 %0, 1
br i1 %13, label %14, label %18
14: ; preds = %2
%15 = getelementptr inbounds i8*, i8** %1, i64 1
%16 = load i8*, i8** %15
%17 = tail call i32 @atoi(i8* %16)
br label %18
18: ; preds = %14, %2
%19 = phi i32 [ %17, %14 ], [ 1024, %2 ]
%20 = bitcast double** %3 to i8*
%21 = bitcast double** %4 to i8*
%22 = bitcast double** %5 to i8*
%23 = bitcast double** %6 to i8*
%24 = bitcast double** %7 to i8*
%25 = bitcast double** %8 to i8*
%26 = bitcast double** %9 to i8*
%27 = bitcast double** %10 to i8*
%28 = bitcast %struct.timeval* %11 to i8*
%29 = bitcast %struct.timezone* %12 to i8*
%30 = bitcast double** %5 to i8**
%31 = shl i32 %19, 3
%32 = mul i32 %31, %19
%33 = call i32 @posix_memalign(i8** %30, i32 16, i32 %32)
%34 = bitcast double** %6 to i8**
%35 = call i32 @posix_memalign(i8** %34, i32 16, i32 %32)
%36 = bitcast double** %3 to i8**
%37 = call i32 @posix_memalign(i8** %36, i32 16, i32 %31)
%38 = bitcast double** %4 to i8**
%39 = call i32 @posix_memalign(i8** %38, i32 16, i32 %31)
%40 = bitcast double** %7 to i8**
%41 = call i32 @posix_memalign(i8** %40, i32 16, i32 %31)
%42 = bitcast double** %8 to i8**
%43 = call i32 @posix_memalign(i8** %42, i32 16, i32 %31)
%44 = bitcast double** %9 to i8**
%45 = call i32 @posix_memalign(i8** %44, i32 16, i32 %31)
%46 = bitcast double** %10 to i8**
%47 = call i32 @posix_memalign(i8** %46, i32 16, i32 %31)
%48 = call i32 @gettimeofday(%struct.timeval* %11, %struct.timezone* %12)
%49 = getelementptr inbounds %struct.timeval, %struct.timeval* %11, i64 0, i32 0
%50 = load i32, i32* %49
%51 = call i32 @srand(i32 %50)
%52 = icmp sgt i32 %19, 0
br i1 %52, label %53, label %67
53: ; preds = %18
%54 = zext i32 %19 to i64
br label %55
55: ; preds = %53, %55
%56 = phi i64 [ 0, %53 ], [ %65, %55 ]
%57 = call i32 (...) @rand()
%58 = sitofp i32 %57 to double
%59 = load double*, double** %3
%60 = getelementptr inbounds double, double* %59, i64 %56
store double %58, double* %60
%61 = call i32 (...) @rand()
%62 = sitofp i32 %61 to double
%63 = load double*, double** %4
%64 = getelementptr inbounds double, double* %63, i64 %56
store double %62, double* %64
%65 = add nuw nsw i64 %56, 1
%66 = icmp eq i64 %65, %54
br i1 %66, label %67, label %55
67: ; preds = %55, %18
%68 = load double*, double** %5
%69 = load double*, double** %6
%70 = call i32 @matrizdft(double* %68, double* %69, i32 %19)
%71 = call i32 @gettimeofday(%struct.timeval* %11, %struct.timezone* %12)
%72 = getelementptr inbounds %struct.timeval, %struct.timeval* %11, i64 0, i32 1
%73 = load i32, i32* %72
%74 = mul nsw i32 %73, 1000000
%75 = load i32, i32* %49
%76 = add nsw i32 %74, %75
%77 = sext i32 %76 to i64
%78 = load double*, double** %3
%79 = load double*, double** %4
%80 = load double*, double** %5
%81 = load double*, double** %6
%82 = load double*, double** %9
%83 = load double*, double** %10
%84 = call i32 @dftc(double* %78, double* %79, double* %80, double* %81, double* %82, double* %83, i32 %19)
%85 = call i32 @gettimeofday(%struct.timeval* %11, %struct.timezone* %12)
%86 = load i32, i32* %72
%87 = mul nsw i32 %86, 1000000
%88 = load i32, i32* %49
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = sub nsw i64 %90, %77
%92 = uitofp i64 %91 to float
%93 = fdiv float %92, 1.000000e+06
%94 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), float %93)
%95 = call i32 @gettimeofday(%struct.timeval* %11, %struct.timezone* %12)
%96 = load i32, i32* %72
%97 = mul nsw i32 %96, 1000000
%98 = load i32, i32* %49
%99 = add nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = load double*, double** %3
%102 = load double*, double** %4
%103 = load double*, double** %5
%104 = load double*, double** %6
%105 = load double*, double** %7
%106 = load double*, double** %8
%107 = call i32 @dft(double* %101, double* %102, double* %103, double* %104, double* %105, double* %106, i32 %19)
%108 = call i32 @gettimeofday(%struct.timeval* %11, %struct.timezone* %12)
%109 = load i32, i32* %72
%110 = mul nsw i32 %109, 1000000
%111 = load i32, i32* %49
%112 = add nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = sub nsw i64 %113, %100
%115 = uitofp i64 %114 to float
%116 = fdiv float %115, 1.000000e+06
%117 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0), float %116)
br i1 %52, label %118, label %243
118: ; preds = %67
%119 = load double*, double** %9
%120 = load double*, double** %7
%121 = load double*, double** %10
%122 = load double*, double** %8
%123 = zext i32 %19 to i64
%124 = icmp eq i32 %19, 1
br i1 %124, label %225, label %125
125: ; preds = %118
%126 = getelementptr double, double* %120, i64 %123
%127 = getelementptr double, double* %122, i64 %123
%128 = getelementptr double, double* %119, i64 %123
%129 = getelementptr double, double* %121, i64 %123
%130 = icmp ult double* %120, %127
%131 = icmp ult double* %122, %126
%132 = and i1 %130, %131
%133 = icmp ult double* %120, %128
%134 = icmp ult double* %119, %126
%135 = and i1 %133, %134
%136 = or i1 %132, %135
%137 = icmp ult double* %120, %129
%138 = icmp ult double* %121, %126
%139 = and i1 %137, %138
%140 = or i1 %136, %139
%141 = icmp ult double* %122, %128
%142 = icmp ult double* %119, %127
%143 = and i1 %141, %142
%144 = or i1 %140, %143
%145 = icmp ult double* %122, %129
%146 = icmp ult double* %121, %127
%147 = and i1 %145, %146
%148 = or i1 %144, %147
br i1 %148, label %225, label %149
149: ; preds = %125
%150 = and i64 %123, 4294967294
%151 = add nsw i64 %150, -2
%152 = lshr exact i64 %151, 1
%153 = add nuw i64 %152, 1
%154 = and i64 %153, 1
%155 = icmp eq i64 %151, 0
br i1 %155, label %201, label %156
156: ; preds = %149
%157 = and i64 %153, -2
br label %158
158: ; preds = %158, %156
%159 = phi i64 [ 0, %156 ], [ %198, %158 ]
%160 = phi i64 [ 0, %156 ], [ %199, %158 ]
%161 = getelementptr inbounds double, double* %119, i64 %159
%162 = bitcast double* %161 to <2 x double>*
%163 = load <2 x double>, <2 x double>* %162
%164 = getelementptr inbounds double, double* %120, i64 %159
%165 = bitcast double* %164 to <2 x double>*
%166 = load <2 x double>, <2 x double>* %165
%167 = fsub <2 x double> %163, %166
%168 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %167)
%169 = bitcast double* %164 to <2 x double>*
store <2 x double> %168, <2 x double>* %169
%170 = getelementptr inbounds double, double* %121, i64 %159
%171 = bitcast double* %170 to <2 x double>*
%172 = load <2 x double>, <2 x double>* %171
%173 = getelementptr inbounds double, double* %122, i64 %159
%174 = bitcast double* %173 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = fsub <2 x double> %172, %175
%177 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %176)
%178 = bitcast double* %173 to <2 x double>*
store <2 x double> %177, <2 x double>* %178
%179 = or i64 %159, 2
%180 = getelementptr inbounds double, double* %119, i64 %179
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = getelementptr inbounds double, double* %120, i64 %179
%184 = bitcast double* %183 to <2 x double>*
%185 = load <2 x double>, <2 x double>* %184
%186 = fsub <2 x double> %182, %185
%187 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %186)
%188 = bitcast double* %183 to <2 x double>*
store <2 x double> %187, <2 x double>* %188
%189 = getelementptr inbounds double, double* %121, i64 %179
%190 = bitcast double* %189 to <2 x double>*
%191 = load <2 x double>, <2 x double>* %190
%192 = getelementptr inbounds double, double* %122, i64 %179
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = fsub <2 x double> %191, %194
%196 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %195)
%197 = bitcast double* %192 to <2 x double>*
store <2 x double> %196, <2 x double>* %197
%198 = add nuw i64 %159, 4
%199 = add nuw i64 %160, 2
%200 = icmp eq i64 %199, %157
br i1 %200, label %201, label %158
201: ; preds = %158, %149
%202 = phi i64 [ 0, %149 ], [ %198, %158 ]
%203 = icmp eq i64 %154, 0
br i1 %203, label %223, label %204
204: ; preds = %201
%205 = getelementptr inbounds double, double* %119, i64 %202
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %120, i64 %202
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fsub <2 x double> %207, %210
%212 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %211)
%213 = bitcast double* %208 to <2 x double>*
store <2 x double> %212, <2 x double>* %213
%214 = getelementptr inbounds double, double* %121, i64 %202
%215 = bitcast double* %214 to <2 x double>*
%216 = load <2 x double>, <2 x double>* %215
%217 = getelementptr inbounds double, double* %122, i64 %202
%218 = bitcast double* %217 to <2 x double>*
%219 = load <2 x double>, <2 x double>* %218
%220 = fsub <2 x double> %216, %219
%221 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %220)
%222 = bitcast double* %217 to <2 x double>*
store <2 x double> %221, <2 x double>* %222
br label %223
223: ; preds = %201, %204
%224 = icmp eq i64 %150, %123
br i1 %224, label %243, label %225
225: ; preds = %125, %118, %223
%226 = phi i64 [ 0, %125 ], [ 0, %118 ], [ %150, %223 ]
br label %227
227: ; preds = %225, %227
%228 = phi i64 [ %241, %227 ], [ %226, %225 ]
%229 = getelementptr inbounds double, double* %119, i64 %228
%230 = load double, double* %229
%231 = getelementptr inbounds double, double* %120, i64 %228
%232 = load double, double* %231
%233 = fsub double %230, %232
%234 = call double @llvm.fabs.f64(double %233)
store double %234, double* %231
%235 = getelementptr inbounds double, double* %121, i64 %228
%236 = load double, double* %235
%237 = getelementptr inbounds double, double* %122, i64 %228
%238 = load double, double* %237
%239 = fsub double %236, %238
%240 = call double @llvm.fabs.f64(double %239)
store double %240, double* %237
%241 = add nuw nsw i64 %228, 1
%242 = icmp eq i64 %241, %123
br i1 %242, label %243, label %227
243: ; preds = %227, %223, %67
%244 = load double*, double** %5
%245 = call i32 @free(double* %244)
%246 = load double*, double** %6
%247 = call i32 @free(double* %246)
%248 = load double*, double** %3
%249 = call i32 @free(double* %248)
%250 = load double*, double** %4
%251 = call i32 @free(double* %250)
%252 = load double*, double** %7
%253 = call i32 @free(double* %252)
%254 = load double*, double** %8
%255 = call i32 @free(double* %254)
%256 = load double*, double** %9
%257 = call i32 @free(double* %256)
%258 = load double*, double** %10
%259 = call i32 @free(double* %258)
ret i32 0
}