#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 */
scalar_t__ calloc(int, int);
double fabs(double);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ printf(char *);
int NUM_lu(double *matrix, double *solution, int neq) {
  int i, j, k;
  int idx;
  double big;
  double tmp = 0.0;
  int *P;
  double *y;
  P = (int *)calloc(neq, sizeof(int));
  y = (double *)calloc(neq, sizeof(double));
  for (i = 0; i < neq; i++) {
    solution[i] = 0;
    P[i] = i;
  }
  for (i = 0; i < neq - 1; i++) {
    for (j = i; j < neq; j++) {
      tmp = 0.0;
      for (k = 0; k < i; k++)
        tmp += matrix[i + neq * P[k]] * matrix[k + neq * P[j]];
      matrix[i + neq * P[j]] = matrix[i + neq * P[j]] - tmp;
    }
    big = 0.0;
    idx = i;
    for (j = i; j < neq; j++) {
      if (big < fabs(matrix[i + neq * P[j]])) {
        idx = j;
        big = fabs(matrix[i + neq * P[j]]);
      }
    }
    if (idx != i) {
      tmp = P[i];
      P[i] = P[idx];
      P[idx] = tmp;
    }
    if (matrix[i + neq * P[i]] == 0.0) {
      printf("LU: matrix is singular, no unique solution.\n");
      return 2;
    }
    for (j = i + 1; j < neq; j++) {
      tmp = 0.0;
      for (k = 0; k < i; k++)
        tmp += matrix[j + neq * P[k]] * matrix[k + neq * P[i]];
      matrix[j + neq * P[i]] =
          (matrix[j + neq * P[i]] - tmp) / matrix[i + neq * P[i]];
    }
  }
  i = neq - 1;
  tmp = 0.0;
  for (k = 0; k < neq - 1; k++)
    tmp += matrix[i + neq * P[k]] * matrix[k + neq * P[i]];
  matrix[i + neq * P[i]] = matrix[i + neq * P[i]] - tmp;
  for (i = 0; i < neq; i++) {
    tmp = 0.0;
    for (j = 0; j < i; j++)
      tmp += matrix[i + neq * P[j]] * y[j];
    y[i] = matrix[i + neq * neq] - tmp;
  }
  for (i = neq - 1; i >= 0; i--) {
    if (matrix[i + neq * P[i]] == 0.0) {
      printf("LU: No unique solution exist.\n");
      return 2;
    }
    tmp = 0.0;
    for (j = i; j < neq; j++)
      tmp += matrix[i + neq * P[j]] * solution[P[j]];
    solution[P[i]] = (y[i] - tmp) / matrix[i + neq * P[i]];
  }
  free(y);
  return 0;
}


x86 assembly (clang, -O0):
<NUM_lu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ac <NUM_lu+0x7c>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1174 <NUM_lu+0x44>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14ec <NUM_lu+0x3bc>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a4 <NUM_lu+0x174>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1251 <NUM_lu+0x121>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x28(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e5 <NUM_lu+0xb5>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ca <NUM_lu+0x9a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1347 <NUM_lu+0x217>
movsd  -0x38(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd10(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1334 <NUM_lu+0x204>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xcd5(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1339 <NUM_lu+0x209>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b8 <NUM_lu+0x188>
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     138b <NUM_lu+0x25b>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cvttsd2si -0x40(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13d6 <NUM_lu+0x2a6>
jp     13d6 <NUM_lu+0x2a6>
lea    0xc4b(%rip),%rdi
call   1040 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    179f <NUM_lu+0x66f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14d9 <NUM_lu+0x3a9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1466 <NUM_lu+0x336>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x28(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13fa <NUM_lu+0x2ca>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13df <NUM_lu+0x2af>
jmp    14de <NUM_lu+0x3ae>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b3 <NUM_lu+0x83>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1575 <NUM_lu+0x445>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x28(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1504 <NUM_lu+0x3d4>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    166d <NUM_lu+0x53d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1635 <NUM_lu+0x505>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15dc <NUM_lu+0x4ac>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    15c1 <NUM_lu+0x491>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     178f <NUM_lu+0x65f>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16cb <NUM_lu+0x59b>
jp     16cb <NUM_lu+0x59b>
lea    0x983(%rip),%rdi
call   1040 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    179f <NUM_lu+0x66f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    173a <NUM_lu+0x60a>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x24(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16d9 <NUM_lu+0x5a9>
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rsi
movslq -0x20(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1676 <NUM_lu+0x546>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NUM_lu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,%r13
mov    %edx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r12
mov    %r15d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %r15d,%r10d
test   %r15d,%r15d
jle    1178 <NUM_lu+0x48>
cmp    $0x4,%r15d
jae    1181 <NUM_lu+0x51>
xor    %edx,%edx
jmp    1270 <NUM_lu+0x140>
lea    -0x1(%r15),%ebx
jmp    15c0 <NUM_lu+0x490>
mov    %r10d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rsi,%rsi
je     15a4 <NUM_lu+0x474>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xe52(%rip),%xmm0
xor    %esi,%esi
movdqa 0xe58(%rip),%xmm1
xorpd  %xmm2,%xmm2
movdqa 0xe5c(%rip),%xmm3
movdqa 0xe64(%rip),%xmm4
movdqa 0xe6c(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm2,0x10(%r14,%rsi,8)
movdqa %xmm0,%xmm7
punpcklqdq %xmm6,%xmm7
movdqu %xmm7,(%r12,%rsi,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
punpcklqdq %xmm7,%xmm6
movupd %xmm2,0x20(%r14,%rsi,8)
movupd %xmm2,0x30(%r14,%rsi,8)
movdqu %xmm6,0x10(%r12,%rsi,4)
add    $0x8,%rsi
paddd  %xmm5,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    11e0 <NUM_lu+0xb0>
test   $0x1,%cl
je     1266 <NUM_lu+0x136>
movdqa 0xdc9(%rip),%xmm1
paddd  %xmm0,%xmm1
xorpd  %xmm2,%xmm2
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm2,0x10(%r14,%rsi,8)
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%r12,%rsi,4)
cmp    %r10,%rdx
je     1285 <NUM_lu+0x155>
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%r14,%rdx,8)
mov    %edx,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r10
jne    1270 <NUM_lu+0x140>
lea    -0x1(%r15),%ebx
cmp    $0x2,%r15d
jl     15c0 <NUM_lu+0x490>
mov    %ebx,0x4(%rsp)
mov    %ebx,%ecx
mov    %rcx,0x18(%rsp)
lea    0x8(%r13),%rcx
mov    %rcx,0x10(%rsp)
mov    $0x1,%ecx
mov    %rcx,0x8(%rsp)
xor    %ecx,%ecx
movapd 0xd95(%rip),%xmm0
pxor   %xmm1,%xmm1
jmp    12e9 <NUM_lu+0x1b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x8(%rsp)
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rcx
cmp    %rdi,%rcx
je     157e <NUM_lu+0x44e>
mov    %rcx,%rdi
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
movslq %r15d,%rsi
cmp    %r10,%rcx
jae    13f0 <NUM_lu+0x2c0>
mov    %rdi,%r11
jmp    133c <NUM_lu+0x20c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %r8d,%r8d
xorpd  %xmm2,%xmm2
add    %r8d,%r9d
movslq %r9d,%rcx
movsd  0x0(%r13,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rcx,8)
add    $0x1,%r11
cmp    %r10,%r11
je     1400 <NUM_lu+0x2d0>
movslq (%r12,%r11,4),%r9
imul   %rsi,%r9
test   %rdi,%rdi
je     1310 <NUM_lu+0x1e0>
cmp    $0x1,%rdi
jne    1360 <NUM_lu+0x230>
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
jmp    13b6 <NUM_lu+0x286>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,8),%rbp
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
nop
mov    (%r12,%rcx,4),%ebx
imul   %r15d,%ebx
add    %edi,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
mulsd  -0x8(%rbp,%rcx,8),%xmm3
addsd  %xmm2,%xmm3
mov    0x4(%r12,%rcx,4),%ebx
imul   %r15d,%ebx
add    %edi,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm2
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm3,%xmm2
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1370 <NUM_lu+0x240>
mov    %edi,%r8d
test   $0x1,%dil
je     1317 <NUM_lu+0x1e7>
mov    (%r12,%rcx,4),%ebp
imul   %r15d,%ebp
add    %edi,%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm3
add    %r9,%rcx
mulsd  0x0(%r13,%rcx,8),%xmm3
addsd  %xmm3,%xmm2
mov    %edi,%r8d
jmp    1317 <NUM_lu+0x1e7>
nopl   (%rax)
mov    %edi,%r8d
mov    %edi,%ecx
jmp    1453 <NUM_lu+0x323>
nopw   0x0(%rax,%rax,1)
cmp    %r10,%rdi
jae    1450 <NUM_lu+0x320>
xorpd  %xmm2,%xmm2
mov    %rdi,%rbp
mov    %r8d,%ecx
nop
mov    (%r12,%rbp,4),%ebx
imul   %r15d,%ebx
add    %r8d,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
cmova  %ebp,%ecx
maxsd  %xmm2,%xmm3
add    $0x1,%rbp
movapd %xmm3,%xmm2
cmp    %rbp,%r10
jne    1410 <NUM_lu+0x2e0>
jmp    1453 <NUM_lu+0x323>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8d,%ecx
mov    %ecx,%ebp
cmp    %rbp,%rdi
je     146d <NUM_lu+0x33d>
mov    (%r12,%rdi,4),%ebp
movslq %ecx,%rcx
mov    (%r12,%rcx,4),%ebx
mov    %ebx,(%r12,%rdi,4)
mov    %ebp,(%r12,%rcx,4)
movslq (%r12,%rdi,4),%rbp
imul   %rsi,%rbp
add    %ebp,%r8d
movslq %r8d,%r8
movsd  0x0(%r13,%r8,8),%xmm2
ucomisd %xmm1,%xmm2
jne    148e <NUM_lu+0x35e>
jnp    1572 <NUM_lu+0x442>
lea    0x1(%rdi),%rcx
mov    %rcx,0x20(%rsp)
cmp    %r10,%rcx
jae    12d0 <NUM_lu+0x1a0>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,8),%r9
mov    0x8(%rsp),%rcx
jmp    14da <NUM_lu+0x3aa>
lea    (%rcx,%rbp,1),%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  0x0(%r13,%r8,8),%xmm3
movsd  %xmm3,0x0(%r13,%rbx,8)
add    $0x1,%rcx
cmp    %r10,%rcx
je     12d0 <NUM_lu+0x1a0>
xorpd  %xmm2,%xmm2
test   %rdi,%rdi
je     14b0 <NUM_lu+0x380>
cmp    $0x1,%rdi
jne    14f0 <NUM_lu+0x3c0>
xor    %r11d,%r11d
jmp    1543 <NUM_lu+0x413>
xchg   %ax,%ax
xorpd  %xmm2,%xmm2
xor    %r11d,%r11d
nopw   0x0(%rax,%rax,1)
movslq (%r12,%r11,4),%rbx
imul   %rsi,%rbx
add    %rcx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
mulsd  -0x8(%r9,%r11,8),%xmm3
addsd  %xmm2,%xmm3
movslq 0x4(%r12,%r11,4),%rbx
imul   %rsi,%rbx
add    %rcx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm2
mulsd  (%r9,%r11,8),%xmm2
addsd  %xmm3,%xmm2
add    $0x2,%r11
cmp    %r11,%rdx
jne    1500 <NUM_lu+0x3d0>
test   $0x1,%dil
je     14b0 <NUM_lu+0x380>
movslq (%r12,%r11,4),%rbx
imul   %rsi,%rbx
add    %rcx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
add    %rbp,%r11
mulsd  0x0(%r13,%r11,8),%xmm3
addsd  %xmm3,%xmm2
jmp    14b0 <NUM_lu+0x380>
lea    0xb05(%rip),%rdi
jmp    17e2 <NUM_lu+0x6b2>
cmp    $0x1,%r15d
jle    15bc <NUM_lu+0x48c>
movslq (%r12,%rdi,4),%rdx
imul   %rsi,%rdx
mov    0x4(%rsp),%ebx
cmp    $0x1,%ebx
jne    17fb <NUM_lu+0x6cb>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1865 <NUM_lu+0x735>
movdqa 0xa54(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%cl
jne    123f <NUM_lu+0x10f>
jmp    1266 <NUM_lu+0x136>
mov    0x4(%rsp),%ebx
movslq %ebx,%rcx
mov    (%r12,%rcx,4),%edx
imul   %r15d,%edx
xorpd  %xmm0,%xmm0
add    %ebx,%edx
movslq %edx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
test   %r15d,%r15d
jle    17cf <NUM_lu+0x69f>
mov    %r15d,%edx
imul   %edx,%edx
xor    %esi,%esi
jmp    1625 <NUM_lu+0x4f5>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
lea    (%rsi,%rdx,1),%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %r10,%rsi
je     16c1 <NUM_lu+0x591>
test   %rsi,%rsi
je     1600 <NUM_lu+0x4d0>
cmp    $0x1,%rsi
jne    1640 <NUM_lu+0x510>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1695 <NUM_lu+0x565>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   (%rax)
mov    (%r12,%rcx,4),%ebp
imul   %r15d,%ebp
add    %esi,%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x4(%r12,%rcx,4),%ebp
imul   %r15d,%ebp
add    %esi,%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rax,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    1650 <NUM_lu+0x520>
test   $0x1,%sil
je     1604 <NUM_lu+0x4d4>
mov    (%r12,%rcx,4),%edi
imul   %r15d,%edi
add    %esi,%edi
movslq %edi,%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1604 <NUM_lu+0x4d4>
test   %r15d,%r15d
jle    17cf <NUM_lu+0x69f>
mov    %ebx,%esi
xor    %edx,%edx
xorpd  %xmm0,%xmm0
mov    %r10,%r8
jmp    1707 <NUM_lu+0x5d7>
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm1,%xmm3
movsd  %xmm3,(%r14,%rdi,8)
lea    -0x1(%rsi),%rcx
add    $0x1,%rdx
test   %rsi,%rsi
mov    %rcx,%rsi
jle    17cf <NUM_lu+0x69f>
movslq (%r12,%rsi,4),%rdi
mov    %edi,%ecx
imul   %r15d,%ecx
add    %esi,%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1729 <NUM_lu+0x5f9>
jnp    17db <NUM_lu+0x6ab>
mov    %r8,%rbp
add    $0xffffffffffffffff,%r8
xorpd  %xmm2,%xmm2
cmp    %r10,%rsi
jge    16e0 <NUM_lu+0x5b0>
xorpd  %xmm2,%xmm2
mov    %r8,%rcx
test   $0x1,%dl
jne    1768 <NUM_lu+0x638>
movslq (%r12,%r8,4),%rcx
mov    %ecx,%ebx
imul   %r15d,%ebx
add    %esi,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm2
mulsd  (%r14,%rcx,8),%xmm2
addsd  %xmm0,%xmm2
mov    %rbp,%rcx
test   %rdx,%rdx
je     16e0 <NUM_lu+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq (%r12,%rcx,4),%rbp
mov    %ebp,%ebx
imul   %r15d,%ebx
add    %esi,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm3
mulsd  (%r14,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
movslq 0x4(%r12,%rcx,4),%rbp
mov    %ebp,%ebx
imul   %r15d,%ebx
add    %esi,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm2
mulsd  (%r14,%rbp,8),%xmm2
addsd  %xmm3,%xmm2
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1780 <NUM_lu+0x650>
jmp    16e0 <NUM_lu+0x5b0>
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    17ec <NUM_lu+0x6bc>
lea    0x87e(%rip),%rdi
call   1040 <puts@plt>
mov    $0x2,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edi,%r8d
and    $0xfffffffe,%r8d
lea    0x8(,%rdx,8),%rsi
add    %r13,%rsi
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rcx,4),%ebp
imul   %r15d,%ebp
add    %ebx,%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
mulsd  -0x8(%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x4(%r12,%rcx,4),%ebp
imul   %r15d,%ebp
add    %ebx,%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  (%rsi,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rcx
cmp    %rcx,%r8
jne    1820 <NUM_lu+0x6f0>
test   $0x1,%dil
jne    1874 <NUM_lu+0x744>
mov    0x4(%rsp),%ebx
jmp    15cf <NUM_lu+0x49f>
mov    (%r12,%rcx,4),%esi
imul   %r15d,%esi
mov    0x4(%rsp),%ebx
add    %ebx,%esi
movslq %esi,%rsi
movsd  0x0(%r13,%rsi,8),%xmm1
mov    %rdx,%rsi
add    %rcx,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    15cf <NUM_lu+0x49f>

LLVM IR (-O0):
@.str = [45 x i8] c"LU: matrix is singular, no unique solution.\0A\00"
@.str.1 = [31 x i8] c"LU: No unique solution exist.\0A\00"
define i32 @NUM_lu(double* %0, double* %1, i32 %2) {
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca i32*
%15 = alloca double*
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
store double 0.000000e+00, double* %13
%16 = load i32, i32* %7
%17 = call i64 @calloc(i32 %16, i32 4)
%18 = inttoptr i64 %17 to i32*
store i32* %18, i32** %14
%19 = load i32, i32* %7
%20 = call i64 @calloc(i32 %19, i32 8)
%21 = inttoptr i64 %20 to double*
store double* %21, double** %15
store i32 0, i32* %8
br label %22
22: ; preds = %36, %3
%23 = load i32, i32* %8
%24 = load i32, i32* %7
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %39
26: ; preds = %22
%27 = load double*, double** %6
%28 = load i32, i32* %8
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %27, i64 %29
store double 0.000000e+00, double* %30
%31 = load i32, i32* %8
%32 = load i32*, i32** %14
%33 = load i32, i32* %8
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
store i32 %31, i32* %35
br label %36
36: ; preds = %26
%37 = load i32, i32* %8
%38 = add nsw i32 %37, 1
store i32 %38, i32* %8
br label %22
39: ; preds = %22
store i32 0, i32* %8
br label %40
40: ; preds = %296, %39
%41 = load i32, i32* %8
%42 = load i32, i32* %7
%43 = sub nsw i32 %42, 1
%44 = icmp slt i32 %41, %43
br i1 %44, label %45, label %299
45: ; preds = %40
%46 = load i32, i32* %8
store i32 %46, i32* %9
br label %47
47: ; preds = %116, %45
%48 = load i32, i32* %9
%49 = load i32, i32* %7
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %119
51: ; preds = %47
store double 0.000000e+00, double* %13
store i32 0, i32* %10
br label %52
52: ; preds = %85, %51
%53 = load i32, i32* %10
%54 = load i32, i32* %8
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %88
56: ; preds = %52
%57 = load double*, double** %5
%58 = load i32, i32* %8
%59 = load i32, i32* %7
%60 = load i32*, i32** %14
%61 = load i32, i32* %10
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %60, i64 %62
%64 = load i32, i32* %63
%65 = mul nsw i32 %59, %64
%66 = add nsw i32 %58, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %57, i64 %67
%69 = load double, double* %68
%70 = load double*, double** %5
%71 = load i32, i32* %10
%72 = load i32, i32* %7
%73 = load i32*, i32** %14
%74 = load i32, i32* %9
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %73, i64 %75
%77 = load i32, i32* %76
%78 = mul nsw i32 %72, %77
%79 = add nsw i32 %71, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %70, i64 %80
%82 = load double, double* %81
%83 = load double, double* %13
%84 = call double @llvm.fmuladd.f64(double %69, double %82, double %83)
store double %84, double* %13
br label %85
85: ; preds = %56
%86 = load i32, i32* %10
%87 = add nsw i32 %86, 1
store i32 %87, i32* %10
br label %52
88: ; preds = %52
%89 = load double*, double** %5
%90 = load i32, i32* %8
%91 = load i32, i32* %7
%92 = load i32*, i32** %14
%93 = load i32, i32* %9
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
%97 = mul nsw i32 %91, %96
%98 = add nsw i32 %90, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %89, i64 %99
%101 = load double, double* %100
%102 = load double, double* %13
%103 = fsub double %101, %102
%104 = load double*, double** %5
%105 = load i32, i32* %8
%106 = load i32, i32* %7
%107 = load i32*, i32** %14
%108 = load i32, i32* %9
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
%112 = mul nsw i32 %106, %111
%113 = add nsw i32 %105, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %104, i64 %114
store double %103, double* %115
br label %116
116: ; preds = %88
%117 = load i32, i32* %9
%118 = add nsw i32 %117, 1
store i32 %118, i32* %9
br label %47
119: ; preds = %47
store double 0.000000e+00, double* %12
%120 = load i32, i32* %8
store i32 %120, i32* %11
%121 = load i32, i32* %8
store i32 %121, i32* %9
br label %122
122: ; preds = %160, %119
%123 = load i32, i32* %9
%124 = load i32, i32* %7
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %163
126: ; preds = %122
%127 = load double, double* %12
%128 = load double*, double** %5
%129 = load i32, i32* %8
%130 = load i32, i32* %7
%131 = load i32*, i32** %14
%132 = load i32, i32* %9
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
%135 = load i32, i32* %134
%136 = mul nsw i32 %130, %135
%137 = add nsw i32 %129, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %128, i64 %138
%140 = load double, double* %139
%141 = call double @llvm.fabs.f64(double %140)
%142 = fcmp olt double %127, %141
br i1 %142, label %143, label %159
143: ; preds = %126
%144 = load i32, i32* %9
store i32 %144, i32* %11
%145 = load double*, double** %5
%146 = load i32, i32* %8
%147 = load i32, i32* %7
%148 = load i32*, i32** %14
%149 = load i32, i32* %9
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
%152 = load i32, i32* %151
%153 = mul nsw i32 %147, %152
%154 = add nsw i32 %146, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %145, i64 %155
%157 = load double, double* %156
%158 = call double @llvm.fabs.f64(double %157)
store double %158, double* %12
br label %159
159: ; preds = %143, %126
br label %160
160: ; preds = %159
%161 = load i32, i32* %9
%162 = add nsw i32 %161, 1
store i32 %162, i32* %9
br label %122
163: ; preds = %122
%164 = load i32, i32* %11
%165 = load i32, i32* %8
%166 = icmp ne i32 %164, %165
br i1 %166, label %167, label %189
167: ; preds = %163
%168 = load i32*, i32** %14
%169 = load i32, i32* %8
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %168, i64 %170
%172 = load i32, i32* %171
%173 = sitofp i32 %172 to double
store double %173, double* %13
%174 = load i32*, i32** %14
%175 = load i32, i32* %11
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %174, i64 %176
%178 = load i32, i32* %177
%179 = load i32*, i32** %14
%180 = load i32, i32* %8
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
store i32 %178, i32* %182
%183 = load double, double* %13
%184 = fptosi double %183 to i32
%185 = load i32*, i32** %14
%186 = load i32, i32* %11
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %185, i64 %187
store i32 %184, i32* %188
br label %189
189: ; preds = %167, %163
%190 = load double*, double** %5
%191 = load i32, i32* %8
%192 = load i32, i32* %7
%193 = load i32*, i32** %14
%194 = load i32, i32* %8
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32, i32* %193, i64 %195
%197 = load i32, i32* %196
%198 = mul nsw i32 %192, %197
%199 = add nsw i32 %191, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %190, i64 %200
%202 = load double, double* %201
%203 = fcmp oeq double %202, 0.000000e+00
br i1 %203, label %204, label %206
204: ; preds = %189
%205 = call i32 @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0))
store i32 2, i32* %4
br label %512
206: ; preds = %189
%207 = load i32, i32* %8
%208 = add nsw i32 %207, 1
store i32 %208, i32* %9
br label %209
209: ; preds = %292, %206
%210 = load i32, i32* %9
%211 = load i32, i32* %7
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %295
213: ; preds = %209
store double 0.000000e+00, double* %13
store i32 0, i32* %10
br label %214
214: ; preds = %247, %213
%215 = load i32, i32* %10
%216 = load i32, i32* %8
%217 = icmp slt i32 %215, %216
br i1 %217, label %218, label %250
218: ; preds = %214
%219 = load double*, double** %5
%220 = load i32, i32* %9
%221 = load i32, i32* %7
%222 = load i32*, i32** %14
%223 = load i32, i32* %10
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
%226 = load i32, i32* %225
%227 = mul nsw i32 %221, %226
%228 = add nsw i32 %220, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %219, i64 %229
%231 = load double, double* %230
%232 = load double*, double** %5
%233 = load i32, i32* %10
%234 = load i32, i32* %7
%235 = load i32*, i32** %14
%236 = load i32, i32* %8
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i32, i32* %235, i64 %237
%239 = load i32, i32* %238
%240 = mul nsw i32 %234, %239
%241 = add nsw i32 %233, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %232, i64 %242
%244 = load double, double* %243
%245 = load double, double* %13
%246 = call double @llvm.fmuladd.f64(double %231, double %244, double %245)
store double %246, double* %13
br label %247
247: ; preds = %218
%248 = load i32, i32* %10
%249 = add nsw i32 %248, 1
store i32 %249, i32* %10
br label %214
250: ; preds = %214
%251 = load double*, double** %5
%252 = load i32, i32* %9
%253 = load i32, i32* %7
%254 = load i32*, i32** %14
%255 = load i32, i32* %8
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %254, i64 %256
%258 = load i32, i32* %257
%259 = mul nsw i32 %253, %258
%260 = add nsw i32 %252, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %251, i64 %261
%263 = load double, double* %262
%264 = load double, double* %13
%265 = fsub double %263, %264
%266 = load double*, double** %5
%267 = load i32, i32* %8
%268 = load i32, i32* %7
%269 = load i32*, i32** %14
%270 = load i32, i32* %8
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
%273 = load i32, i32* %272
%274 = mul nsw i32 %268, %273
%275 = add nsw i32 %267, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %266, i64 %276
%278 = load double, double* %277
%279 = fdiv double %265, %278
%280 = load double*, double** %5
%281 = load i32, i32* %9
%282 = load i32, i32* %7
%283 = load i32*, i32** %14
%284 = load i32, i32* %8
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %283, i64 %285
%287 = load i32, i32* %286
%288 = mul nsw i32 %282, %287
%289 = add nsw i32 %281, %288
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %280, i64 %290
store double %279, double* %291
br label %292
292: ; preds = %250
%293 = load i32, i32* %9
%294 = add nsw i32 %293, 1
store i32 %294, i32* %9
br label %209
295: ; preds = %209
br label %296
296: ; preds = %295
%297 = load i32, i32* %8
%298 = add nsw i32 %297, 1
store i32 %298, i32* %8
br label %40
299: ; preds = %40
%300 = load i32, i32* %7
%301 = sub nsw i32 %300, 1
store i32 %301, i32* %8
store double 0.000000e+00, double* %13
store i32 0, i32* %10
br label %302
302: ; preds = %336, %299
%303 = load i32, i32* %10
%304 = load i32, i32* %7
%305 = sub nsw i32 %304, 1
%306 = icmp slt i32 %303, %305
br i1 %306, label %307, label %339
307: ; preds = %302
%308 = load double*, double** %5
%309 = load i32, i32* %8
%310 = load i32, i32* %7
%311 = load i32*, i32** %14
%312 = load i32, i32* %10
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i32, i32* %311, i64 %313
%315 = load i32, i32* %314
%316 = mul nsw i32 %310, %315
%317 = add nsw i32 %309, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %308, i64 %318
%320 = load double, double* %319
%321 = load double*, double** %5
%322 = load i32, i32* %10
%323 = load i32, i32* %7
%324 = load i32*, i32** %14
%325 = load i32, i32* %8
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
%329 = mul nsw i32 %323, %328
%330 = add nsw i32 %322, %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %321, i64 %331
%333 = load double, double* %332
%334 = load double, double* %13
%335 = call double @llvm.fmuladd.f64(double %320, double %333, double %334)
store double %335, double* %13
br label %336
336: ; preds = %307
%337 = load i32, i32* %10
%338 = add nsw i32 %337, 1
store i32 %338, i32* %10
br label %302
339: ; preds = %302
%340 = load double*, double** %5
%341 = load i32, i32* %8
%342 = load i32, i32* %7
%343 = load i32*, i32** %14
%344 = load i32, i32* %8
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i32, i32* %343, i64 %345
%347 = load i32, i32* %346
%348 = mul nsw i32 %342, %347
%349 = add nsw i32 %341, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %340, i64 %350
%352 = load double, double* %351
%353 = load double, double* %13
%354 = fsub double %352, %353
%355 = load double*, double** %5
%356 = load i32, i32* %8
%357 = load i32, i32* %7
%358 = load i32*, i32** %14
%359 = load i32, i32* %8
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i32, i32* %358, i64 %360
%362 = load i32, i32* %361
%363 = mul nsw i32 %357, %362
%364 = add nsw i32 %356, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %355, i64 %365
store double %354, double* %366
store i32 0, i32* %8
br label %367
367: ; preds = %416, %339
%368 = load i32, i32* %8
%369 = load i32, i32* %7
%370 = icmp slt i32 %368, %369
br i1 %370, label %371, label %419
371: ; preds = %367
store double 0.000000e+00, double* %13
store i32 0, i32* %9
br label %372
372: ; preds = %397, %371
%373 = load i32, i32* %9
%374 = load i32, i32* %8
%375 = icmp slt i32 %373, %374
br i1 %375, label %376, label %400
376: ; preds = %372
%377 = load double*, double** %5
%378 = load i32, i32* %8
%379 = load i32, i32* %7
%380 = load i32*, i32** %14
%381 = load i32, i32* %9
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %380, i64 %382
%384 = load i32, i32* %383
%385 = mul nsw i32 %379, %384
%386 = add nsw i32 %378, %385
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %377, i64 %387
%389 = load double, double* %388
%390 = load double*, double** %15
%391 = load i32, i32* %9
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %390, i64 %392
%394 = load double, double* %393
%395 = load double, double* %13
%396 = call double @llvm.fmuladd.f64(double %389, double %394, double %395)
store double %396, double* %13
br label %397
397: ; preds = %376
%398 = load i32, i32* %9
%399 = add nsw i32 %398, 1
store i32 %399, i32* %9
br label %372
400: ; preds = %372
%401 = load double*, double** %5
%402 = load i32, i32* %8
%403 = load i32, i32* %7
%404 = load i32, i32* %7
%405 = mul nsw i32 %403, %404
%406 = add nsw i32 %402, %405
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %401, i64 %407
%409 = load double, double* %408
%410 = load double, double* %13
%411 = fsub double %409, %410
%412 = load double*, double** %15
%413 = load i32, i32* %8
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %412, i64 %414
store double %411, double* %415
br label %416
416: ; preds = %400
%417 = load i32, i32* %8
%418 = add nsw i32 %417, 1
store i32 %418, i32* %8
br label %367
419: ; preds = %367
%420 = load i32, i32* %7
%421 = sub nsw i32 %420, 1
store i32 %421, i32* %8
br label %422
422: ; preds = %506, %419
%423 = load i32, i32* %8
%424 = icmp sge i32 %423, 0
br i1 %424, label %425, label %509
425: ; preds = %422
%426 = load double*, double** %5
%427 = load i32, i32* %8
%428 = load i32, i32* %7
%429 = load i32*, i32** %14
%430 = load i32, i32* %8
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i32, i32* %429, i64 %431
%433 = load i32, i32* %432
%434 = mul nsw i32 %428, %433
%435 = add nsw i32 %427, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %426, i64 %436
%438 = load double, double* %437
%439 = fcmp oeq double %438, 0.000000e+00
br i1 %439, label %440, label %442
440: ; preds = %425
%441 = call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0))
store i32 2, i32* %4
br label %512
442: ; preds = %425
store double 0.000000e+00, double* %13
%443 = load i32, i32* %8
store i32 %443, i32* %9
br label %444
444: ; preds = %473, %442
%445 = load i32, i32* %9
%446 = load i32, i32* %7
%447 = icmp slt i32 %445, %446
br i1 %447, label %448, label %476
448: ; preds = %444
%449 = load double*, double** %5
%450 = load i32, i32* %8
%451 = load i32, i32* %7
%452 = load i32*, i32** %14
%453 = load i32, i32* %9
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %452, i64 %454
%456 = load i32, i32* %455
%457 = mul nsw i32 %451, %456
%458 = add nsw i32 %450, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %449, i64 %459
%461 = load double, double* %460
%462 = load double*, double** %6
%463 = load i32*, i32** %14
%464 = load i32, i32* %9
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds i32, i32* %463, i64 %465
%467 = load i32, i32* %466
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %462, i64 %468
%470 = load double, double* %469
%471 = load double, double* %13
%472 = call double @llvm.fmuladd.f64(double %461, double %470, double %471)
store double %472, double* %13
br label %473
473: ; preds = %448
%474 = load i32, i32* %9
%475 = add nsw i32 %474, 1
store i32 %475, i32* %9
br label %444
476: ; preds = %444
%477 = load double*, double** %15
%478 = load i32, i32* %8
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %477, i64 %479
%481 = load double, double* %480
%482 = load double, double* %13
%483 = fsub double %481, %482
%484 = load double*, double** %5
%485 = load i32, i32* %8
%486 = load i32, i32* %7
%487 = load i32*, i32** %14
%488 = load i32, i32* %8
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i32, i32* %487, i64 %489
%491 = load i32, i32* %490
%492 = mul nsw i32 %486, %491
%493 = add nsw i32 %485, %492
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %484, i64 %494
%496 = load double, double* %495
%497 = fdiv double %483, %496
%498 = load double*, double** %6
%499 = load i32*, i32** %14
%500 = load i32, i32* %8
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %499, i64 %501
%503 = load i32, i32* %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %498, i64 %504
store double %497, double* %505
br label %506
506: ; preds = %476
%507 = load i32, i32* %8
%508 = add nsw i32 %507, -1
store i32 %508, i32* %8
br label %422
509: ; preds = %422
%510 = load double*, double** %15
%511 = call i32 @free(double* %510)
store i32 0, i32* %4
br label %512
512: ; preds = %509, %440, %204
%513 = load i32, i32* %4
ret i32 %513
}

LLVM IR (-O2):
@str = [30 x i8] c"LU: No unique solution exist.\00"
@str.2 = [44 x i8] c"LU: matrix is singular, no unique solution.\00"
define i32 @NUM_lu(double* nocapture %0, double* nocapture %1, i32 %2) {
%4 = tail call i64 @calloc(i32 %2, i32 4)
%5 = inttoptr i64 %4 to i32*
%6 = tail call i64 @calloc(i32 %2, i32 8)
%7 = inttoptr i64 %6 to double*
%8 = icmp sgt i32 %2, 0
br i1 %8, label %11, label %9
9: ; preds = %3
%10 = add i32 %2, -1
br label %103
11: ; preds = %3
%12 = zext i32 %2 to i64
%13 = icmp ult i32 %2, 4
br i1 %13, label %67, label %14
14: ; preds = %11
%15 = and i64 %12, 4294967292
%16 = add nsw i64 %15, -4
%17 = lshr exact i64 %16, 2
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %51, label %21
21: ; preds = %14
%22 = and i64 %18, 9223372036854775806
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %47, %23 ]
%25 = phi <2 x i32> [ <i32 0, i32 1>, %21 ], [ %48, %23 ]
%26 = phi i64 [ 0, %21 ], [ %49, %23 ]
%27 = add <2 x i32> %25, <i32 2, i32 2>
%28 = getelementptr inbounds double, double* %1, i64 %24
%29 = bitcast double* %28 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %29
%30 = getelementptr inbounds double, double* %28, i64 2
%31 = bitcast double* %30 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %31
%32 = getelementptr inbounds i32, i32* %5, i64 %24
%33 = bitcast i32* %32 to <2 x i32>*
store <2 x i32> %25, <2 x i32>* %33
%34 = getelementptr inbounds i32, i32* %32, i64 2
%35 = bitcast i32* %34 to <2 x i32>*
store <2 x i32> %27, <2 x i32>* %35
%36 = or i64 %24, 4
%37 = add <2 x i32> %25, <i32 4, i32 4>
%38 = add <2 x i32> %25, <i32 6, i32 6>
%39 = getelementptr inbounds double, double* %1, i64 %36
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %40
%41 = getelementptr inbounds double, double* %39, i64 2
%42 = bitcast double* %41 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %42
%43 = getelementptr inbounds i32, i32* %5, i64 %36
%44 = bitcast i32* %43 to <2 x i32>*
store <2 x i32> %37, <2 x i32>* %44
%45 = getelementptr inbounds i32, i32* %43, i64 2
%46 = bitcast i32* %45 to <2 x i32>*
store <2 x i32> %38, <2 x i32>* %46
%47 = add nuw i64 %24, 8
%48 = add <2 x i32> %25, <i32 8, i32 8>
%49 = add i64 %26, 2
%50 = icmp eq i64 %49, %22
br i1 %50, label %51, label %23
51: ; preds = %23, %14
%52 = phi i64 [ 0, %14 ], [ %47, %23 ]
%53 = phi <2 x i32> [ <i32 0, i32 1>, %14 ], [ %48, %23 ]
%54 = icmp eq i64 %19, 0
br i1 %54, label %65, label %55
55: ; preds = %51
%56 = add <2 x i32> %53, <i32 2, i32 2>
%57 = getelementptr inbounds double, double* %1, i64 %52
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %58
%59 = getelementptr inbounds double, double* %57, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %60
%61 = getelementptr inbounds i32, i32* %5, i64 %52
%62 = bitcast i32* %61 to <2 x i32>*
store <2 x i32> %53, <2 x i32>* %62
%63 = getelementptr inbounds i32, i32* %61, i64 2
%64 = bitcast i32* %63 to <2 x i32>*
store <2 x i32> %56, <2 x i32>* %64
br label %65
65: ; preds = %51, %55
%66 = icmp eq i64 %15, %12
br i1 %66, label %69, label %67
67: ; preds = %11, %65
%68 = phi i64 [ 0, %11 ], [ %15, %65 ]
br label %78
69: ; preds = %78, %65
%70 = add i32 %2, -1
%71 = icmp sgt i32 %2, 1
br i1 %71, label %72, label %103
72: ; preds = %69
%73 = zext i32 %2 to i64
%74 = zext i32 %70 to i64
%75 = zext i32 %2 to i64
%76 = zext i32 %2 to i64
%77 = zext i32 %2 to i64
br label %88
78: ; preds = %67, %78
%79 = phi i64 [ %83, %78 ], [ %68, %67 ]
%80 = getelementptr inbounds double, double* %1, i64 %79
store double 0.000000e+00, double* %80
%81 = getelementptr inbounds i32, i32* %5, i64 %79
%82 = trunc i64 %79 to i32
store i32 %82, i32* %81
%83 = add nuw nsw i64 %79, 1
%84 = icmp eq i64 %83, %12
br i1 %84, label %69, label %78
85: ; preds = %281, %224
%86 = add nuw nsw i64 %89, 1
%87 = icmp eq i64 %225, %74
br i1 %87, label %102, label %88
88: ; preds = %72, %85
%89 = phi i64 [ 1, %72 ], [ %86, %85 ]
%90 = phi i64 [ 0, %72 ], [ %225, %85 ]
%91 = icmp ult i64 %90, %73
br i1 %91, label %94, label %92
92: ; preds = %88
%93 = trunc i64 %90 to i32
br label %202
94: ; preds = %88
%95 = icmp eq i64 %90, 0
%96 = trunc i64 %90 to i32
%97 = trunc i64 %90 to i32
%98 = and i64 %90, 1
%99 = icmp eq i64 %90, 1
%100 = and i64 %90, 9223372036854775806
%101 = icmp eq i64 %98, 0
br label %121
102: ; preds = %85
br i1 %71, label %109, label %103
103: ; preds = %69, %9, %102
%104 = phi i32 [ %70, %102 ], [ %10, %9 ], [ %70, %69 ]
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %5, i64 %105
%107 = load i32, i32* %106
%108 = mul nsw i32 %107, %2
br label %338
109: ; preds = %102
%110 = zext i32 %70 to i64
%111 = getelementptr inbounds i32, i32* %5, i64 %110
%112 = load i32, i32* %111
%113 = mul nsw i32 %112, %2
%114 = sext i32 %113 to i64
%115 = zext i32 %70 to i64
%116 = and i64 %115, 1
%117 = icmp eq i32 %70, 1
br i1 %117, label %321, label %118
118: ; preds = %109
%119 = and i64 %115, 4294967294
br label %291
120: ; preds = %174
br i1 %91, label %184, label %202
121: ; preds = %94, %174
%122 = phi i64 [ %90, %94 ], [ %182, %174 ]
%123 = getelementptr inbounds i32, i32* %5, i64 %122
%124 = load i32, i32* %123
%125 = mul nsw i32 %124, %2
br i1 %95, label %174, label %126
126: ; preds = %121
%127 = sext i32 %125 to i64
br i1 %99, label %158, label %128
128: ; preds = %126, %128
%129 = phi i64 [ %155, %128 ], [ 0, %126 ]
%130 = phi double [ %154, %128 ], [ 0.000000e+00, %126 ]
%131 = phi i64 [ %156, %128 ], [ 0, %126 ]
%132 = getelementptr inbounds i32, i32* %5, i64 %129
%133 = load i32, i32* %132
%134 = mul nsw i32 %133, %2
%135 = add nsw i32 %134, %96
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %0, i64 %136
%138 = load double, double* %137
%139 = add nsw i64 %129, %127
%140 = getelementptr inbounds double, double* %0, i64 %139
%141 = load double, double* %140
%142 = tail call double @llvm.fmuladd.f64(double %138, double %141, double %130)
%143 = or i64 %129, 1
%144 = getelementptr inbounds i32, i32* %5, i64 %143
%145 = load i32, i32* %144
%146 = mul nsw i32 %145, %2
%147 = add nsw i32 %146, %96
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %0, i64 %148
%150 = load double, double* %149
%151 = add nsw i64 %143, %127
%152 = getelementptr inbounds double, double* %0, i64 %151
%153 = load double, double* %152
%154 = tail call double @llvm.fmuladd.f64(double %150, double %153, double %142)
%155 = add nuw nsw i64 %129, 2
%156 = add i64 %131, 2
%157 = icmp eq i64 %156, %100
br i1 %157, label %158, label %128
158: ; preds = %128, %126
%159 = phi double [ undef, %126 ], [ %154, %128 ]
%160 = phi i64 [ 0, %126 ], [ %155, %128 ]
%161 = phi double [ 0.000000e+00, %126 ], [ %154, %128 ]
br i1 %101, label %174, label %162
162: ; preds = %158
%163 = getelementptr inbounds i32, i32* %5, i64 %160
%164 = load i32, i32* %163
%165 = mul nsw i32 %164, %2
%166 = add nsw i32 %165, %96
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %0, i64 %167
%169 = load double, double* %168
%170 = add nsw i64 %160, %127
%171 = getelementptr inbounds double, double* %0, i64 %170
%172 = load double, double* %171
%173 = tail call double @llvm.fmuladd.f64(double %169, double %172, double %161)
br label %174
174: ; preds = %162, %158, %121
%175 = phi i32 [ 0, %121 ], [ %97, %158 ], [ %97, %162 ]
%176 = phi double [ 0.000000e+00, %121 ], [ %159, %158 ], [ %173, %162 ]
%177 = add nsw i32 %125, %175
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %0, i64 %178
%180 = load double, double* %179
%181 = fsub double %180, %176
store double %181, double* %179
%182 = add nuw nsw i64 %122, 1
%183 = icmp eq i64 %182, %75
br i1 %183, label %120, label %121
184: ; preds = %120, %184
%185 = phi i64 [ %200, %184 ], [ %90, %120 ]
%186 = phi double [ %199, %184 ], [ 0.000000e+00, %120 ]
%187 = phi i32 [ %198, %184 ], [ %175, %120 ]
%188 = getelementptr inbounds i32, i32* %5, i64 %185
%189 = load i32, i32* %188
%190 = mul nsw i32 %189, %2
%191 = add nsw i32 %190, %175
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %0, i64 %192
%194 = load double, double* %193
%195 = tail call double @llvm.fabs.f64(double %194)
%196 = fcmp olt double %186, %195
%197 = trunc i64 %185 to i32
%198 = select i1 %196, i32 %197, i32 %187
%199 = select i1 %196, double %195, double %186
%200 = add nuw nsw i64 %185, 1
%201 = icmp eq i64 %200, %76
br i1 %201, label %202, label %184
202: ; preds = %184, %92, %120
%203 = phi i32 [ %175, %120 ], [ %93, %92 ], [ %175, %184 ]
%204 = phi i32 [ %175, %120 ], [ %93, %92 ], [ %198, %184 ]
%205 = zext i32 %204 to i64
%206 = icmp eq i64 %90, %205
br i1 %206, label %213, label %207
207: ; preds = %202
%208 = getelementptr inbounds i32, i32* %5, i64 %90
%209 = load i32, i32* %208
%210 = sext i32 %204 to i64
%211 = getelementptr inbounds i32, i32* %5, i64 %210
%212 = load i32, i32* %211
store i32 %212, i32* %208
store i32 %209, i32* %211
br label %213
213: ; preds = %207, %202
%214 = getelementptr inbounds i32, i32* %5, i64 %90
%215 = load i32, i32* %214
%216 = mul nsw i32 %215, %2
%217 = add nsw i32 %216, %203
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %0, i64 %218
%220 = load double, double* %219
%221 = fcmp oeq double %220, 0.000000e+00
br i1 %221, label %222, label %224
222: ; preds = %213
%223 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @str.2, i64 0, i64 0))
br label %496
224: ; preds = %213
%225 = add nuw nsw i64 %90, 1
%226 = icmp ult i64 %225, %73
br i1 %226, label %227, label %85
227: ; preds = %224
%228 = sext i32 %216 to i64
%229 = and i64 %90, 1
%230 = icmp eq i64 %90, 1
%231 = and i64 %90, 9223372036854775806
%232 = icmp eq i64 %229, 0
br label %233
233: ; preds = %227, %281
%234 = phi i64 [ %89, %227 ], [ %289, %281 ]
switch i64 %90, label %235 [
i64 0, label %281
i64 1, label %265
]
235: ; preds = %233, %235
%236 = phi i64 [ %262, %235 ], [ 0, %233 ]
%237 = phi double [ %261, %235 ], [ 0.000000e+00, %233 ]
%238 = phi i64 [ %263, %235 ], [ 0, %233 ]
%239 = getelementptr inbounds i32, i32* %5, i64 %236
%240 = load i32, i32* %239
%241 = mul nsw i32 %240, %2
%242 = sext i32 %241 to i64
%243 = add nsw i64 %234, %242
%244 = getelementptr inbounds double, double* %0, i64 %243
%245 = load double, double* %244
%246 = add nsw i64 %236, %228
%247 = getelementptr inbounds double, double* %0, i64 %246
%248 = load double, double* %247
%249 = tail call double @llvm.fmuladd.f64(double %245, double %248, double %237)
%250 = or i64 %236, 1
%251 = getelementptr inbounds i32, i32* %5, i64 %250
%252 = load i32, i32* %251
%253 = mul nsw i32 %252, %2
%254 = sext i32 %253 to i64
%255 = add nsw i64 %234, %254
%256 = getelementptr inbounds double, double* %0, i64 %255
%257 = load double, double* %256
%258 = add nsw i64 %250, %228
%259 = getelementptr inbounds double, double* %0, i64 %258
%260 = load double, double* %259
%261 = tail call double @llvm.fmuladd.f64(double %257, double %260, double %249)
%262 = add nuw nsw i64 %236, 2
%263 = add i64 %238, 2
%264 = icmp eq i64 %263, %231
br i1 %264, label %265, label %235
265: ; preds = %235, %233
%266 = phi double [ undef, %233 ], [ %261, %235 ]
%267 = phi i64 [ 0, %233 ], [ %262, %235 ]
%268 = phi double [ 0.000000e+00, %233 ], [ %261, %235 ]
br i1 %232, label %281, label %269
269: ; preds = %265
%270 = getelementptr inbounds i32, i32* %5, i64 %267
%271 = load i32, i32* %270
%272 = mul nsw i32 %271, %2
%273 = sext i32 %272 to i64
%274 = add nsw i64 %234, %273
%275 = getelementptr inbounds double, double* %0, i64 %274
%276 = load double, double* %275
%277 = add nsw i64 %267, %228
%278 = getelementptr inbounds double, double* %0, i64 %277
%279 = load double, double* %278
%280 = tail call double @llvm.fmuladd.f64(double %276, double %279, double %268)
br label %281
281: ; preds = %269, %265, %233
%282 = phi double [ 0.000000e+00, %233 ], [ %266, %265 ], [ %280, %269 ]
%283 = add nsw i64 %234, %228
%284 = getelementptr inbounds double, double* %0, i64 %283
%285 = load double, double* %284
%286 = fsub double %285, %282
%287 = load double, double* %219
%288 = fdiv double %286, %287
store double %288, double* %284
%289 = add nuw nsw i64 %234, 1
%290 = icmp eq i64 %289, %77
br i1 %290, label %85, label %233
291: ; preds = %291, %118
%292 = phi i64 [ 0, %118 ], [ %318, %291 ]
%293 = phi double [ 0.000000e+00, %118 ], [ %317, %291 ]
%294 = phi i64 [ 0, %118 ], [ %319, %291 ]
%295 = getelementptr inbounds i32, i32* %5, i64 %292
%296 = load i32, i32* %295
%297 = mul nsw i32 %296, %2
%298 = add nsw i32 %297, %70
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %0, i64 %299
%301 = load double, double* %300
%302 = add nsw i64 %292, %114
%303 = getelementptr inbounds double, double* %0, i64 %302
%304 = load double, double* %303
%305 = tail call double @llvm.fmuladd.f64(double %301, double %304, double %293)
%306 = or i64 %292, 1
%307 = getelementptr inbounds i32, i32* %5, i64 %306
%308 = load i32, i32* %307
%309 = mul nsw i32 %308, %2
%310 = add nsw i32 %309, %70
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %0, i64 %311
%313 = load double, double* %312
%314 = add nsw i64 %306, %114
%315 = getelementptr inbounds double, double* %0, i64 %314
%316 = load double, double* %315
%317 = tail call double @llvm.fmuladd.f64(double %313, double %316, double %305)
%318 = add nuw nsw i64 %292, 2
%319 = add i64 %294, 2
%320 = icmp eq i64 %319, %119
br i1 %320, label %321, label %291
321: ; preds = %291, %109
%322 = phi double [ undef, %109 ], [ %317, %291 ]
%323 = phi i64 [ 0, %109 ], [ %318, %291 ]
%324 = phi double [ 0.000000e+00, %109 ], [ %317, %291 ]
%325 = icmp eq i64 %116, 0
br i1 %325, label %338, label %326
326: ; preds = %321
%327 = getelementptr inbounds i32, i32* %5, i64 %323
%328 = load i32, i32* %327
%329 = mul nsw i32 %328, %2
%330 = add nsw i32 %329, %70
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %0, i64 %331
%333 = load double, double* %332
%334 = add nsw i64 %323, %114
%335 = getelementptr inbounds double, double* %0, i64 %334
%336 = load double, double* %335
%337 = tail call double @llvm.fmuladd.f64(double %333, double %336, double %324)
br label %338
338: ; preds = %326, %321, %103
%339 = phi i32 [ %104, %103 ], [ %70, %321 ], [ %70, %326 ]
%340 = phi i32 [ %108, %103 ], [ %113, %321 ], [ %113, %326 ]
%341 = phi double [ 0.000000e+00, %103 ], [ %322, %321 ], [ %337, %326 ]
%342 = add nsw i32 %340, %339
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %0, i64 %343
%345 = load double, double* %344
%346 = fsub double %345, %341
store double %346, double* %344
br i1 %8, label %347, label %494
347: ; preds = %338
%348 = mul nsw i32 %2, %2
%349 = zext i32 %348 to i64
%350 = zext i32 %2 to i64
br label %351
351: ; preds = %347, %408
%352 = phi i64 [ 0, %347 ], [ %415, %408 ]
%353 = icmp eq i64 %352, 0
br i1 %353, label %408, label %354
354: ; preds = %351
%355 = trunc i64 %352 to i32
%356 = and i64 %352, 1
%357 = icmp eq i64 %352, 1
br i1 %357, label %392, label %358
358: ; preds = %354
%359 = and i64 %352, 9223372036854775806
br label %364
360: ; preds = %408
br i1 %8, label %361, label %494
361: ; preds = %360
%362 = zext i32 %2 to i64
%363 = zext i32 %339 to i64
br label %417
364: ; preds = %364, %358
%365 = phi i64 [ 0, %358 ], [ %389, %364 ]
%366 = phi double [ 0.000000e+00, %358 ], [ %388, %364 ]
%367 = phi i64 [ 0, %358 ], [ %390, %364 ]
%368 = getelementptr inbounds i32, i32* %5, i64 %365
%369 = load i32, i32* %368
%370 = mul nsw i32 %369, %2
%371 = add nsw i32 %370, %355
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %0, i64 %372
%374 = load double, double* %373
%375 = getelementptr inbounds double, double* %7, i64 %365
%376 = load double, double* %375
%377 = tail call double @llvm.fmuladd.f64(double %374, double %376, double %366)
%378 = or i64 %365, 1
%379 = getelementptr inbounds i32, i32* %5, i64 %378
%380 = load i32, i32* %379
%381 = mul nsw i32 %380, %2
%382 = add nsw i32 %381, %355
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds double, double* %0, i64 %383
%385 = load double, double* %384
%386 = getelementptr inbounds double, double* %7, i64 %378
%387 = load double, double* %386
%388 = tail call double @llvm.fmuladd.f64(double %385, double %387, double %377)
%389 = add nuw nsw i64 %365, 2
%390 = add i64 %367, 2
%391 = icmp eq i64 %390, %359
br i1 %391, label %392, label %364
392: ; preds = %364, %354
%393 = phi double [ undef, %354 ], [ %388, %364 ]
%394 = phi i64 [ 0, %354 ], [ %389, %364 ]
%395 = phi double [ 0.000000e+00, %354 ], [ %388, %364 ]
%396 = icmp eq i64 %356, 0
br i1 %396, label %408, label %397
397: ; preds = %392
%398 = getelementptr inbounds i32, i32* %5, i64 %394
%399 = load i32, i32* %398
%400 = mul nsw i32 %399, %2
%401 = add nsw i32 %400, %355
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %0, i64 %402
%404 = load double, double* %403
%405 = getelementptr inbounds double, double* %7, i64 %394
%406 = load double, double* %405
%407 = tail call double @llvm.fmuladd.f64(double %404, double %406, double %395)
br label %408
408: ; preds = %397, %392, %351
%409 = phi double [ 0.000000e+00, %351 ], [ %393, %392 ], [ %407, %397 ]
%410 = add nuw nsw i64 %352, %349
%411 = getelementptr inbounds double, double* %0, i64 %410
%412 = load double, double* %411
%413 = fsub double %412, %409
%414 = getelementptr inbounds double, double* %7, i64 %352
store double %413, double* %414
%415 = add nuw nsw i64 %352, 1
%416 = icmp eq i64 %415, %350
br i1 %416, label %360, label %351
417: ; preds = %361, %483
%418 = phi i64 [ 0, %361 ], [ %493, %483 ]
%419 = phi i64 [ %363, %361 ], [ %492, %483 ]
%420 = phi i64 [ %362, %361 ], [ %421, %483 ]
%421 = add nsw i64 %420, -1
%422 = getelementptr inbounds i32, i32* %5, i64 %419
%423 = load i32, i32* %422
%424 = mul nsw i32 %423, %2
%425 = trunc i64 %419 to i32
%426 = add nsw i32 %424, %425
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %0, i64 %427
%429 = load double, double* %428
%430 = fcmp oeq double %429, 0.000000e+00
br i1 %430, label %453, label %431
431: ; preds = %417
%432 = icmp slt i64 %419, %362
br i1 %432, label %433, label %483
433: ; preds = %431
%434 = and i64 %418, 1
%435 = icmp eq i64 %434, 0
br i1 %435, label %436, label %448
436: ; preds = %433
%437 = getelementptr inbounds i32, i32* %5, i64 %421
%438 = load i32, i32* %437
%439 = mul nsw i32 %438, %2
%440 = add nsw i32 %439, %425
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds double, double* %0, i64 %441
%443 = load double, double* %442
%444 = sext i32 %438 to i64
%445 = getelementptr inbounds double, double* %1, i64 %444
%446 = load double, double* %445
%447 = tail call double @llvm.fmuladd.f64(double %443, double %446, double 0.000000e+00)
br label %448
448: ; preds = %436, %433
%449 = phi double [ undef, %433 ], [ %447, %436 ]
%450 = phi i64 [ %421, %433 ], [ %420, %436 ]
%451 = phi double [ 0.000000e+00, %433 ], [ %447, %436 ]
%452 = icmp eq i64 %418, 0
br i1 %452, label %483, label %455
453: ; preds = %417
%454 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
br label %496
455: ; preds = %448, %455
%456 = phi i64 [ %481, %455 ], [ %450, %448 ]
%457 = phi double [ %480, %455 ], [ %451, %448 ]
%458 = getelementptr inbounds i32, i32* %5, i64 %456
%459 = load i32, i32* %458
%460 = mul nsw i32 %459, %2
%461 = add nsw i32 %460, %425
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %0, i64 %462
%464 = load double, double* %463
%465 = sext i32 %459 to i64
%466 = getelementptr inbounds double, double* %1, i64 %465
%467 = load double, double* %466
%468 = tail call double @llvm.fmuladd.f64(double %464, double %467, double %457)
%469 = add nsw i64 %456, 1
%470 = getelementptr inbounds i32, i32* %5, i64 %469
%471 = load i32, i32* %470
%472 = mul nsw i32 %471, %2
%473 = add nsw i32 %472, %425
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %0, i64 %474
%476 = load double, double* %475
%477 = sext i32 %471 to i64
%478 = getelementptr inbounds double, double* %1, i64 %477
%479 = load double, double* %478
%480 = tail call double @llvm.fmuladd.f64(double %476, double %479, double %468)
%481 = add nsw i64 %456, 2
%482 = icmp eq i64 %481, %362
br i1 %482, label %483, label %455
483: ; preds = %448, %455, %431
%484 = phi double [ 0.000000e+00, %431 ], [ %449, %448 ], [ %480, %455 ]
%485 = getelementptr inbounds double, double* %7, i64 %419
%486 = load double, double* %485
%487 = fsub double %486, %484
%488 = fdiv double %487, %429
%489 = sext i32 %423 to i64
%490 = getelementptr inbounds double, double* %1, i64 %489
store double %488, double* %490
%491 = icmp sgt i64 %419, 0
%492 = add nsw i64 %419, -1
%493 = add i64 %418, 1
br i1 %491, label %417, label %494
494: ; preds = %483, %338, %360
%495 = tail call i32 @free(double* %7)
br label %496
496: ; preds = %494, %453, %222
%497 = phi i32 [ 2, %222 ], [ 2, %453 ], [ 0, %494 ]
ret i32 %497
}