int lu_decomposition(double **a, int n, int *index, int *sign) {
  int i, imax = 0, j, k;
  double big, sum, temp;
  double *v;
  v = (double *)Malloc(
      __func__,
      "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
      "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/statistic.c",
      390, (n * sizeof(double)));
  *sign = 1;
  for (i = 0; i < n; i++) {
    big = 0;
    for (j = 0; j < n; j++)
      if ((temp = fabs(a[i][j])) > big)
        big = temp;
    if ((((big) != (big)) || ((0.) != (0.))
             ? (((big) != (big)) && ((0.) != (0.)) ? 1 : 0)
             : !(big < 0. || 0. < big)))
      return 0;
    v[i] = 1 / big;
  }
  for (j = 0; j < n; j++) {
    for (i = 0; i < j; i++) {
      sum = a[i][j];
      for (k = 0; k < i; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
    }
    big = 0;
    for (i = j; i < n; i++) {
      sum = a[i][j];
      for (k = 0; k < j; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
      if ((temp = v[i] * fabs(sum)) >= big) {
        big = temp;
        imax = i;
      }
    }
    if (j != imax) {
      for (k = 0; k < n; k++) {
        temp = a[imax][k];
        a[imax][k] = a[j][k];
        a[j][k] = temp;
      }
      *sign = -*sign;
      v[imax] = v[j];
    }
    index[j] = imax;
    if ((((a[j][j]) != (a[j][j])) || ((0.) != (0.))
             ? (((a[j][j]) != (a[j][j])) && ((0.) != (0.)) ? 1 : 0)
             : !(a[j][j] < 0. || 0. < a[j][j])))
      return 0;
    if (j != n) {
      temp = 1 / a[j][j];
      for (i = j + 1; i < n; i++)
        a[i][j] *= temp;
    }
  }
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/statistic.c",
       448, (v));
  return 1;
}


x86 assembly (clang, -O0):
<lu_decomposition>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
lea    0xed3(%rip),%rdi
lea    0xedd(%rip),%rsi
mov    $0x186,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a2 <lu_decomposition+0x182>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11eb <lu_decomposition+0xcb>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe56(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
ucomisd -0x40(%rbp),%xmm0
jbe    11d8 <lu_decomposition+0xb8>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11dd <lu_decomposition+0xbd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1192 <lu_decomposition+0x72>
movsd  -0x40(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jne    1206 <lu_decomposition+0xe6>
jp     1206 <lu_decomposition+0xe6>
jmp    124e <lu_decomposition+0x12e>
movsd  -0x40(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jne    1221 <lu_decomposition+0x101>
jp     1221 <lu_decomposition+0x101>
jmp    123f <lu_decomposition+0x11f>
xor    %eax,%eax
test   $0x1,%al
jne    1230 <lu_decomposition+0x110>
jmp    123f <lu_decomposition+0x11f>
mov    $0x1,%al
test   $0x1,%al
jne    126e <lu_decomposition+0x14e>
jmp    127a <lu_decomposition+0x15a>
xor    %eax,%eax
test   $0x1,%al
jne    126e <lu_decomposition+0x14e>
jmp    127a <lu_decomposition+0x15a>
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
ja     127a <lu_decomposition+0x15a>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     127a <lu_decomposition+0x15a>
movl   $0x0,-0x4(%rbp)
jmp    16f1 <lu_decomposition+0x5d1>
movsd  0xd7e(%rip),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1177 <lu_decomposition+0x57>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16cc <lu_decomposition+0x5ac>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    137e <lu_decomposition+0x25e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1356 <lu_decomposition+0x236>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e9 <lu_decomposition+0x1c9>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12bc <lu_decomposition+0x19c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1494 <lu_decomposition+0x374>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1426 <lu_decomposition+0x306>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13b9 <lu_decomposition+0x299>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0xbb7(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
ucomisd -0x40(%rbp),%xmm0
jb     1481 <lu_decomposition+0x361>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1486 <lu_decomposition+0x366>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138c <lu_decomposition+0x26c>
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1547 <lu_decomposition+0x427>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    151f <lu_decomposition+0x3ff>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14a7 <lu_decomposition+0x387>
mov    -0x28(%rbp),%rax
xor    %ecx,%ecx
sub    (%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1590 <lu_decomposition+0x470>
jp     1590 <lu_decomposition+0x470>
jmp    15f8 <lu_decomposition+0x4d8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15cb <lu_decomposition+0x4ab>
jp     15cb <lu_decomposition+0x4ab>
jmp    15e9 <lu_decomposition+0x4c9>
xor    %eax,%eax
test   $0x1,%al
jne    15da <lu_decomposition+0x4ba>
jmp    15e9 <lu_decomposition+0x4c9>
mov    $0x1,%al
test   $0x1,%al
jne    1638 <lu_decomposition+0x518>
jmp    1644 <lu_decomposition+0x524>
xor    %eax,%eax
test   $0x1,%al
jne    1638 <lu_decomposition+0x518>
jmp    1644 <lu_decomposition+0x524>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
ja     1644 <lu_decomposition+0x524>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     1644 <lu_decomposition+0x524>
movl   $0x0,-0x4(%rbp)
jmp    16f1 <lu_decomposition+0x5d1>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     16b9 <lu_decomposition+0x599>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  0x998(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16b4 <lu_decomposition+0x594>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    167b <lu_decomposition+0x55b>
jmp    16b9 <lu_decomposition+0x599>
jmp    16be <lu_decomposition+0x59e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a9 <lu_decomposition+0x189>
mov    -0x58(%rbp),%rcx
lea    0x949(%rip),%rdi
lea    0x953(%rip),%rsi
mov    $0x1c0,%edx
mov    $0x0,%al
call   1040 <Free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu_decomposition>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %rdx,0x40(%rsp)
mov    %rdi,%r15
mov    %esi,0x4(%rsp)
movslq %esi,%rbp
lea    0x0(,%rbp,8),%rcx
lea    0xec9(%rip),%rdi
lea    0xed3(%rip),%rsi
mov    $0x186,%edx
xor    %eax,%eax
call   1030 <Malloc@plt>
movslq %eax,%rcx
mov    %rbx,0x30(%rsp)
movl   $0x1,(%rbx)
mov    %rbp,0x38(%rsp)
test   %ebp,%ebp
jle    1694 <lu_decomposition+0x574>
mov    0x4(%rsp),%r14d
lea    -0x1(%r14),%r8
mov    %r14d,%esi
and    $0x3,%esi
mov    %r14d,%edi
and    $0xfffffffc,%edi
xor    %ebp,%ebp
xorpd  %xmm2,%xmm2
movsd  0xe6f(%rip),%xmm8
movapd 0xe57(%rip),%xmm1
movapd 0xe4f(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdx
cmp    $0x3,%r8
jae    11e0 <lu_decomposition+0xc0>
xor    %eax,%eax
xorpd  %xmm4,%xmm4
jmp    1234 <lu_decomposition+0x114>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm5,%xmm5
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm6
movsd  0x8(%rdx,%rax,8),%xmm7
movsd  0x10(%rdx,%rax,8),%xmm0
movsd  0x18(%rdx,%rax,8),%xmm4
andpd  %xmm3,%xmm6
maxsd  %xmm5,%xmm6
andpd  %xmm3,%xmm7
maxsd  %xmm6,%xmm7
andpd  %xmm3,%xmm0
maxsd  %xmm7,%xmm0
andpd  %xmm3,%xmm4
maxsd  %xmm0,%xmm4
add    $0x4,%rax
movapd %xmm4,%xmm5
cmp    %rax,%rdi
jne    11f0 <lu_decomposition+0xd0>
movapd %xmm4,%xmm5
test   %rsi,%rsi
je     126a <lu_decomposition+0x14a>
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm5
andpd  %xmm1,%xmm5
maxsd  %xmm4,%xmm5
add    $0x1,%rdx
movapd %xmm5,%xmm4
cmp    %rdx,%rsi
jne    1250 <lu_decomposition+0x130>
ucomisd %xmm2,%xmm5
jne    1276 <lu_decomposition+0x156>
jnp    16b5 <lu_decomposition+0x595>
movapd %xmm8,%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %r14,%rbp
jne    11c0 <lu_decomposition+0xa0>
cmpl   $0x0,0x4(%rsp)
jle    1694 <lu_decomposition+0x574>
mov    %r14d,%eax
and    $0xfffffffc,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x10(%rsp)
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x8(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x28(%rsp)
xor    %r8d,%r8d
xorpd  %xmm2,%xmm2
mov    %r14,%r12
mov    %r15,%r9
xor    %r13d,%r13d
jmp    1304 <lu_decomposition+0x1e4>
nop
add    $0x8,%r9
add    $0xffffffffffffffff,%r12
mov    %rax,%r8
cmp    %r14,%rax
je     1694 <lu_decomposition+0x574>
test   %r8,%r8
je     13b0 <lu_decomposition+0x290>
xor    %edx,%edx
jmp    1334 <lu_decomposition+0x214>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,0x0(%rbp,%r8,8)
add    $0x1,%rdx
cmp    %r8,%rdx
je     13b0 <lu_decomposition+0x290>
mov    (%r15,%rdx,8),%rbp
movsd  0x0(%rbp,%r8,8),%xmm3
test   %rdx,%rdx
je     1320 <lu_decomposition+0x200>
cmp    $0x1,%rdx
jne    1350 <lu_decomposition+0x230>
xor    %esi,%esi
jmp    1392 <lu_decomposition+0x272>
xchg   %ax,%ax
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  0x8(%rbp,%rsi,8),%xmm4
mov    (%r15,%rsi,8),%rdi
mov    0x8(%r15,%rsi,8),%rbx
mulsd  (%rdi,%r8,8),%xmm0
mulsd  (%rbx,%r8,8),%xmm4
subsd  %xmm0,%xmm3
subsd  %xmm4,%xmm3
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1360 <lu_decomposition+0x240>
test   $0x1,%dl
je     1320 <lu_decomposition+0x200>
movsd  0x0(%rbp,%rsi,8),%xmm0
mov    (%r15,%rsi,8),%rax
mulsd  (%rax,%r8,8),%xmm0
subsd  %xmm0,%xmm3
jmp    1320 <lu_decomposition+0x200>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xorpd  %xmm3,%xmm3
mov    %r8,%rdx
jmp    1401 <lu_decomposition+0x2e1>
movsd  %xmm4,(%rsi,%r8,8)
andpd  %xmm1,%xmm4
mulsd  (%rcx,%rdx,8),%xmm4
ucomisd %xmm3,%xmm4
cmovae %edx,%r13d
movapd %xmm3,%xmm0
cmpnlesd %xmm4,%xmm0
movapd %xmm0,%xmm5
andnpd %xmm4,%xmm5
andpd  %xmm3,%xmm0
orpd   %xmm5,%xmm0
add    $0x1,%rdx
movapd %xmm0,%xmm3
cmp    %r14,%rdx
je     1480 <lu_decomposition+0x360>
mov    (%r15,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm4
test   %r8,%r8
je     13c0 <lu_decomposition+0x2a0>
xor    %eax,%eax
cmp    $0x1,%r8
je     1451 <lu_decomposition+0x331>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  0x8(%rsi,%rax,8),%xmm5
mov    (%r15,%rax,8),%rdi
mov    0x8(%r15,%rax,8),%rbx
mulsd  (%rdi,%r8,8),%xmm0
mulsd  (%rbx,%r8,8),%xmm5
subsd  %xmm0,%xmm4
subsd  %xmm5,%xmm4
add    $0x2,%rax
cmp    %rax,%rbp
jne    1420 <lu_decomposition+0x300>
test   $0x1,%r8b
je     13c0 <lu_decomposition+0x2a0>
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rax,8),%rax
mulsd  (%rax,%r8,8),%xmm0
subsd  %xmm0,%xmm4
jmp    13c0 <lu_decomposition+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13d,%eax
cmp    %rax,%r8
je     1622 <lu_decomposition+0x502>
movslq %r13d,%rsi
mov    (%r15,%rsi,8),%r10
mov    (%r15,%r8,8),%r11
cmpl   $0x4,0x4(%rsp)
jb     14b8 <lu_decomposition+0x398>
lea    (%r11,%r14,8),%rax
cmp    %rax,%r10
jae    1532 <lu_decomposition+0x412>
lea    (%r10,%r14,8),%rax
cmp    %rax,%r11
jae    1532 <lu_decomposition+0x412>
xor    %edx,%edx
mov    %rdx,%rax
test   $0x1,%r14b
je     14e2 <lu_decomposition+0x3c2>
movsd  (%r10,%rdx,8),%xmm0
movsd  (%r11,%rdx,8),%xmm3
movsd  %xmm3,(%r10,%rdx,8)
movsd  %xmm0,(%r11,%rdx,8)
mov    %rdx,%rax
or     $0x1,%rax
not    %rdx
cmp    0x28(%rsp),%rdx
je     1610 <lu_decomposition+0x4f0>
movsd  (%r10,%rax,8),%xmm0
movsd  (%r11,%rax,8),%xmm3
movsd  %xmm3,(%r10,%rax,8)
movsd  %xmm0,(%r11,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm0
movsd  0x8(%r11,%rax,8),%xmm3
movsd  %xmm3,0x8(%r10,%rax,8)
movsd  %xmm0,0x8(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    14f0 <lu_decomposition+0x3d0>
jmp    1610 <lu_decomposition+0x4f0>
cmpq   $0x0,0x20(%rsp)
je     1682 <lu_decomposition+0x562>
mov    0x8(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r10,%rdx,8),%xmm0
movups 0x10(%r10,%rdx,8),%xmm3
movups (%r11,%rdx,8),%xmm4
movups 0x10(%r11,%rdx,8),%xmm5
movups %xmm4,(%r10,%rdx,8)
movups %xmm5,0x10(%r10,%rdx,8)
movups %xmm0,(%r11,%rdx,8)
movups %xmm3,0x10(%r11,%rdx,8)
movupd 0x20(%r10,%rdx,8),%xmm0
movupd 0x30(%r10,%rdx,8),%xmm3
movupd 0x20(%r11,%rdx,8),%xmm4
movupd 0x30(%r11,%rdx,8),%xmm5
movupd %xmm4,0x20(%r10,%rdx,8)
movupd %xmm5,0x30(%r10,%rdx,8)
movupd %xmm0,0x20(%r11,%rdx,8)
movupd %xmm3,0x30(%r11,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1550 <lu_decomposition+0x430>
testb  $0x1,0x18(%rsp)
je     15f9 <lu_decomposition+0x4d9>
movupd (%r10,%rdx,8),%xmm0
movupd 0x10(%r10,%rdx,8),%xmm3
movupd (%r11,%rdx,8),%xmm4
movupd 0x10(%r11,%rdx,8),%xmm5
movupd %xmm4,(%r10,%rdx,8)
movupd %xmm5,0x10(%r10,%rdx,8)
movupd %xmm0,(%r11,%rdx,8)
movupd %xmm3,0x10(%r11,%rdx,8)
mov    0x10(%rsp),%rax
mov    %rax,%rdx
cmp    %r14,%rax
jne    14ba <lu_decomposition+0x39a>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
negl   (%rax)
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
mov    0x40(%rsp),%rax
mov    %r13d,(%rax,%r8,4)
mov    (%r15,%r8,8),%rax
movsd  (%rax,%r8,8),%xmm4
ucomisd %xmm2,%xmm4
jne    163d <lu_decomposition+0x51d>
jnp    16b5 <lu_decomposition+0x595>
lea    0x1(%r8),%rax
cmp    0x38(%rsp),%rax
jge    12f0 <lu_decomposition+0x1d0>
movapd %xmm8,%xmm3
divsd  %xmm4,%xmm3
mov    $0x1,%edx
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%r8,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1660 <lu_decomposition+0x540>
jmp    12f0 <lu_decomposition+0x1d0>
xor    %edx,%edx
testb  $0x1,0x18(%rsp)
jne    15c5 <lu_decomposition+0x4a5>
jmp    15f9 <lu_decomposition+0x4d9>
lea    0x97d(%rip),%rdi
lea    0x987(%rip),%rsi
mov    $0x1c0,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    $0x1,%eax
jmp    16b7 <lu_decomposition+0x597>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__func__.lu_decomposition = [17 x i8] c"lu_decomposition\00"
@.str = [133 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/statistic.c\00"
define i32 @lu_decomposition(double** %0, i32 %1, i32* %2, i32* %3) {
%5 = alloca i32
%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 double
%15 = alloca double
%16 = alloca double
%17 = alloca 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* %11
%18 = load i32, i32* %7
%19 = sext i32 %18 to i64
%20 = mul i64 %19, 8
%21 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__func__.lu_decomposition, i64 0, i64 0), i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 390, i64 %20)
%22 = sext i32 %21 to i64
%23 = inttoptr i64 %22 to double*
store double* %23, double** %17
%24 = load i32*, i32** %9
store i32 1, i32* %24
store i32 0, i32* %10
br label %25
25: ; preds = %78, %4
%26 = load i32, i32* %10
%27 = load i32, i32* %7
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %81
29: ; preds = %25
store double 0.000000e+00, double* %14
store i32 0, i32* %12
br label %30
30: ; preds = %50, %29
%31 = load i32, i32* %12
%32 = load i32, i32* %7
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %53
34: ; preds = %30
%35 = load double**, double*** %6
%36 = load i32, i32* %10
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double*, double** %35, i64 %37
%39 = load double*, double** %38
%40 = load i32, i32* %12
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %39, i64 %41
%43 = load double, double* %42
%44 = call double @llvm.fabs.f64(double %43)
store double %44, double* %16
%45 = load double, double* %14
%46 = fcmp ogt double %44, %45
br i1 %46, label %47, label %49
47: ; preds = %34
%48 = load double, double* %16
store double %48, double* %14
br label %49
49: ; preds = %47, %34
br label %50
50: ; preds = %49
%51 = load i32, i32* %12
%52 = add nsw i32 %51, 1
store i32 %52, i32* %12
br label %30
53: ; preds = %30
%54 = load double, double* %14
%55 = load double, double* %14
%56 = fcmp une double %54, %55
br i1 %56, label %57, label %64
57: ; preds = %53
%58 = load double, double* %14
%59 = load double, double* %14
%60 = fcmp une double %58, %59
br i1 %60, label %61, label %63
61: ; preds = %57
br i1 false, label %62, label %63
62: ; preds = %61
br i1 true, label %70, label %71
63: ; preds = %61, %57
br i1 false, label %70, label %71
64: ; preds = %53
%65 = load double, double* %14
%66 = fcmp olt double %65, 0.000000e+00
br i1 %66, label %71, label %67
67: ; preds = %64
%68 = load double, double* %14
%69 = fcmp olt double 0.000000e+00, %68
br i1 %69, label %71, label %70
70: ; preds = %67, %63, %62
store i32 0, i32* %5
br label %392
71: ; preds = %67, %64, %63, %62
%72 = load double, double* %14
%73 = fdiv double 1.000000e+00, %72
%74 = load double*, double** %17
%75 = load i32, i32* %10
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
store double %73, double* %77
br label %78
78: ; preds = %71
%79 = load i32, i32* %10
%80 = add nsw i32 %79, 1
store i32 %80, i32* %10
br label %25
81: ; preds = %25
store i32 0, i32* %12
br label %82
82: ; preds = %386, %81
%83 = load i32, i32* %12
%84 = load i32, i32* %7
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %389
86: ; preds = %82
store i32 0, i32* %10
br label %87
87: ; preds = %140, %86
%88 = load i32, i32* %10
%89 = load i32, i32* %12
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %143
91: ; preds = %87
%92 = load double**, double*** %6
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double*, double** %92, i64 %94
%96 = load double*, double** %95
%97 = load i32, i32* %12
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
%100 = load double, double* %99
store double %100, double* %15
store i32 0, i32* %13
br label %101
101: ; preds = %127, %91
%102 = load i32, i32* %13
%103 = load i32, i32* %10
%104 = icmp slt i32 %102, %103
br i1 %104, label %105, label %130
105: ; preds = %101
%106 = load double**, double*** %6
%107 = load i32, i32* %10
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double*, double** %106, i64 %108
%110 = load double*, double** %109
%111 = load i32, i32* %13
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
%114 = load double, double* %113
%115 = load double**, double*** %6
%116 = load i32, i32* %13
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double*, double** %115, i64 %117
%119 = load double*, double** %118
%120 = load i32, i32* %12
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %119, i64 %121
%123 = load double, double* %122
%124 = load double, double* %15
%125 = fneg double %114
%126 = call double @llvm.fmuladd.f64(double %125, double %123, double %124)
store double %126, double* %15
br label %127
127: ; preds = %105
%128 = load i32, i32* %13
%129 = add nsw i32 %128, 1
store i32 %129, i32* %13
br label %101
130: ; preds = %101
%131 = load double, double* %15
%132 = load double**, double*** %6
%133 = load i32, i32* %10
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double*, double** %132, i64 %134
%136 = load double*, double** %135
%137 = load i32, i32* %12
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
store double %131, double* %139
br label %140
140: ; preds = %130
%141 = load i32, i32* %10
%142 = add nsw i32 %141, 1
store i32 %142, i32* %10
br label %87
143: ; preds = %87
store double 0.000000e+00, double* %14
%144 = load i32, i32* %12
store i32 %144, i32* %10
br label %145
145: ; preds = %212, %143
%146 = load i32, i32* %10
%147 = load i32, i32* %7
%148 = icmp slt i32 %146, %147
br i1 %148, label %149, label %215
149: ; preds = %145
%150 = load double**, double*** %6
%151 = load i32, i32* %10
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double*, double** %150, i64 %152
%154 = load double*, double** %153
%155 = load i32, i32* %12
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
%158 = load double, double* %157
store double %158, double* %15
store i32 0, i32* %13
br label %159
159: ; preds = %185, %149
%160 = load i32, i32* %13
%161 = load i32, i32* %12
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %188
163: ; preds = %159
%164 = load double**, double*** %6
%165 = load i32, i32* %10
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds double*, double** %164, i64 %166
%168 = load double*, double** %167
%169 = load i32, i32* %13
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = load double, double* %171
%173 = load double**, double*** %6
%174 = load i32, i32* %13
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double*, double** %173, i64 %175
%177 = load double*, double** %176
%178 = load i32, i32* %12
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = load double, double* %15
%183 = fneg double %172
%184 = call double @llvm.fmuladd.f64(double %183, double %181, double %182)
store double %184, double* %15
br label %185
185: ; preds = %163
%186 = load i32, i32* %13
%187 = add nsw i32 %186, 1
store i32 %187, i32* %13
br label %159
188: ; preds = %159
%189 = load double, double* %15
%190 = load double**, double*** %6
%191 = load i32, i32* %10
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double*, double** %190, i64 %192
%194 = load double*, double** %193
%195 = load i32, i32* %12
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
store double %189, double* %197
%198 = load double*, double** %17
%199 = load i32, i32* %10
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %198, i64 %200
%202 = load double, double* %201
%203 = load double, double* %15
%204 = call double @llvm.fabs.f64(double %203)
%205 = fmul double %202, %204
store double %205, double* %16
%206 = load double, double* %14
%207 = fcmp oge double %205, %206
br i1 %207, label %208, label %211
208: ; preds = %188
%209 = load double, double* %16
store double %209, double* %14
%210 = load i32, i32* %10
store i32 %210, i32* %11
br label %211
211: ; preds = %208, %188
br label %212
212: ; preds = %211
%213 = load i32, i32* %10
%214 = add nsw i32 %213, 1
store i32 %214, i32* %10
br label %145
215: ; preds = %145
%216 = load i32, i32* %12
%217 = load i32, i32* %11
%218 = icmp ne i32 %216, %217
br i1 %218, label %219, label %277
219: ; preds = %215
store i32 0, i32* %13
br label %220
220: ; preds = %260, %219
%221 = load i32, i32* %13
%222 = load i32, i32* %7
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %263
224: ; preds = %220
%225 = load double**, double*** %6
%226 = load i32, i32* %11
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double*, double** %225, i64 %227
%229 = load double*, double** %228
%230 = load i32, i32* %13
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
%233 = load double, double* %232
store double %233, double* %16
%234 = load double**, double*** %6
%235 = load i32, i32* %12
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double*, double** %234, i64 %236
%238 = load double*, double** %237
%239 = load i32, i32* %13
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load double**, double*** %6
%244 = load i32, i32* %11
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double*, double** %243, i64 %245
%247 = load double*, double** %246
%248 = load i32, i32* %13
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %247, i64 %249
store double %242, double* %250
%251 = load double, double* %16
%252 = load double**, double*** %6
%253 = load i32, i32* %12
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double*, double** %252, i64 %254
%256 = load double*, double** %255
%257 = load i32, i32* %13
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %256, i64 %258
store double %251, double* %259
br label %260
260: ; preds = %224
%261 = load i32, i32* %13
%262 = add nsw i32 %261, 1
store i32 %262, i32* %13
br label %220
263: ; preds = %220
%264 = load i32*, i32** %9
%265 = load i32, i32* %264
%266 = sub nsw i32 0, %265
%267 = load i32*, i32** %9
store i32 %266, i32* %267
%268 = load double*, double** %17
%269 = load i32, i32* %12
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %268, i64 %270
%272 = load double, double* %271
%273 = load double*, double** %17
%274 = load i32, i32* %11
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
store double %272, double* %276
br label %277
277: ; preds = %263, %215
%278 = load i32, i32* %11
%279 = load i32*, i32** %8
%280 = load i32, i32* %12
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i32, i32* %279, i64 %281
store i32 %278, i32* %282
%283 = load double**, double*** %6
%284 = load i32, i32* %12
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double*, double** %283, i64 %285
%287 = load double*, double** %286
%288 = load i32, i32* %12
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = load double**, double*** %6
%293 = load i32, i32* %12
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double*, double** %292, i64 %294
%296 = load double*, double** %295
%297 = load i32, i32* %12
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %296, i64 %298
%300 = load double, double* %299
%301 = fcmp une double %291, %300
br i1 %301, label %302, label %325
302: ; preds = %277
%303 = load double**, double*** %6
%304 = load i32, i32* %12
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds double*, double** %303, i64 %305
%307 = load double*, double** %306
%308 = load i32, i32* %12
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = load double**, double*** %6
%313 = load i32, i32* %12
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double*, double** %312, i64 %314
%316 = load double*, double** %315
%317 = load i32, i32* %12
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = fcmp une double %311, %320
br i1 %321, label %322, label %324
322: ; preds = %302
br i1 false, label %323, label %324
323: ; preds = %322
br i1 true, label %347, label %348
324: ; preds = %322, %302
br i1 false, label %347, label %348
325: ; preds = %277
%326 = load double**, double*** %6
%327 = load i32, i32* %12
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double*, double** %326, i64 %328
%330 = load double*, double** %329
%331 = load i32, i32* %12
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %330, i64 %332
%334 = load double, double* %333
%335 = fcmp olt double %334, 0.000000e+00
br i1 %335, label %348, label %336
336: ; preds = %325
%337 = load double**, double*** %6
%338 = load i32, i32* %12
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double*, double** %337, i64 %339
%341 = load double*, double** %340
%342 = load i32, i32* %12
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
%345 = load double, double* %344
%346 = fcmp olt double 0.000000e+00, %345
br i1 %346, label %348, label %347
347: ; preds = %336, %324, %323
store i32 0, i32* %5
br label %392
348: ; preds = %336, %325, %324, %323
%349 = load i32, i32* %12
%350 = load i32, i32* %7
%351 = icmp ne i32 %349, %350
br i1 %351, label %352, label %385
352: ; preds = %348
%353 = load double**, double*** %6
%354 = load i32, i32* %12
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double*, double** %353, i64 %355
%357 = load double*, double** %356
%358 = load i32, i32* %12
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = fdiv double 1.000000e+00, %361
store double %362, double* %16
%363 = load i32, i32* %12
%364 = add nsw i32 %363, 1
store i32 %364, i32* %10
br label %365
365: ; preds = %381, %352
%366 = load i32, i32* %10
%367 = load i32, i32* %7
%368 = icmp slt i32 %366, %367
br i1 %368, label %369, label %384
369: ; preds = %365
%370 = load double, double* %16
%371 = load double**, double*** %6
%372 = load i32, i32* %10
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double*, double** %371, i64 %373
%375 = load double*, double** %374
%376 = load i32, i32* %12
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %375, i64 %377
%379 = load double, double* %378
%380 = fmul double %379, %370
store double %380, double* %378
br label %381
381: ; preds = %369
%382 = load i32, i32* %10
%383 = add nsw i32 %382, 1
store i32 %383, i32* %10
br label %365
384: ; preds = %365
br label %385
385: ; preds = %384, %348
br label %386
386: ; preds = %385
%387 = load i32, i32* %12
%388 = add nsw i32 %387, 1
store i32 %388, i32* %12
br label %82
389: ; preds = %82
%390 = load double*, double** %17
%391 = call i32 (i8*, i8*, i32, double*, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double*, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__func__.lu_decomposition, i64 0, i64 0), i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 448, double* %390)
store i32 1, i32* %5
br label %392
392: ; preds = %389, %347, %70
%393 = load i32, i32* %5
ret i32 %393
}

LLVM IR (-O2):
@__func__.lu_decomposition = [17 x i8] c"lu_decomposition\00"
@.str = [133 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/statistic.c\00"
define i32 @lu_decomposition(double** nocapture %0, i32 %1, i32* nocapture writeonly %2, i32* nocapture %3) {
%5 = sext i32 %1 to i64
%6 = shl nsw i64 %5, 3
%7 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__func__.lu_decomposition, i64 0, i64 0), i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 390, i64 %6)
%8 = sext i32 %7 to i64
%9 = inttoptr i64 %8 to double*
store i32 1, i32* %3
%10 = icmp sgt i32 %1, 0
br i1 %10, label %11, label %344
11: ; preds = %4
%12 = zext i32 %1 to i64
%13 = add nsw i64 %12, -1
%14 = and i64 %12, 3
%15 = icmp ult i64 %13, 3
%16 = and i64 %12, 4294967292
%17 = icmp eq i64 %14, 0
br label %18
18: ; preds = %88, %11
%19 = phi i64 [ 0, %11 ], [ %91, %88 ]
%20 = getelementptr inbounds double*, double** %0, i64 %19
%21 = load double*, double** %20
br i1 %15, label %69, label %39
22: ; preds = %88
br i1 %10, label %23, label %344
23: ; preds = %22
%24 = zext i32 %1 to i64
%25 = and i64 %24, 4294967292
%26 = add nsw i64 %25, -4
%27 = lshr exact i64 %26, 2
%28 = add nuw nsw i64 %27, 1
%29 = icmp ult i32 %1, 4
%30 = and i64 %12, 4294967292
%31 = and i64 %28, 1
%32 = icmp eq i64 %26, 0
%33 = and i64 %28, 9223372036854775806
%34 = icmp eq i64 %31, 0
%35 = icmp eq i64 %30, %12
%36 = and i64 %24, 1
%37 = icmp eq i64 %36, 0
%38 = sub nsw i64 0, %24
br label %93
39: ; preds = %18, %39
%40 = phi i64 [ %66, %39 ], [ 0, %18 ]
%41 = phi double [ %65, %39 ], [ 0.000000e+00, %18 ]
%42 = phi i64 [ %67, %39 ], [ 0, %18 ]
%43 = getelementptr inbounds double, double* %21, i64 %40
%44 = load double, double* %43
%45 = tail call double @llvm.fabs.f64(double %44)
%46 = fcmp ogt double %45, %41
%47 = select i1 %46, double %45, double %41
%48 = or i64 %40, 1
%49 = getelementptr inbounds double, double* %21, i64 %48
%50 = load double, double* %49
%51 = tail call double @llvm.fabs.f64(double %50)
%52 = fcmp ogt double %51, %47
%53 = select i1 %52, double %51, double %47
%54 = or i64 %40, 2
%55 = getelementptr inbounds double, double* %21, i64 %54
%56 = load double, double* %55
%57 = tail call double @llvm.fabs.f64(double %56)
%58 = fcmp ogt double %57, %53
%59 = select i1 %58, double %57, double %53
%60 = or i64 %40, 3
%61 = getelementptr inbounds double, double* %21, i64 %60
%62 = load double, double* %61
%63 = tail call double @llvm.fabs.f64(double %62)
%64 = fcmp ogt double %63, %59
%65 = select i1 %64, double %63, double %59
%66 = add nuw nsw i64 %40, 4
%67 = add i64 %42, 4
%68 = icmp eq i64 %67, %16
br i1 %68, label %69, label %39
69: ; preds = %39, %18
%70 = phi double [ undef, %18 ], [ %65, %39 ]
%71 = phi i64 [ 0, %18 ], [ %66, %39 ]
%72 = phi double [ 0.000000e+00, %18 ], [ %65, %39 ]
br i1 %17, label %85, label %73
73: ; preds = %69, %73
%74 = phi i64 [ %82, %73 ], [ %71, %69 ]
%75 = phi double [ %81, %73 ], [ %72, %69 ]
%76 = phi i64 [ %83, %73 ], [ 0, %69 ]
%77 = getelementptr inbounds double, double* %21, i64 %74
%78 = load double, double* %77
%79 = tail call double @llvm.fabs.f64(double %78)
%80 = fcmp ogt double %79, %75
%81 = select i1 %80, double %79, double %75
%82 = add nuw nsw i64 %74, 1
%83 = add i64 %76, 1
%84 = icmp eq i64 %83, %14
br i1 %84, label %85, label %73
85: ; preds = %73, %69
%86 = phi double [ %70, %69 ], [ %81, %73 ]
%87 = fcmp oeq double %86, 0.000000e+00
br i1 %87, label %346, label %88
88: ; preds = %85
%89 = fdiv double 1.000000e+00, %86
%90 = getelementptr inbounds double, double* %9, i64 %19
store double %89, double* %90
%91 = add nuw nsw i64 %19, 1
%92 = icmp eq i64 %91, %12
br i1 %92, label %22, label %18
93: ; preds = %23, %341
%94 = phi i64 [ 1, %23 ], [ %342, %341 ]
%95 = phi i64 [ 0, %23 ], [ %330, %341 ]
%96 = phi i32 [ 0, %23 ], [ %211, %341 ]
%97 = icmp eq i64 %95, 0
br i1 %97, label %152, label %98
98: ; preds = %93, %148
%99 = phi i64 [ %150, %148 ], [ 0, %93 ]
%100 = getelementptr inbounds double*, double** %0, i64 %99
%101 = load double*, double** %100
%102 = getelementptr inbounds double, double* %101, i64 %95
%103 = load double, double* %102
%104 = icmp eq i64 %99, 0
br i1 %104, label %148, label %105
105: ; preds = %98
%106 = and i64 %99, 1
%107 = icmp eq i64 %99, 1
br i1 %107, label %134, label %108
108: ; preds = %105
%109 = and i64 %99, 9223372036854775806
br label %110
110: ; preds = %110, %108
%111 = phi i64 [ 0, %108 ], [ %131, %110 ]
%112 = phi double [ %103, %108 ], [ %130, %110 ]
%113 = phi i64 [ 0, %108 ], [ %132, %110 ]
%114 = getelementptr inbounds double, double* %101, i64 %111
%115 = load double, double* %114
%116 = getelementptr inbounds double*, double** %0, i64 %111
%117 = load double*, double** %116
%118 = getelementptr inbounds double, double* %117, i64 %95
%119 = load double, double* %118
%120 = fneg double %115
%121 = tail call double @llvm.fmuladd.f64(double %120, double %119, double %112)
%122 = or i64 %111, 1
%123 = getelementptr inbounds double, double* %101, i64 %122
%124 = load double, double* %123
%125 = getelementptr inbounds double*, double** %0, i64 %122
%126 = load double*, double** %125
%127 = getelementptr inbounds double, double* %126, i64 %95
%128 = load double, double* %127
%129 = fneg double %124
%130 = tail call double @llvm.fmuladd.f64(double %129, double %128, double %121)
%131 = add nuw nsw i64 %111, 2
%132 = add i64 %113, 2
%133 = icmp eq i64 %132, %109
br i1 %133, label %134, label %110
134: ; preds = %110, %105
%135 = phi double [ undef, %105 ], [ %130, %110 ]
%136 = phi i64 [ 0, %105 ], [ %131, %110 ]
%137 = phi double [ %103, %105 ], [ %130, %110 ]
%138 = icmp eq i64 %106, 0
br i1 %138, label %148, label %139
139: ; preds = %134
%140 = getelementptr inbounds double, double* %101, i64 %136
%141 = load double, double* %140
%142 = getelementptr inbounds double*, double** %0, i64 %136
%143 = load double*, double** %142
%144 = getelementptr inbounds double, double* %143, i64 %95
%145 = load double, double* %144
%146 = fneg double %141
%147 = tail call double @llvm.fmuladd.f64(double %146, double %145, double %137)
br label %148
148: ; preds = %139, %134, %98
%149 = phi double [ %103, %98 ], [ %135, %134 ], [ %147, %139 ]
store double %149, double* %102
%150 = add nuw nsw i64 %99, 1
%151 = icmp eq i64 %150, %95
br i1 %151, label %152, label %98
152: ; preds = %148, %93
%153 = and i64 %95, 1
%154 = icmp eq i64 %95, 1
%155 = and i64 %95, 9223372036854775806
%156 = icmp eq i64 %153, 0
br label %157
157: ; preds = %152, %203
%158 = phi i64 [ %213, %203 ], [ %95, %152 ]
%159 = phi double [ %212, %203 ], [ 0.000000e+00, %152 ]
%160 = phi i32 [ %211, %203 ], [ %96, %152 ]
%161 = getelementptr inbounds double*, double** %0, i64 %158
%162 = load double*, double** %161
%163 = getelementptr inbounds double, double* %162, i64 %95
%164 = load double, double* %163
br i1 %97, label %203, label %165
165: ; preds = %157
br i1 %154, label %190, label %166
166: ; preds = %165, %166
%167 = phi i64 [ %187, %166 ], [ 0, %165 ]
%168 = phi double [ %186, %166 ], [ %164, %165 ]
%169 = phi i64 [ %188, %166 ], [ 0, %165 ]
%170 = getelementptr inbounds double, double* %162, i64 %167
%171 = load double, double* %170
%172 = getelementptr inbounds double*, double** %0, i64 %167
%173 = load double*, double** %172
%174 = getelementptr inbounds double, double* %173, i64 %95
%175 = load double, double* %174
%176 = fneg double %171
%177 = tail call double @llvm.fmuladd.f64(double %176, double %175, double %168)
%178 = or i64 %167, 1
%179 = getelementptr inbounds double, double* %162, i64 %178
%180 = load double, double* %179
%181 = getelementptr inbounds double*, double** %0, i64 %178
%182 = load double*, double** %181
%183 = getelementptr inbounds double, double* %182, i64 %95
%184 = load double, double* %183
%185 = fneg double %180
%186 = tail call double @llvm.fmuladd.f64(double %185, double %184, double %177)
%187 = add nuw nsw i64 %167, 2
%188 = add i64 %169, 2
%189 = icmp eq i64 %188, %155
br i1 %189, label %190, label %166
190: ; preds = %166, %165
%191 = phi double [ undef, %165 ], [ %186, %166 ]
%192 = phi i64 [ 0, %165 ], [ %187, %166 ]
%193 = phi double [ %164, %165 ], [ %186, %166 ]
br i1 %156, label %203, label %194
194: ; preds = %190
%195 = getelementptr inbounds double, double* %162, i64 %192
%196 = load double, double* %195
%197 = getelementptr inbounds double*, double** %0, i64 %192
%198 = load double*, double** %197
%199 = getelementptr inbounds double, double* %198, i64 %95
%200 = load double, double* %199
%201 = fneg double %196
%202 = tail call double @llvm.fmuladd.f64(double %201, double %200, double %193)
br label %203
203: ; preds = %194, %190, %157
%204 = phi double [ %164, %157 ], [ %191, %190 ], [ %202, %194 ]
store double %204, double* %163
%205 = getelementptr inbounds double, double* %9, i64 %158
%206 = load double, double* %205
%207 = tail call double @llvm.fabs.f64(double %204)
%208 = fmul double %207, %206
%209 = fcmp ult double %208, %159
%210 = trunc i64 %158 to i32
%211 = select i1 %209, i32 %160, i32 %210
%212 = select i1 %209, double %159, double %208
%213 = add nuw nsw i64 %158, 1
%214 = icmp eq i64 %213, %24
br i1 %214, label %215, label %157
215: ; preds = %203
%216 = zext i32 %211 to i64
%217 = icmp eq i64 %95, %216
br i1 %217, label %321, label %218
218: ; preds = %215
%219 = sext i32 %211 to i64
%220 = getelementptr inbounds double*, double** %0, i64 %219
%221 = load double*, double** %220
%222 = getelementptr inbounds double*, double** %0, i64 %95
%223 = load double*, double** %222
br i1 %29, label %290, label %224
224: ; preds = %218
%225 = getelementptr double, double* %221, i64 %12
%226 = getelementptr double, double* %223, i64 %12
%227 = icmp ult double* %221, %226
%228 = icmp ult double* %223, %225
%229 = and i1 %227, %228
br i1 %229, label %290, label %230
230: ; preds = %224
br i1 %32, label %270, label %231
231: ; preds = %230, %231
%232 = phi i64 [ %267, %231 ], [ 0, %230 ]
%233 = phi i64 [ %268, %231 ], [ 0, %230 ]
%234 = getelementptr inbounds double, double* %221, i64 %232
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = getelementptr inbounds double, double* %234, i64 2
%238 = bitcast double* %237 to <2 x double>*
%239 = load <2 x double>, <2 x double>* %238
%240 = getelementptr inbounds double, double* %223, i64 %232
%241 = bitcast double* %240 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = getelementptr inbounds double, double* %240, i64 2
%244 = bitcast double* %243 to <2 x double>*
%245 = load <2 x double>, <2 x double>* %244
%246 = bitcast double* %234 to <2 x double>*
store <2 x double> %242, <2 x double>* %246
%247 = bitcast double* %237 to <2 x double>*
store <2 x double> %245, <2 x double>* %247
%248 = bitcast double* %240 to <2 x double>*
store <2 x double> %236, <2 x double>* %248
%249 = bitcast double* %243 to <2 x double>*
store <2 x double> %239, <2 x double>* %249
%250 = or i64 %232, 4
%251 = getelementptr inbounds double, double* %221, i64 %250
%252 = bitcast double* %251 to <2 x double>*
%253 = load <2 x double>, <2 x double>* %252
%254 = getelementptr inbounds double, double* %251, i64 2
%255 = bitcast double* %254 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = getelementptr inbounds double, double* %223, i64 %250
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = getelementptr inbounds double, double* %257, i64 2
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = bitcast double* %251 to <2 x double>*
store <2 x double> %259, <2 x double>* %263
%264 = bitcast double* %254 to <2 x double>*
store <2 x double> %262, <2 x double>* %264
%265 = bitcast double* %257 to <2 x double>*
store <2 x double> %253, <2 x double>* %265
%266 = bitcast double* %260 to <2 x double>*
store <2 x double> %256, <2 x double>* %266
%267 = add nuw i64 %232, 8
%268 = add i64 %233, 2
%269 = icmp eq i64 %268, %33
br i1 %269, label %270, label %231
270: ; preds = %231, %230
%271 = phi i64 [ 0, %230 ], [ %267, %231 ]
br i1 %34, label %289, label %272
272: ; preds = %270
%273 = getelementptr inbounds double, double* %221, i64 %271
%274 = bitcast double* %273 to <2 x double>*
%275 = load <2 x double>, <2 x double>* %274
%276 = getelementptr inbounds double, double* %273, i64 2
%277 = bitcast double* %276 to <2 x double>*
%278 = load <2 x double>, <2 x double>* %277
%279 = getelementptr inbounds double, double* %223, i64 %271
%280 = bitcast double* %279 to <2 x double>*
%281 = load <2 x double>, <2 x double>* %280
%282 = getelementptr inbounds double, double* %279, i64 2
%283 = bitcast double* %282 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283
%285 = bitcast double* %273 to <2 x double>*
store <2 x double> %281, <2 x double>* %285
%286 = bitcast double* %276 to <2 x double>*
store <2 x double> %284, <2 x double>* %286
%287 = bitcast double* %279 to <2 x double>*
store <2 x double> %275, <2 x double>* %287
%288 = bitcast double* %282 to <2 x double>*
store <2 x double> %278, <2 x double>* %288
br label %289
289: ; preds = %270, %272
br i1 %35, label %315, label %290
290: ; preds = %224, %218, %289
%291 = phi i64 [ 0, %224 ], [ 0, %218 ], [ %30, %289 ]
%292 = xor i64 %291, -1
br i1 %37, label %299, label %293
293: ; preds = %290
%294 = getelementptr inbounds double, double* %221, i64 %291
%295 = load double, double* %294
%296 = getelementptr inbounds double, double* %223, i64 %291
%297 = load double, double* %296
store double %297, double* %294
store double %295, double* %296
%298 = or i64 %291, 1
br label %299
299: ; preds = %293, %290
%300 = phi i64 [ %291, %290 ], [ %298, %293 ]
%301 = icmp eq i64 %292, %38
br i1 %301, label %315, label %302
302: ; preds = %299, %302
%303 = phi i64 [ %313, %302 ], [ %300, %299 ]
%304 = getelementptr inbounds double, double* %221, i64 %303
%305 = load double, double* %304
%306 = getelementptr inbounds double, double* %223, i64 %303
%307 = load double, double* %306
store double %307, double* %304
store double %305, double* %306
%308 = add nuw nsw i64 %303, 1
%309 = getelementptr inbounds double, double* %221, i64 %308
%310 = load double, double* %309
%311 = getelementptr inbounds double, double* %223, i64 %308
%312 = load double, double* %311
store double %312, double* %309
store double %310, double* %311
%313 = add nuw nsw i64 %303, 2
%314 = icmp eq i64 %313, %24
br i1 %314, label %315, label %302
315: ; preds = %299, %302, %289
%316 = load i32, i32* %3
%317 = sub nsw i32 0, %316
store i32 %317, i32* %3
%318 = getelementptr inbounds double, double* %9, i64 %95
%319 = load double, double* %318
%320 = getelementptr inbounds double, double* %9, i64 %219
store double %319, double* %320
br label %321
321: ; preds = %315, %215
%322 = getelementptr inbounds i32, i32* %2, i64 %95
store i32 %211, i32* %322
%323 = getelementptr inbounds double*, double** %0, i64 %95
%324 = load double*, double** %323
%325 = getelementptr inbounds double, double* %324, i64 %95
%326 = load double, double* %325
%327 = fcmp une double %326, 0.000000e+00
br i1 %327, label %328, label %346
328: ; preds = %321
%329 = fdiv double 1.000000e+00, %326
%330 = add nuw nsw i64 %95, 1
%331 = icmp slt i64 %330, %5
br i1 %331, label %332, label %341
332: ; preds = %328, %332
%333 = phi i64 [ %339, %332 ], [ %94, %328 ]
%334 = getelementptr inbounds double*, double** %0, i64 %333
%335 = load double*, double** %334
%336 = getelementptr inbounds double, double* %335, i64 %95
%337 = load double, double* %336
%338 = fmul double %329, %337
store double %338, double* %336
%339 = add nuw nsw i64 %333, 1
%340 = icmp eq i64 %339, %24
br i1 %340, label %341, label %332
341: ; preds = %332, %328
%342 = add nuw nsw i64 %94, 1
%343 = icmp eq i64 %330, %24
br i1 %343, label %344, label %93
344: ; preds = %341, %4, %22
%345 = tail call i32 (i8*, i8*, i32, double*, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double*, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__func__.lu_decomposition, i64 0, i64 0), i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 448, double* %9)
br label %346
346: ; preds = %85, %321, %344
%347 = phi i32 [ 1, %344 ], [ 0, %321 ], [ 0, %85 ]
ret i32 %347
}