double *vectores(double *arr, int row, int col, int c_actual) {
  int i, j;
  int sum_prod_c = 0;
  int sum_prod_p = 0;
  int sum_prod_v = 0;
  double beta = 0;
  double mu, sigma, v_1, acumula;
  int vectorc[4] = {0, 0, 0, 0};
  double vector[4] = {0, 0, 0, 0};
  for (i = 0; i < row - c_actual; i++) {
    vectorc[i] = *(arr + ((i + c_actual) * col) + c_actual);
    sum_prod_c += vectorc[i] * vectorc[i];
    if (i > 0)
      sum_prod_p += vectorc[i] * vectorc[i];
    if (i == 0)
      vector[i] = 1;
    else
      vector[i] = vectorc[i];
    printf(" Vector completo: %d \n", vectorc[i]);
    printf(" Vector V : %f \n", vector[i]);
  }
  mu = sqrt(sum_prod_c);
  sigma = sum_prod_p;
  printf(" MU: %f \n", mu);
  printf(" sigma: %f \n\n", sigma);
  if (sigma == 0 && vectorc[0] >= 0)
    beta = 0;
  else if (sigma == 0 && vectorc[0] < 0)
    beta = -2;
  else if (vectorc[0] <= 0)
    v_1 = vectorc[1] - mu;
  else
    v_1 = -sigma / (vectorc[0] + mu);
  beta = 2 * pow(v_1, 2) / (sigma + pow(v_1, 2));
  for (i = 0; i < row - c_actual; i++) {
    vector[i] = vector[i] / v_1;
    sum_prod_v += vector[i] * vector[i];
    printf(" Vector V de householder : %f \n", vector[i]);
  }
  printf(" \n Beta: %f \n\n", beta);
  printf(" \n V_1: %f \n\n", v_1);
  double I_Bvvt[4][4] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
  for (i = 0; i < row - c_actual; i++) {
    for (j = 0; j < row - c_actual; j++) {
      if (i != j)
        I_Bvvt[i][j] = -1 * (beta * vector[i] * vector[j]);
      else
        I_Bvvt[i][j] = 1 - (beta * vector[i] * vector[j]);
      acumula += ((I_Bvvt[i][j]) * vectorc[j]);
      printf(" I_Bvvt:  %f", I_Bvvt[i][j]);
      printf(" vectorc[j] %d", vectorc[j]);
    }
    *(arr + ((i + c_actual) * col) + c_actual) = acumula;
    printf("MULTIPLICA %f", acumula);
    printf("acaboooooo \n");
    acumula = 0;
  }
  show((double *)I_Bvvt, 4, 4);
  printf("Nuevoooo \n");
  show((double *)arr, 4, 3);
}


x86 assembly (clang, -O0):
<vectores>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    129b <vectores+0x14b>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
movslq -0x20(%rbp),%rax
mov    %ecx,-0x70(%rbp,%rax,4)
movslq -0x20(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%eax
movslq -0x20(%rbp),%rcx
imul   -0x70(%rbp,%rcx,4),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    1221 <vectores+0xd1>
movslq -0x20(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%eax
movslq -0x20(%rbp),%rcx
imul   -0x70(%rbp,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    1245 <vectores+0xf5>
movslq -0x20(%rbp),%rax
movsd  0xdd9(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
jmp    125c <vectores+0x10c>
movslq -0x20(%rbp),%rax
cvtsi2sdl -0x70(%rbp,%rax,4),%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x20(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%esi
lea    0xdb5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0x20(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
lea    0xdb1(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11af <vectores+0x5f>
cvtsi2sdl -0x28(%rbp),%xmm0
call   1070 <sqrt@plt>
movsd  %xmm0,-0x40(%rbp)
cvtsi2sdl -0x2c(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
lea    0xd88(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x48(%rbp),%xmm0
lea    0xd7f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1309 <vectores+0x1b9>
jp     1309 <vectores+0x1b9>
cmpl   $0x0,-0x70(%rbp)
jl     1309 <vectores+0x1b9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1394 <vectores+0x244>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    133d <vectores+0x1ed>
jp     133d <vectores+0x1ed>
cmpl   $0x0,-0x70(%rbp)
jge    133d <vectores+0x1ed>
movsd  0xccd(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    138f <vectores+0x23f>
cmpl   $0x0,-0x70(%rbp)
jg     135b <vectores+0x20b>
cvtsi2sdl -0x6c(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    138a <vectores+0x23a>
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsi2sdl -0x70(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    138f <vectores+0x23f>
jmp    1394 <vectores+0x244>
movsd  -0x50(%rbp),%xmm0
movsd  0xc67(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xc57(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  0xc31(%rip),%xmm1
call   1060 <pow@plt>
movsd  -0x120(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x118(%rbp),%xmm0
ff
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    148a <vectores+0x33a>
movslq -0x20(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
divsd  -0x50(%rbp),%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x20(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x20(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm2
ff ff
cvtsi2sdl -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
movslq -0x20(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
lea    0xbeb(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1403 <vectores+0x2b3>
movsd  -0x38(%rbp),%xmm0
lea    0xbea(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
lea    0xbe6(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1040 <memset@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    168c <vectores+0x53c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    162f <vectores+0x4df>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     154a <vectores+0x3fa>
movsd  -0x38(%rbp),%xmm1
movslq -0x20(%rbp),%rax
mulsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movsd  0xaf2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15ab <vectores+0x45b>
movsd  -0x38(%rbp),%xmm0
movslq -0x20(%rbp),%rax
mulsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xa84(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x20(%rbp),%rcx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rax
cvtsi2sdl -0x70(%rbp,%rax,4),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movslq -0x20(%rbp),%rcx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xa99(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movslq -0x24(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%esi
lea    0xa90(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14e2 <vectores+0x392>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
lea    0xa58(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xa58(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14ca <vectores+0x37a>
lea    -0x110(%rbp),%rdi
mov    $0x4,%edx
mov    %edx,%esi
mov    $0x0,%al
call   1050 <show@plt>
lea    0xa2c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rdi
mov    $0x4,%esi
mov    $0x3,%edx
mov    $0x0,%al
call   1050 <show@plt>
mov    -0x8(%rbp),%rax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vectores>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %esi,%r12d
xorps  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
sub    %ecx,%r12d
xorpd  %xmm1,%xmm1
movslq %ecx,%rbp
movslq %edx,%r13
mov    %r12d,%eax
mov    %rax,0x28(%rsp)
test   %r12d,%r12d
mov    %rbp,0x48(%rsp)
mov    %rdi,0x40(%rsp)
mov    %r13,0x88(%rsp)
jle    1296 <vectores+0x156>
mov    %rdi,%r14
mov    %rbp,%rax
imul   %r13,%rax
lea    (%rdi,%rax,8),%rax
cvttsd2si (%rax,%rbp,8),%esi
mov    %esi,0x50(%rsp)
mov    %esi,%r15d
imul   %esi,%r15d
movabs $0x3ff0000000000000,%rax
mov    %rax,0x60(%rsp)
lea    0xe56(%rip),%rdi
xor    %ebx,%ebx
mov    %esi,0x8(%rsp)
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe59(%rip),%rdi
movsd  0xe1a(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    $0x1,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
je     128c <vectores+0x14c>
mov    %r12d,0x30(%rsp)
lea    0x1(%rbp),%rax
imul   %r13,%rax
add    %rbp,%rax
lea    (%r14,%rax,8),%r12
lea    0x0(,%r13,8),%r13
mov    $0x1,%ebp
xor    %ebx,%ebx
mov    0x28(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12),%xmm0
cvttsd2si %xmm0,%esi
mov    %esi,0x50(%rsp,%rbp,4)
mov    %esi,%eax
imul   %esi,%eax
add    %eax,%r15d
cvttpd2dq %xmm0,%xmm0
add    %eax,%ebx
cvtdq2pd %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movlps %xmm0,0x60(%rsp,%rbp,8)
lea    0xdbf(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xdc8(%rip),%rdi
movaps 0x10(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
add    %r13,%r12
cmp    %rbp,%r14
jne    1230 <vectores+0xf0>
mov    0x30(%rsp),%r12d
mov    0x8(%rsp),%ebp
xorpd  %xmm1,%xmm1
jmp    12a6 <vectores+0x166>
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
xor    %r15d,%r15d
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
ucomisd %xmm1,%xmm0
jb     12ba <vectores+0x17a>
sqrtsd %xmm0,%xmm0
jmp    12bf <vectores+0x17f>
call   1060 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movapd %xmm1,0x10(%rsp)
lea    0xd75(%rip),%rdi
movsd  %xmm0,0x8(%rsp)
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xd6b(%rip),%rdi
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
test   %ebx,%ebx
je     1325 <vectores+0x1e5>
test   %ebp,%ebp
jle    1327 <vectores+0x1e7>
movapd 0xd0c(%rip),%xmm1
movapd 0x10(%rsp),%xmm2
xorpd  %xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  0x8(%rsp),%xmm3
addsd  %xmm0,%xmm3
divsd  %xmm3,%xmm1
jmp    133c <vectores+0x1fc>
jmp    1336 <vectores+0x1f6>
xorps  %xmm1,%xmm1
cvtsi2sdl 0x54(%rsp),%xmm1
subsd  0x8(%rsp),%xmm1
movapd 0x10(%rsp),%xmm2
movapd %xmm1,0x10(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
test   %r12d,%r12d
mov    0x28(%rsp),%rbx
jle    13c5 <vectores+0x285>
movsd  0x20(%rsp),%xmm0
divsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
lea    0xcdd(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
je     13c5 <vectores+0x285>
mov    $0x1,%ebp
lea    0xcc4(%rip),%r14
nopl   0x0(%rax)
movsd  0x60(%rsp,%rbp,8),%xmm0
divsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp,%rbp,8)
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    13a0 <vectores+0x260>
lea    0xcb4(%rip),%rdi
movaps 0x30(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xcb0(%rip),%rdi
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x100(%rsp)
movapd %xmm0,0xf0(%rsp)
movapd %xmm0,0xe0(%rsp)
movapd %xmm0,0xd0(%rsp)
movapd %xmm0,0xc0(%rsp)
movapd %xmm0,0xb0(%rsp)
movapd %xmm0,0xa0(%rsp)
movapd %xmm0,0x90(%rsp)
test   %r12d,%r12d
mov    0x48(%rsp),%rcx
jle    1588 <vectores+0x448>
movapd 0x30(%rsp),%xmm0
xorpd  0xbbc(%rip),%xmm0
movapd %xmm0,0x30(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x80(%rsp)
lea    0x90(%rsp),%r12
lea    0xc23(%rip),%r13
lea    0xc29(%rip),%rbp
xor    %r15d,%r15d
jmp    14df <vectores+0x39f>
cs nopw 0x0(%rax,%rax,1)
mov    0x48(%rsp),%rax
add    %r15,%rax
imul   0x88(%rsp),%rax
mov    0x80(%rsp),%rcx
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
lea    0xbfe(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xc08(%rip),%rdi
call   1030 <puts@plt>
add    $0x1,%r15
add    $0x20,%r12
cmp    %rbx,%r15
je     1588 <vectores+0x448>
movsd  0x60(%rsp,%r15,8),%xmm0
movapd %xmm0,%xmm1
mulsd  0x30(%rsp),%xmm1
movsd  %xmm1,0x20(%rsp)
mulsd  %xmm1,%xmm0
addsd  0xafe(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %r14d,%r14d
jmp    156e <vectores+0x42e>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%r12,%r14,8)
mov    0x50(%rsp,%r14,4),%ebx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x10(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
mov    %r13,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r14
mov    0x28(%rsp),%rbx
cmp    %r14,%rbx
je     1490 <vectores+0x350>
movsd  0x8(%rsp),%xmm0
cmp    %r14,%r15
je     1520 <vectores+0x3e0>
movsd  0x60(%rsp,%r14,8),%xmm0
mulsd  0x20(%rsp),%xmm0
jmp    1520 <vectores+0x3e0>
lea    0x90(%rsp),%rdi
mov    $0x4,%esi
mov    $0x4,%edx
xor    %eax,%eax
call   1050 <show@plt>
lea    0xb1f(%rip),%rdi
call   1030 <puts@plt>
mov    0x40(%rsp),%rdi
mov    $0x4,%esi
mov    $0x3,%edx
xor    %eax,%eax
call   1050 <show@plt>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [23 x i8] c" Vector completo: %d \0A\00"
@.str.1 = [17 x i8] c" Vector V : %f \0A\00"
@.str.2 = [10 x i8] c" MU: %f \0A\00"
@.str.3 = [14 x i8] c" sigma: %f \0A\0A\00"
@.str.4 = [32 x i8] c" Vector V de householder : %f \0A\00"
@.str.5 = [15 x i8] c" \0A Beta: %f \0A\0A\00"
@.str.6 = [14 x i8] c" \0A V_1: %f \0A\0A\00"
@.str.7 = [13 x i8] c" I_Bvvt: %f\00"
@.str.8 = [15 x i8] c" vectorc[j] %d\00"
@.str.9 = [14 x i8] c"MULTIPLICA %f\00"
@str = [10 x i8] c"Nuevoooo \00"
@str.12 = [12 x i8] c"acaboooooo \00"
define double* @vectores(double* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca [4 x i32]
%6 = alloca [4 x double]
%7 = alloca [4 x [4 x double]]
%8 = bitcast [4 x i32]* %5 to i8*
%9 = bitcast [4 x double]* %6 to i8*
%10 = sub i32 %1, %3
%11 = icmp sgt i32 %10, 0
br i1 %11, label %12, label %48
12: ; preds = %4
%13 = sext i32 %3 to i64
%14 = sext i32 %2 to i64
%15 = zext i32 %10 to i64
%16 = mul nsw i64 %13, %14
%17 = getelementptr inbounds double, double* %0, i64 %16
%18 = getelementptr inbounds double, double* %17, i64 %13
%19 = load double, double* %18
%20 = fptosi double %19 to i32
%21 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
store i32 %20, i32* %21
%22 = mul nsw i32 %20, %20
%23 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 0
store double 1.000000e+00, double* %23
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 %20)
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), double 1.000000e+00)
%26 = icmp eq i32 %10, 1
br i1 %26, label %48, label %27
27: ; preds = %12
%28 = getelementptr inbounds double, double* %0, i64 %13
br label %29
29: ; preds = %27, %29
%30 = phi i64 [ 1, %27 ], [ %46, %29 ]
%31 = phi i32 [ 0, %27 ], [ %41, %29 ]
%32 = phi i32 [ %22, %27 ], [ %40, %29 ]
%33 = add nsw i64 %30, %13
%34 = mul nsw i64 %33, %14
%35 = getelementptr inbounds double, double* %28, i64 %34
%36 = load double, double* %35
%37 = fptosi double %36 to i32
%38 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 %30
store i32 %37, i32* %38
%39 = mul nsw i32 %37, %37
%40 = add nuw nsw i32 %39, %32
%41 = add nuw nsw i32 %39, %31
%42 = sitofp i32 %37 to double
%43 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %30
store double %42, double* %43
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 %37)
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), double %42)
%46 = add nuw nsw i64 %30, 1
%47 = icmp eq i64 %46, %15
br i1 %47, label %48, label %29
48: ; preds = %29, %12, %4
%49 = phi double [ 0.000000e+00, %4 ], [ 1.000000e+00, %12 ], [ 1.000000e+00, %29 ]
%50 = phi i32 [ 0, %4 ], [ %20, %12 ], [ %20, %29 ]
%51 = phi i32 [ 0, %4 ], [ %22, %12 ], [ %40, %29 ]
%52 = phi i32 [ 0, %4 ], [ 0, %12 ], [ %41, %29 ]
%53 = sitofp i32 %51 to double
%54 = tail call double @sqrt(double %53)
%55 = sitofp i32 %52 to double
%56 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), double %54)
%57 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), double %55)
%58 = icmp eq i32 %52, 0
br i1 %58, label %71, label %59
59: ; preds = %48
%60 = icmp slt i32 %50, 1
br i1 %60, label %61, label %66
61: ; preds = %59
%62 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 1
%63 = load i32, i32* %62
%64 = sitofp i32 %63 to double
%65 = fsub double %64, %54
br label %71
66: ; preds = %59
%67 = fneg double %55
%68 = sitofp i32 %50 to double
%69 = fadd double %54, %68
%70 = fdiv double %67, %69
br label %71
71: ; preds = %48, %66, %61
%72 = phi double [ %65, %61 ], [ %70, %66 ], [ undef, %48 ]
%73 = fmul double %72, %72
%74 = fmul double %73, 2.000000e+00
%75 = fadd double %73, %55
%76 = fdiv double %74, %75
br i1 %11, label %77, label %92
77: ; preds = %71
%78 = zext i32 %10 to i64
%79 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 0
%80 = fdiv double %49, %72
store double %80, double* %79
%81 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), double %80)
%82 = icmp eq i32 %10, 1
br i1 %82, label %92, label %83
83: ; preds = %77, %83
%84 = phi i64 [ %90, %83 ], [ 1, %77 ]
%85 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %84
%86 = load double, double* %85
%87 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %84
%88 = fdiv double %86, %72
store double %88, double* %87
%89 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), double %88)
%90 = add nuw nsw i64 %84, 1
%91 = icmp eq i64 %90, %78
br i1 %91, label %92, label %83
92: ; preds = %83, %77, %71
%93 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %76)
%94 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.6, i64 0, i64 0), double %72)
%95 = bitcast [4 x [4 x double]]* %7 to i8*
br i1 %11, label %96, label %136
96: ; preds = %92
%97 = fneg double %76
%98 = sext i32 %3 to i64
%99 = sext i32 %2 to i64
%100 = zext i32 %10 to i64
%101 = getelementptr inbounds double, double* %0, i64 %98
br label %102
102: ; preds = %128, %96
%103 = phi i64 [ 0, %96 ], [ %134, %128 ]
%104 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %103
%105 = load double, double* %104
%106 = fmul double %105, %97
%107 = fmul double %105, %97
%108 = tail call double @llvm.fmuladd.f64(double %107, double %105, double 1.000000e+00)
br label %109
109: ; preds = %102, %117
%110 = phi i64 [ 0, %102 ], [ %126, %117 ]
%111 = phi double [ 0.000000e+00, %102 ], [ %123, %117 ]
%112 = icmp eq i64 %103, %110
br i1 %112, label %117, label %113
113: ; preds = %109
%114 = getelementptr inbounds [4 x double], [4 x double]* %6, i64 0, i64 %110
%115 = load double, double* %114
%116 = fmul double %106, %115
br label %117
117: ; preds = %109, %113
%118 = phi double [ %116, %113 ], [ %108, %109 ]
%119 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %7, i64 0, i64 %103, i64 %110
store double %118, double* %119
%120 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 %110
%121 = load i32, i32* %120
%122 = sitofp i32 %121 to double
%123 = tail call double @llvm.fmuladd.f64(double %118, double %122, double %111)
%124 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i64 0, i64 0), double %118)
%125 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), i32 %121)
%126 = add nuw nsw i64 %110, 1
%127 = icmp eq i64 %126, %100
br i1 %127, label %128, label %109
128: ; preds = %117
%129 = add nsw i64 %103, %98
%130 = mul nsw i64 %129, %99
%131 = getelementptr inbounds double, double* %101, i64 %130
store double %123, double* %131
%132 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.9, i64 0, i64 0), double %123)
%133 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.12, i64 0, i64 0))
%134 = add nuw nsw i64 %103, 1
%135 = icmp eq i64 %134, %100
br i1 %135, label %136, label %102
136: ; preds = %128, %92
%137 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %7, i64 0, i64 0, i64 0
%138 = call i32 (double*, i32, i32, ...) bitcast (i32 (...)* @show to i32 (double*, i32, i32, ...)*)(double* %137, i32 4, i32 4)
%139 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
%140 = call i32 (double*, i32, i32, ...) bitcast (i32 (...)* @show to i32 (double*, i32, i32, ...)*)(double* %0, i32 4, i32 3)
ret double* undef
}