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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int atoi(char *);
scalar_t__ calloc(int, int);
double dwalltime();
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
main(int argc, char *argv[]) {
  double *A, *B, *C, *D, *ab, *cd, *tot;
  int i, j, k, N;
  int check = 1;
  double timetick;
  if (argc < 2) {
    printf("\n Falta un argumento:: N dimension de la matriz \n");
    return 0;
  }
  N = atoi(argv[1]);
  A = (double *)malloc(sizeof(double) * N * N);
  B = (double *)malloc(sizeof(double) * N * N);
  C = (double *)malloc(sizeof(double) * N * N);
  D = (double *)malloc(sizeof(double) * N * N);
  ab = (double *)calloc(N * N, sizeof(double));
  cd = (double *)calloc(N * N, sizeof(double));
  tot = (double *)malloc(sizeof(double) * N * N);
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      A[i * N + j] = 1;
      B[i + j * N] = 1;
      C[i * N + j] = 1;
      D[i + j * N] = 1;
    }
  }
  timetick = dwalltime();
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      for (k = 0; k < N; k++) {
        ab[i * N + j] = ab[i * N + j] + A[i * N + k] * B[k + j * N];
        cd[i * N + j] = cd[i * N + j] + C[i * N + k] * D[k + j * N];
      }
      tot[i * N + j] = cd[i * N + j] + ab[i * N + j];
    }
  }
  printf("Tiempo en segundos %f \n", dwalltime() - timetick);
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      check = check && (tot[i * N + j] == N * 2);
    }
  }
  if (check) {
    printf("Multiplicacion de matrices resultado correcto\n");
  } else {
    printf("Multiplicacion de matrices resultado erroneo\n");
  }
  free(A);
  free(B);
  free(C);
  free(D);
  free(ab);
  free(cd);
  free(tot);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1,-0x5c(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11a1 <main+0x41>
lea    0xe7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    15ba <main+0x45a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x58(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%edi
imul   -0x58(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%edi
imul   -0x58(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
movslq -0x58(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1325 <main+0x1c5>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1312 <main+0x1b2>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd5f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xd3f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd21(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xd01(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    127c <main+0x11c>
jmp    1317 <main+0x1b7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1269 <main+0x109>
mov    $0x0,%al
call   1050 <dwalltime@plt>
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    149f <main+0x33f>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    148c <main+0x32c>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    143c <main+0x2dc>
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    135e <main+0x1fe>
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    134b <main+0x1eb>
jmp    1491 <main+0x331>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1338 <main+0x1d8>
mov    $0x0,%al
call   1050 <dwalltime@plt>
subsd  -0x68(%rbp),%xmm0
lea    0xb88(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1549 <main+0x3e9>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1536 <main+0x3d6>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x69(%rbp)
je     151d <main+0x3bd>
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
sete   %al
setnp  %cl
and    %cl,%al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14d3 <main+0x373>
jmp    153b <main+0x3db>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14c0 <main+0x360>
cmpl   $0x0,-0x5c(%rbp)
je     1566 <main+0x406>
lea    0xaf8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1574 <main+0x414>
lea    0xb14(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
cmp    $0x1,%edi
jg     1194 <main+0x24>
lea    0xee9(%rip),%rdi
call   1040 <puts@plt>
jmp    15c2 <main+0x452>
mov    0x8(%rsi),%rdi
call   1090 <atoi@plt>
mov    %eax,%r12d
mov    %eax,%ebp
imul   %ebp,%ebp
lea    0x0(,%rbp,8),%r14d
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,%r13
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %r12,%r10
mov    %rax,0x20(%rsp)
mov    %r10d,%r12d
test   %r10d,%r10d
mov    %r10,0x30(%rsp)
jle    1429 <main+0x2b9>
mov    %r12d,%r11d
and    $0xfffffffe,%r11d
mov    0x18(%rsp),%rcx
add    $0x8,%rcx
lea    0x0(,%r12,8),%rax
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rsi
add    $0x8,%rsi
lea    (%r15,%r12,8),%r9
mov    %r12,%rdi
shl    $0x4,%rdi
mov    0x10(%rsp),%r8
lea    (%r8,%r12,8),%rax
xor    %edx,%edx
mov    %rdx,(%rsp)
movabs $0x3ff0000000000000,%rdx
mov    %r15,0x28(%rsp)
mov    %r15,%rbp
mov    %r8,%r15
mov    %rdi,0x38(%rsp)
jmp    12b8 <main+0x148>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%r14
add    $0x1,%r14
mov    0x40(%rsp),%r8
add    %r8,%rcx
add    %r8,%rsi
add    $0x8,%r9
add    $0x8,%rax
add    $0x8,%r15
add    $0x8,%rbp
mov    %r14,%rdi
mov    %r14,(%rsp)
cmp    %r12,%r14
mov    0x38(%rsp),%rdi
je     135c <main+0x1ec>
cmp    $0x1,%r10d
jne    12d0 <main+0x160>
xor    %r8d,%r8d
jmp    130f <main+0x19f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %r14d,%r14d
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,-0x8(%rsi,%r8,8)
mov    %rdx,(%r15,%r14,1)
mov    %rdx,-0x8(%rcx,%r8,8)
mov    %rdx,0x0(%rbp,%r14,1)
mov    %rdx,(%rsi,%r8,8)
mov    %rdx,(%rax,%r14,1)
mov    %rdx,(%rcx,%r8,8)
mov    %rdx,(%r9,%r14,1)
add    $0x2,%r8
add    %rdi,%r14
cmp    %r8,%r11
jne    12e0 <main+0x170>
test   $0x1,%r12b
je     1280 <main+0x110>
mov    (%rsp),%rdi
mov    %rdi,%r14
imul   %r12,%r14
add    %r8,%r14
mov    0x8(%rsp),%r10
mov    %rdx,(%r10,%r14,8)
imul   %r12,%r8
add    %rdi,%r8
mov    0x10(%rsp),%rdi
mov    %rdx,(%rdi,%r8,8)
mov    0x18(%rsp),%rdi
mov    %rdx,(%rdi,%r14,8)
mov    0x28(%rsp),%rdi
mov    %rdx,(%rdi,%r8,8)
mov    0x30(%rsp),%r10
jmp    1280 <main+0x110>
xor    %eax,%eax
call   1060 <dwalltime@plt>
cmpl   $0x0,0x30(%rsp)
movsd  %xmm0,(%rsp)
jle    154e <main+0x3de>
lea    0x0(,%r12,8),%r10
xor    %r8d,%r8d
mov    0x18(%rsp),%r14
mov    %r14,%rdx
mov    0x8(%rsp),%rsi
mov    0x28(%rsp),%r15
mov    %r8,%r9
imul   %r12,%r9
mov    %r15,%rcx
mov    0x10(%rsp),%rdi
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r11,%r9,1),%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  (%rdi,%rbp,8),%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rcx,%rbp,8),%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    13c0 <main+0x250>
addsd  (%rbx,%rax,8),%xmm1
mov    0x20(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%r11
add    %r10,%rdi
add    %r10,%rcx
cmp    %r12,%r11
jne    13b0 <main+0x240>
add    $0x1,%r8
add    %r10,%rsi
add    %r10,%rdx
cmp    %r12,%r8
jne    1390 <main+0x220>
jmp    143a <main+0x2ca>
xor    %eax,%eax
call   1060 <dwalltime@plt>
movsd  %xmm0,(%rsp)
mov    0x18(%rsp),%r14
xor    %eax,%eax
call   1060 <dwalltime@plt>
subsd  (%rsp),%xmm0
lea    0xbb3(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x30(%rsp),%rbp
test   %ebp,%ebp
jle    153b <main+0x3cb>
lea    0x0(%rbp,%rbp,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    %r12d,%eax
and    $0xfffffffe,%eax
mov    0x20(%rsp),%rcx
add    $0x8,%rcx
lea    0x0(,%r12,8),%r8
mov    $0x1,%esi
xor    %r9d,%r9d
jmp    14c0 <main+0x350>
nopl   (%rax)
mov    %r9,%rdx
imul   %r12,%rdx
add    %rdx,%rdi
mov    0x20(%rsp),%rdx
movsd  (%rdx,%rdi,8),%xmm1
cmpeqsd %xmm0,%xmm1
movq   %xmm1,%rdx
and    $0x1,%edx
movzbl %dl,%esi
add    $0x1,%r9
add    %r8,%rcx
cmp    %r12,%r9
je     1524 <main+0x3b4>
cmp    $0x1,%ebp
jne    14e0 <main+0x370>
xor    %edi,%edi
test   $0x1,%r12b
je     14b4 <main+0x344>
test   %esi,%esi
jne    1490 <main+0x320>
xor    %edx,%edx
jmp    14b1 <main+0x341>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edi,%edi
jmp    14fe <main+0x38e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
movzbl %dl,%esi
add    $0x2,%rdi
cmp    %rdi,%rax
je     14c7 <main+0x357>
test   %esi,%esi
je     14f0 <main+0x380>
movsd  -0x8(%rcx,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jne    14f0 <main+0x380>
jp     14f0 <main+0x380>
movsd  (%rcx,%rdi,8),%xmm1
cmpeqsd %xmm0,%xmm1
movq   %xmm1,%rdx
and    $0x1,%edx
jmp    14f2 <main+0x382>
lea    0xb1a(%rip),%rax
lea    0xae6(%rip),%rdi
test   $0x1,%dl
cmovne %rax,%rdi
jmp    1542 <main+0x3d2>
lea    0xb03(%rip),%rdi
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rbp
jmp    1583 <main+0x413>
xor    %eax,%eax
call   1060 <dwalltime@plt>
subsd  (%rsp),%xmm0
lea    0xa9f(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xad6(%rip),%rdi
mov    0x8(%rsp),%rbp
mov    0x10(%rsp),%r12
mov    0x18(%rsp),%r14
mov    0x28(%rsp),%r15
call   1040 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [50 x i8] c"\0A Falta un argumento:: N dimension de la matriz \0A\00"
@.str.1 = [24 x i8] c"Tiempo en segundos %f \0A\00"
@.str.2 = [47 x i8] c"Multiplicacion de matrices resultado correcto\0A\00"
@.str.3 = [46 x i8] c"Multiplicacion de matrices resultado erroneo\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 1, i32* %17
%19 = load i32, i32* %4
%20 = icmp slt i32 %19, 2
br i1 %20, label %21, label %23
21: ; preds = %2
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %322
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* %16
%28 = load i32, i32* %16
%29 = sext i32 %28 to i64
%30 = mul i64 8, %29
%31 = load i32, i32* %16
%32 = sext i32 %31 to i64
%33 = mul i64 %30, %32
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to double*
store double* %36, double** %6
%37 = load i32, i32* %16
%38 = sext i32 %37 to i64
%39 = mul i64 8, %38
%40 = load i32, i32* %16
%41 = sext i32 %40 to i64
%42 = mul i64 %39, %41
%43 = trunc i64 %42 to i32
%44 = call i64 @malloc(i32 %43)
%45 = inttoptr i64 %44 to double*
store double* %45, double** %7
%46 = load i32, i32* %16
%47 = sext i32 %46 to i64
%48 = mul i64 8, %47
%49 = load i32, i32* %16
%50 = sext i32 %49 to i64
%51 = mul i64 %48, %50
%52 = trunc i64 %51 to i32
%53 = call i64 @malloc(i32 %52)
%54 = inttoptr i64 %53 to double*
store double* %54, double** %8
%55 = load i32, i32* %16
%56 = sext i32 %55 to i64
%57 = mul i64 8, %56
%58 = load i32, i32* %16
%59 = sext i32 %58 to i64
%60 = mul i64 %57, %59
%61 = trunc i64 %60 to i32
%62 = call i64 @malloc(i32 %61)
%63 = inttoptr i64 %62 to double*
store double* %63, double** %9
%64 = load i32, i32* %16
%65 = load i32, i32* %16
%66 = mul nsw i32 %64, %65
%67 = call i64 @calloc(i32 %66, i32 8)
%68 = inttoptr i64 %67 to double*
store double* %68, double** %10
%69 = load i32, i32* %16
%70 = load i32, i32* %16
%71 = mul nsw i32 %69, %70
%72 = call i64 @calloc(i32 %71, i32 8)
%73 = inttoptr i64 %72 to double*
store double* %73, double** %11
%74 = load i32, i32* %16
%75 = sext i32 %74 to i64
%76 = mul i64 8, %75
%77 = load i32, i32* %16
%78 = sext i32 %77 to i64
%79 = mul i64 %76, %78
%80 = trunc i64 %79 to i32
%81 = call i64 @malloc(i32 %80)
%82 = inttoptr i64 %81 to double*
store double* %82, double** %12
store i32 0, i32* %13
br label %83
83: ; preds = %129, %23
%84 = load i32, i32* %13
%85 = load i32, i32* %16
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %132
87: ; preds = %83
store i32 0, i32* %14
br label %88
88: ; preds = %125, %87
%89 = load i32, i32* %14
%90 = load i32, i32* %16
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %128
92: ; preds = %88
%93 = load double*, double** %6
%94 = load i32, i32* %13
%95 = load i32, i32* %16
%96 = mul nsw i32 %94, %95
%97 = load i32, i32* %14
%98 = add nsw i32 %96, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %93, i64 %99
store double 1.000000e+00, double* %100
%101 = load double*, double** %7
%102 = load i32, i32* %13
%103 = load i32, i32* %14
%104 = load i32, i32* %16
%105 = mul nsw i32 %103, %104
%106 = add nsw i32 %102, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %101, i64 %107
store double 1.000000e+00, double* %108
%109 = load double*, double** %8
%110 = load i32, i32* %13
%111 = load i32, i32* %16
%112 = mul nsw i32 %110, %111
%113 = load i32, i32* %14
%114 = add nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %109, i64 %115
store double 1.000000e+00, double* %116
%117 = load double*, double** %9
%118 = load i32, i32* %13
%119 = load i32, i32* %14
%120 = load i32, i32* %16
%121 = mul nsw i32 %119, %120
%122 = add nsw i32 %118, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %117, i64 %123
store double 1.000000e+00, double* %124
br label %125
125: ; preds = %92
%126 = load i32, i32* %14
%127 = add nsw i32 %126, 1
store i32 %127, i32* %14
br label %88
128: ; preds = %88
br label %129
129: ; preds = %128
%130 = load i32, i32* %13
%131 = add nsw i32 %130, 1
store i32 %131, i32* %13
br label %83
132: ; preds = %83
%133 = call double (...) @dwalltime()
store double %133, double* %18
store i32 0, i32* %13
br label %134
134: ; preds = %256, %132
%135 = load i32, i32* %13
%136 = load i32, i32* %16
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %259
138: ; preds = %134
store i32 0, i32* %14
br label %139
139: ; preds = %252, %138
%140 = load i32, i32* %14
%141 = load i32, i32* %16
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %255
143: ; preds = %139
store i32 0, i32* %15
br label %144
144: ; preds = %221, %143
%145 = load i32, i32* %15
%146 = load i32, i32* %16
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %224
148: ; preds = %144
%149 = load double*, double** %10
%150 = load i32, i32* %13
%151 = load i32, i32* %16
%152 = mul nsw i32 %150, %151
%153 = load i32, i32* %14
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %149, i64 %155
%157 = load double, double* %156
%158 = load double*, double** %6
%159 = load i32, i32* %13
%160 = load i32, i32* %16
%161 = mul nsw i32 %159, %160
%162 = load i32, i32* %15
%163 = add nsw i32 %161, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %158, i64 %164
%166 = load double, double* %165
%167 = load double*, double** %7
%168 = load i32, i32* %15
%169 = load i32, i32* %14
%170 = load i32, i32* %16
%171 = mul nsw i32 %169, %170
%172 = add nsw i32 %168, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %167, i64 %173
%175 = load double, double* %174
%176 = call double @llvm.fmuladd.f64(double %166, double %175, double %157)
%177 = load double*, double** %10
%178 = load i32, i32* %13
%179 = load i32, i32* %16
%180 = mul nsw i32 %178, %179
%181 = load i32, i32* %14
%182 = add nsw i32 %180, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %177, i64 %183
store double %176, double* %184
%185 = load double*, double** %11
%186 = load i32, i32* %13
%187 = load i32, i32* %16
%188 = mul nsw i32 %186, %187
%189 = load i32, i32* %14
%190 = add nsw i32 %188, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %185, i64 %191
%193 = load double, double* %192
%194 = load double*, double** %8
%195 = load i32, i32* %13
%196 = load i32, i32* %16
%197 = mul nsw i32 %195, %196
%198 = load i32, i32* %15
%199 = add nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %194, i64 %200
%202 = load double, double* %201
%203 = load double*, double** %9
%204 = load i32, i32* %15
%205 = load i32, i32* %14
%206 = load i32, i32* %16
%207 = mul nsw i32 %205, %206
%208 = add nsw i32 %204, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds double, double* %203, i64 %209
%211 = load double, double* %210
%212 = call double @llvm.fmuladd.f64(double %202, double %211, double %193)
%213 = load double*, double** %11
%214 = load i32, i32* %13
%215 = load i32, i32* %16
%216 = mul nsw i32 %214, %215
%217 = load i32, i32* %14
%218 = add nsw i32 %216, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %213, i64 %219
store double %212, double* %220
br label %221
221: ; preds = %148
%222 = load i32, i32* %15
%223 = add nsw i32 %222, 1
store i32 %223, i32* %15
br label %144
224: ; preds = %144
%225 = load double*, double** %11
%226 = load i32, i32* %13
%227 = load i32, i32* %16
%228 = mul nsw i32 %226, %227
%229 = load i32, i32* %14
%230 = add nsw i32 %228, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %225, i64 %231
%233 = load double, double* %232
%234 = load double*, double** %10
%235 = load i32, i32* %13
%236 = load i32, i32* %16
%237 = mul nsw i32 %235, %236
%238 = load i32, i32* %14
%239 = add nsw i32 %237, %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %234, i64 %240
%242 = load double, double* %241
%243 = fadd double %233, %242
%244 = load double*, double** %12
%245 = load i32, i32* %13
%246 = load i32, i32* %16
%247 = mul nsw i32 %245, %246
%248 = load i32, i32* %14
%249 = add nsw i32 %247, %248
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %244, i64 %250
store double %243, double* %251
br label %252
252: ; preds = %224
%253 = load i32, i32* %14
%254 = add nsw i32 %253, 1
store i32 %254, i32* %14
br label %139
255: ; preds = %139
br label %256
256: ; preds = %255
%257 = load i32, i32* %13
%258 = add nsw i32 %257, 1
store i32 %258, i32* %13
br label %134
259: ; preds = %134
%260 = call double (...) @dwalltime()
%261 = load double, double* %18
%262 = fsub double %260, %261
%263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), double %262)
store i32 0, i32* %13
br label %264
264: ; preds = %297, %259
%265 = load i32, i32* %13
%266 = load i32, i32* %16
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %300
268: ; preds = %264
store i32 0, i32* %14
br label %269
269: ; preds = %293, %268
%270 = load i32, i32* %14
%271 = load i32, i32* %16
%272 = icmp slt i32 %270, %271
br i1 %272, label %273, label %296
273: ; preds = %269
%274 = load i32, i32* %17
%275 = icmp ne i32 %274, 0
br i1 %275, label %276, label %290
276: ; preds = %273
%277 = load double*, double** %12
%278 = load i32, i32* %13
%279 = load i32, i32* %16
%280 = mul nsw i32 %278, %279
%281 = load i32, i32* %14
%282 = add nsw i32 %280, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %277, i64 %283
%285 = load double, double* %284
%286 = load i32, i32* %16
%287 = mul nsw i32 %286, 2
%288 = sitofp i32 %287 to double
%289 = fcmp oeq double %285, %288
br label %290
290: ; preds = %276, %273
%291 = phi i1 [ false, %273 ], [ %289, %276 ]
%292 = zext i1 %291 to i32
store i32 %292, i32* %17
br label %293
293: ; preds = %290
%294 = load i32, i32* %14
%295 = add nsw i32 %294, 1
store i32 %295, i32* %14
br label %269
296: ; preds = %269
br label %297
297: ; preds = %296
%298 = load i32, i32* %13
%299 = add nsw i32 %298, 1
store i32 %299, i32* %13
br label %264
300: ; preds = %264
%301 = load i32, i32* %17
%302 = icmp ne i32 %301, 0
br i1 %302, label %303, label %305
303: ; preds = %300
%304 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.2, i64 0, i64 0))
br label %307
305: ; preds = %300
%306 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.3, i64 0, i64 0))
br label %307
307: ; preds = %305, %303
%308 = load double*, double** %6
%309 = call i32 @free(double* %308)
%310 = load double*, double** %7
%311 = call i32 @free(double* %310)
%312 = load double*, double** %8
%313 = call i32 @free(double* %312)
%314 = load double*, double** %9
%315 = call i32 @free(double* %314)
%316 = load double*, double** %10
%317 = call i32 @free(double* %316)
%318 = load double*, double** %11
%319 = call i32 @free(double* %318)
%320 = load double*, double** %12
%321 = call i32 @free(double* %320)
store i32 0, i32* %3
br label %322
322: ; preds = %307, %21
%323 = load i32, i32* %3
ret i32 %323
}

LLVM IR (-O2):
@.str.1 = [24 x i8] c"Tiempo en segundos %f \0A\00"
@str = [45 x i8] c"Multiplicacion de matrices resultado erroneo\00"
@str.4 = [46 x i8] c"Multiplicacion de matrices resultado correcto\00"
@str.5 = [49 x i8] c"\0A Falta un argumento:: N dimension de la matriz \00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp slt i32 %0, 2
br i1 %3, label %4, label %6
4: ; preds = %2
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str.5, i64 0, i64 0))
br label %191
6: ; preds = %2
%7 = getelementptr inbounds i8*, i8** %1, i64 1
%8 = load i8*, i8** %7
%9 = tail call i32 @atoi(i8* %8)
%10 = shl i32 %9, 3
%11 = mul i32 %10, %9
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = tail call i64 @malloc(i32 %11)
%15 = inttoptr i64 %14 to double*
%16 = tail call i64 @malloc(i32 %11)
%17 = inttoptr i64 %16 to double*
%18 = tail call i64 @malloc(i32 %11)
%19 = inttoptr i64 %18 to double*
%20 = mul nsw i32 %9, %9
%21 = tail call i64 @calloc(i32 %20, i32 8)
%22 = inttoptr i64 %21 to double*
%23 = tail call i64 @calloc(i32 %20, i32 8)
%24 = inttoptr i64 %23 to double*
%25 = tail call i64 @malloc(i32 %11)
%26 = inttoptr i64 %25 to double*
%27 = icmp sgt i32 %9, 0
br i1 %27, label %30, label %28
28: ; preds = %6
%29 = tail call double (...) @dwalltime()
br label %115
30: ; preds = %6
%31 = zext i32 %9 to i64
%32 = zext i32 %9 to i64
%33 = and i64 %32, 1
%34 = icmp eq i32 %9, 1
%35 = and i64 %32, 4294967294
%36 = icmp eq i64 %33, 0
br label %37
37: ; preds = %71, %30
%38 = phi i64 [ 0, %30 ], [ %72, %71 ]
%39 = mul nsw i64 %38, %31
br i1 %34, label %61, label %40
40: ; preds = %37, %40
%41 = phi i64 [ %58, %40 ], [ 0, %37 ]
%42 = phi i64 [ %59, %40 ], [ 0, %37 ]
%43 = add nuw nsw i64 %41, %39
%44 = getelementptr inbounds double, double* %13, i64 %43
store double 1.000000e+00, double* %44
%45 = mul nsw i64 %41, %31
%46 = add nuw nsw i64 %45, %38
%47 = getelementptr inbounds double, double* %15, i64 %46
store double 1.000000e+00, double* %47
%48 = getelementptr inbounds double, double* %17, i64 %43
store double 1.000000e+00, double* %48
%49 = getelementptr inbounds double, double* %19, i64 %46
store double 1.000000e+00, double* %49
%50 = or i64 %41, 1
%51 = add nuw nsw i64 %50, %39
%52 = getelementptr inbounds double, double* %13, i64 %51
store double 1.000000e+00, double* %52
%53 = mul nsw i64 %50, %31
%54 = add nuw nsw i64 %53, %38
%55 = getelementptr inbounds double, double* %15, i64 %54
store double 1.000000e+00, double* %55
%56 = getelementptr inbounds double, double* %17, i64 %51
store double 1.000000e+00, double* %56
%57 = getelementptr inbounds double, double* %19, i64 %54
store double 1.000000e+00, double* %57
%58 = add nuw nsw i64 %41, 2
%59 = add i64 %42, 2
%60 = icmp eq i64 %59, %35
br i1 %60, label %61, label %40
61: ; preds = %40, %37
%62 = phi i64 [ 0, %37 ], [ %58, %40 ]
br i1 %36, label %71, label %63
63: ; preds = %61
%64 = add nuw nsw i64 %62, %39
%65 = getelementptr inbounds double, double* %13, i64 %64
store double 1.000000e+00, double* %65
%66 = mul nsw i64 %62, %31
%67 = add nuw nsw i64 %66, %38
%68 = getelementptr inbounds double, double* %15, i64 %67
store double 1.000000e+00, double* %68
%69 = getelementptr inbounds double, double* %17, i64 %64
store double 1.000000e+00, double* %69
%70 = getelementptr inbounds double, double* %19, i64 %67
store double 1.000000e+00, double* %70
br label %71
71: ; preds = %61, %63
%72 = add nuw nsw i64 %38, 1
%73 = icmp eq i64 %72, %32
br i1 %73, label %74, label %37
74: ; preds = %71
%75 = tail call double (...) @dwalltime()
br i1 %27, label %76, label %177
76: ; preds = %74
%77 = zext i32 %9 to i64
%78 = zext i32 %9 to i64
br label %79
79: ; preds = %112, %76
%80 = phi i64 [ 0, %76 ], [ %113, %112 ]
%81 = mul nsw i64 %80, %77
br label %82
82: ; preds = %106, %79
%83 = phi i64 [ 0, %79 ], [ %110, %106 ]
%84 = add nuw nsw i64 %83, %81
%85 = getelementptr inbounds double, double* %22, i64 %84
%86 = mul nsw i64 %83, %77
%87 = getelementptr inbounds double, double* %24, i64 %84
br label %88
88: ; preds = %82, %88
%89 = phi i64 [ 0, %82 ], [ %104, %88 ]
%90 = load double, double* %85
%91 = add nuw nsw i64 %89, %81
%92 = getelementptr inbounds double, double* %13, i64 %91
%93 = load double, double* %92
%94 = add nuw nsw i64 %89, %86
%95 = getelementptr inbounds double, double* %15, i64 %94
%96 = load double, double* %95
%97 = tail call double @llvm.fmuladd.f64(double %93, double %96, double %90)
store double %97, double* %85
%98 = load double, double* %87
%99 = getelementptr inbounds double, double* %17, i64 %91
%100 = load double, double* %99
%101 = getelementptr inbounds double, double* %19, i64 %94
%102 = load double, double* %101
%103 = tail call double @llvm.fmuladd.f64(double %100, double %102, double %98)
store double %103, double* %87
%104 = add nuw nsw i64 %89, 1
%105 = icmp eq i64 %104, %78
br i1 %105, label %106, label %88
106: ; preds = %88
%107 = load double, double* %85
%108 = fadd double %103, %107
%109 = getelementptr inbounds double, double* %26, i64 %84
store double %108, double* %109
%110 = add nuw nsw i64 %83, 1
%111 = icmp eq i64 %110, %78
br i1 %111, label %112, label %82
112: ; preds = %106
%113 = add nuw nsw i64 %80, 1
%114 = icmp eq i64 %113, %78
br i1 %114, label %115, label %79
115: ; preds = %112, %28
%116 = phi double [ %29, %28 ], [ %75, %112 ]
%117 = tail call double (...) @dwalltime()
%118 = fsub double %117, %116
%119 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), double %118)
br i1 %27, label %120, label %181
120: ; preds = %115
%121 = shl nuw nsw i32 %9, 1
%122 = sitofp i32 %121 to double
%123 = zext i32 %9 to i64
%124 = zext i32 %9 to i64
%125 = and i64 %124, 1
%126 = icmp eq i32 %9, 1
%127 = and i64 %124, 4294967294
%128 = icmp eq i64 %125, 0
br label %129
129: ; preds = %170, %120
%130 = phi i64 [ 0, %120 ], [ %173, %170 ]
%131 = phi i32 [ 1, %120 ], [ %172, %170 ]
%132 = mul nsw i64 %130, %123
br i1 %126, label %155, label %133
133: ; preds = %129, %149
%134 = phi i64 [ %152, %149 ], [ 0, %129 ]
%135 = phi i32 [ %151, %149 ], [ %131, %129 ]
%136 = phi i64 [ %153, %149 ], [ 0, %129 ]
%137 = icmp eq i32 %135, 0
br i1 %137, label %149, label %138
138: ; preds = %133
%139 = add nuw nsw i64 %134, %132
%140 = getelementptr inbounds double, double* %26, i64 %139
%141 = load double, double* %140
%142 = fcmp oeq double %141, %122
br i1 %142, label %143, label %149
143: ; preds = %138
%144 = or i64 %134, 1
%145 = add nuw nsw i64 %144, %132
%146 = getelementptr inbounds double, double* %26, i64 %145
%147 = load double, double* %146
%148 = fcmp oeq double %147, %122
br label %149
149: ; preds = %133, %143, %138
%150 = phi i1 [ false, %138 ], [ %148, %143 ], [ false, %133 ]
%151 = zext i1 %150 to i32
%152 = add nuw nsw i64 %134, 2
%153 = add i64 %136, 2
%154 = icmp eq i64 %153, %127
br i1 %154, label %155, label %133
155: ; preds = %149, %129
%156 = phi i1 [ undef, %129 ], [ %150, %149 ]
%157 = phi i32 [ undef, %129 ], [ %151, %149 ]
%158 = phi i64 [ 0, %129 ], [ %152, %149 ]
%159 = phi i32 [ %131, %129 ], [ %151, %149 ]
br i1 %128, label %170, label %160
160: ; preds = %155
%161 = icmp eq i32 %159, 0
br i1 %161, label %167, label %162
162: ; preds = %160
%163 = add nuw nsw i64 %158, %132
%164 = getelementptr inbounds double, double* %26, i64 %163
%165 = load double, double* %164
%166 = fcmp oeq double %165, %122
br label %167
167: ; preds = %162, %160
%168 = phi i1 [ false, %160 ], [ %166, %162 ]
%169 = zext i1 %168 to i32
br label %170
170: ; preds = %155, %167
%171 = phi i1 [ %156, %155 ], [ %168, %167 ]
%172 = phi i32 [ %157, %155 ], [ %169, %167 ]
%173 = add nuw nsw i64 %130, 1
%174 = icmp eq i64 %173, %124
br i1 %174, label %175, label %129
175: ; preds = %170
%176 = select i1 %171, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @str.4, i64 0, i64 0), i8* getelementptr inbounds ([45 x i8], [45 x i8]* @str, i64 0, i64 0)
br label %181
177: ; preds = %74
%178 = tail call double (...) @dwalltime()
%179 = fsub double %178, %75
%180 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), double %179)
br label %181
181: ; preds = %175, %115, %177
%182 = phi i8* [ getelementptr inbounds ([46 x i8], [46 x i8]* @str.4, i64 0, i64 0), %177 ], [ getelementptr inbounds ([46 x i8], [46 x i8]* @str.4, i64 0, i64 0), %115 ], [ %176, %175 ]
%183 = tail call i32 @puts(i8* dereferenceable(1) %182)
%184 = tail call i32 @free(double* %13)
%185 = tail call i32 @free(double* %15)
%186 = tail call i32 @free(double* %17)
%187 = tail call i32 @free(double* %19)
%188 = tail call i32 @free(double* %22)
%189 = tail call i32 @free(double* %24)
%190 = tail call i32 @free(double* %26)
br label %191
191: ; preds = %181, %4
ret i32 0
}