#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 */
double DBL_EPSILON;
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(void *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(double *, double *, int);
int /*<<< orphan*/ stderr;
int dAx_eq_b_LU_noLapack(double *A, double *B, double *x, int m) {
  void *buf = NULL;
  int buf_sz = 0;
  register int i, j, k;
  int *idx, maxi = -1, idx_sz, a_sz, work_sz, tot_sz;
  double *a, *work, max, sum, tmp;
  if (!A)
    return 1;
  idx_sz = m;
  a_sz = m * m;
  work_sz = m;
  tot_sz = (a_sz + work_sz) * sizeof(double) + idx_sz * sizeof(int);
  buf_sz = tot_sz;
  buf = (void *)malloc(tot_sz);
  if (!buf) {
    fprintf(stderr, "memory allocation in "
                    "dAx_eq_b_LU_noLapack"
                    "() failed!\n");
    exit(1);
  }
  a = buf;
  work = a + a_sz;
  idx = (int *)(work + work_sz);
  memcpy(a, A, a_sz * sizeof(double));
  memcpy(x, B, m * sizeof(double));
  for (i = 0; i < m; ++i) {
    max = 0.0;
    for (j = 0; j < m; ++j)
      if ((tmp = (((a[i * m + j]) >= 0.0) ? (a[i * m + j]) : -(a[i * m + j]))) >
          max)
        max = tmp;
    if (max == 0.0) {
      fprintf(stderr, "Singular matrix A in "
                      "dAx_eq_b_LU_noLapack"
                      "()!\n");
      free(buf);
      return 0;
    }
    work[i] = (1.0) / max;
  }
  for (j = 0; j < m; ++j) {
    for (i = 0; i < j; ++i) {
      sum = a[i * m + j];
      for (k = 0; k < i; ++k)
        sum -= a[i * m + k] * a[k * m + j];
      a[i * m + j] = sum;
    }
    max = 0.0;
    for (i = j; i < m; ++i) {
      sum = a[i * m + j];
      for (k = 0; k < j; ++k)
        sum -= a[i * m + k] * a[k * m + j];
      a[i * m + j] = sum;
      if ((tmp = work[i] * (((sum) >= 0.0) ? (sum) : -(sum))) >= max) {
        max = tmp;
        maxi = i;
      }
    }
    if (j != maxi) {
      for (k = 0; k < m; ++k) {
        tmp = a[maxi * m + k];
        a[maxi * m + k] = a[j * m + k];
        a[j * m + k] = tmp;
      }
      work[maxi] = work[j];
    }
    idx[j] = maxi;
    if (a[j * m + j] == 0.0)
      a[j * m + j] = DBL_EPSILON;
    if (j != m - 1) {
      tmp = (1.0) / (a[j * m + j]);
      for (i = j + 1; i < m; ++i)
        a[i * m + j] *= tmp;
    }
  }
  for (i = k = 0; i < m; ++i) {
    j = idx[i];
    sum = x[j];
    x[j] = x[i];
    if (k != 0)
      for (j = k - 1; j < i; ++j)
        sum -= a[i * m + j] * x[j];
    else if (sum != 0.0)
      k = i + 1;
    x[i] = sum;
  }
  for (i = m - 1; i >= 0; --i) {
    sum = x[i];
    for (j = i + 1; j < m; ++j)
      sum -= a[i * m + j] * x[j];
    x[i] = sum / a[i * m + i];
  }
  free(buf);
  return 1;
}


x86 assembly (clang, -O0):
<dAx_eq_b_LU_noLapack>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movq   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1197 <dAx_eq_b_LU_noLapack+0x47>
movl   $0x1,-0x4(%rbp)
jmp    1990 <dAx_eq_b_LU_noLapack+0x840>
mov    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
cltq
shl    $0x3,%rax
movslq -0x50(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x5c(%rbp),%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1203 <dAx_eq_b_LU_noLapack+0xb3>
mov    0x2ded(%rip),%rax
mov    (%rax),%edi
lea    0xe14(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x30(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x54(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movslq -0x24(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13ad <dAx_eq_b_LU_noLapack+0x25d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1343 <dAx_eq_b_LU_noLapack+0x1f3>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12d3 <dAx_eq_b_LU_noLapack+0x183>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1308 <dAx_eq_b_LU_noLapack+0x1b8>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
ucomisd -0x78(%rbp),%xmm0
jbe    1330 <dAx_eq_b_LU_noLapack+0x1e0>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1335 <dAx_eq_b_LU_noLapack+0x1e5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1281 <dAx_eq_b_LU_noLapack+0x131>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1385 <dAx_eq_b_LU_noLapack+0x235>
jp     1385 <dAx_eq_b_LU_noLapack+0x235>
mov    0x2c76(%rip),%rax
mov    (%rax),%edi
lea    0xcd2(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1990 <dAx_eq_b_LU_noLapack+0x840>
movsd  0xc73(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1266 <dAx_eq_b_LU_noLapack+0x116>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1799 <dAx_eq_b_LU_noLapack+0x649>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    148d <dAx_eq_b_LU_noLapack+0x33d>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1464 <dAx_eq_b_LU_noLapack+0x314>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13f5 <dAx_eq_b_LU_noLapack+0x2a5>
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13c7 <dAx_eq_b_LU_noLapack+0x277>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15fd <dAx_eq_b_LU_noLapack+0x4ad>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1538 <dAx_eq_b_LU_noLapack+0x3e8>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14c9 <dAx_eq_b_LU_noLapack+0x379>
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     158c <dAx_eq_b_LU_noLapack+0x43c>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    15b0 <dAx_eq_b_LU_noLapack+0x460>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
ucomisd -0x78(%rbp),%xmm0
jb     15ea <dAx_eq_b_LU_noLapack+0x49a>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    15ef <dAx_eq_b_LU_noLapack+0x49f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    149b <dAx_eq_b_LU_noLapack+0x34b>
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     16ac <dAx_eq_b_LU_noLapack+0x55c>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1692 <dAx_eq_b_LU_noLapack+0x542>
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1610 <dAx_eq_b_LU_noLapack+0x4c0>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1704 <dAx_eq_b_LU_noLapack+0x5b4>
jp     1704 <dAx_eq_b_LU_noLapack+0x5b4>
mov    0x28fe(%rip),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1786 <dAx_eq_b_LU_noLapack+0x636>
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x8d2(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1781 <dAx_eq_b_LU_noLapack+0x631>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1744 <dAx_eq_b_LU_noLapack+0x5f4>
jmp    1786 <dAx_eq_b_LU_noLapack+0x636>
jmp    178b <dAx_eq_b_LU_noLapack+0x63b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b4 <dAx_eq_b_LU_noLapack+0x264>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18b6 <dAx_eq_b_LU_noLapack+0x766>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x40(%rbp)
je     186b <dAx_eq_b_LU_noLapack+0x71b>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1866 <dAx_eq_b_LU_noLapack+0x716>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1800 <dAx_eq_b_LU_noLapack+0x6b0>
jmp    1896 <dAx_eq_b_LU_noLapack+0x746>
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1888 <dAx_eq_b_LU_noLapack+0x738>
jp     1888 <dAx_eq_b_LU_noLapack+0x738>
jmp    1891 <dAx_eq_b_LU_noLapack+0x741>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1896 <dAx_eq_b_LU_noLapack+0x746>
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17a7 <dAx_eq_b_LU_noLapack+0x657>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1980 <dAx_eq_b_LU_noLapack+0x830>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    194a <dAx_eq_b_LU_noLapack+0x7fa>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18e4 <dAx_eq_b_LU_noLapack+0x794>
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    18bf <dAx_eq_b_LU_noLapack+0x76f>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dAx_eq_b_LU_noLapack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
test   %rdi,%rdi
je     183f <dAx_eq_b_LU_noLapack+0x6ef>
mov    %ecx,%ebp
mov    %rsi,%r12
mov    %rdi,%r14
mov    %rdx,0x18(%rsp)
mov    %ecx,%r15d
imul   %r15d,%r15d
lea    (%r15,%rbp,1),%eax
lea    0x0(,%rbp,4),%ecx
lea    (%rcx,%rax,8),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     19fc <dAx_eq_b_LU_noLapack+0x8ac>
mov    %rax,%rbx
lea    0x0(,%r15,8),%edx
mov    %rax,%rdi
mov    %r14,%rsi
call   1050 <memcpy@plt>
lea    0x0(,%rbp,8),%edx
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   1050 <memcpy@plt>
mov    $0x1,%r12d
test   %ebp,%ebp
jle    185f <dAx_eq_b_LU_noLapack+0x70f>
mov    %rbp,%r14
movslq %r14d,%r8
mov    %r15d,%eax
lea    (%rbx,%rax,8),%rax
mov    %rax,0x10(%rsp)
lea    (%rax,%r8,8),%rax
mov    %rax,0x30(%rsp)
mov    %r14d,%eax
mov    %eax,%esi
and    $0xfffffffe,%esi
lea    0x8(%rbx),%rbp
lea    0x0(,%r8,8),%r10
xor    %edi,%edi
xorpd  %xmm2,%xmm2
movsd  0xe00(%rip),%xmm8
movapd 0xde8(%rip),%xmm1
movapd 0xde0(%rip),%xmm3
mov    %rax,(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x1,%r14d
jne    1240 <dAx_eq_b_LU_noLapack+0xf0>
xor    %ecx,%ecx
xorpd  %xmm4,%xmm4
jmp    12a7 <dAx_eq_b_LU_noLapack+0x157>
xchg   %ax,%ax
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rcx,8),%xmm5
movsd  0x0(%rbp,%rcx,8),%xmm6
movapd %xmm5,%xmm7
xorpd  %xmm3,%xmm7
xorpd  %xmm0,%xmm0
cmpnlesd %xmm5,%xmm0
andpd  %xmm0,%xmm7
andnpd %xmm5,%xmm0
orpd   %xmm7,%xmm0
maxsd  %xmm4,%xmm0
movapd %xmm6,%xmm5
xorpd  %xmm3,%xmm5
xorpd  %xmm4,%xmm4
cmpnlesd %xmm6,%xmm4
andpd  %xmm4,%xmm5
andnpd %xmm6,%xmm4
orpd   %xmm5,%xmm4
maxsd  %xmm0,%xmm4
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1250 <dAx_eq_b_LU_noLapack+0x100>
test   $0x1,%al
je     12e3 <dAx_eq_b_LU_noLapack+0x193>
mov    %rdi,%rax
imul   %r8,%rax
add    %rax,%rcx
mov    (%rsp),%rax
movsd  (%rbx,%rcx,8),%xmm0
movapd %xmm0,%xmm5
xorpd  %xmm1,%xmm5
xorpd  %xmm6,%xmm6
cmpnlesd %xmm0,%xmm6
andpd  %xmm6,%xmm5
andnpd %xmm0,%xmm6
orpd   %xmm5,%xmm6
maxsd  %xmm4,%xmm6
movapd %xmm6,%xmm4
ucomisd %xmm2,%xmm4
jne    12ef <dAx_eq_b_LU_noLapack+0x19f>
jnp    1847 <dAx_eq_b_LU_noLapack+0x6f7>
movapd %xmm8,%xmm0
divsd  %xmm4,%xmm0
mov    0x10(%rsp),%rcx
movsd  %xmm0,(%rcx,%rdi,8)
add    $0x1,%rdi
add    %r10,%rbp
cmp    %rax,%rdi
jne    1230 <dAx_eq_b_LU_noLapack+0xe0>
test   %r14d,%r14d
jle    185f <dAx_eq_b_LU_noLapack+0x70f>
lea    -0x1(%r14),%ecx
mov    %rcx,0x70(%rsp)
lea    (%rbx,%rax,8),%rsi
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x58(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x50(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x48(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x40(%rsp)
neg    %rax
mov    %rax,0x68(%rsp)
lea    0x8(%rbx),%rax
mov    %rax,0x8(%rsp)
lea    (%rbx,%r8,8),%r11
lea    (%r8,%r8,1),%r12
lea    0x30(%rbx),%rax
mov    %rax,0x38(%rsp)
mov    $0xffffffff,%r9d
mov    $0x1,%r13d
xor    %r15d,%r15d
xorpd  %xmm2,%xmm2
mov    %r8,0x20(%rsp)
mov    %r14,0x78(%rsp)
mov    %rsi,0x60(%rsp)
jmp    13c0 <dAx_eq_b_LU_noLapack+0x270>
nopl   (%rax)
add    $0x1,%r15
mov    %r15,%rcx
mov    (%rsp),%rax
add    $0x1,%r13
add    %r8,0x20(%rsp)
mov    %rcx,%r15
cmp    %rax,%rcx
je     187c <dAx_eq_b_LU_noLapack+0x72c>
test   %r15,%r15
je     1480 <dAx_eq_b_LU_noLapack+0x330>
mov    0x8(%rsp),%rsi
xor    %ecx,%ecx
jmp    13f6 <dAx_eq_b_LU_noLapack+0x2a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm3,(%rbx,%r14,8)
add    $0x1,%rcx
add    %r10,%rsi
cmp    %r15,%rcx
je     1480 <dAx_eq_b_LU_noLapack+0x330>
mov    %rcx,%rax
imul   %r8,%rax
lea    (%rax,%r15,1),%r14
movsd  (%rbx,%r14,8),%xmm3
test   %rcx,%rcx
je     13e0 <dAx_eq_b_LU_noLapack+0x290>
cmp    $0x1,%rcx
jne    1420 <dAx_eq_b_LU_noLapack+0x2d0>
xor    %edx,%edx
jmp    145a <dAx_eq_b_LU_noLapack+0x30a>
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    %r15,%rbp
xor    %edx,%edx
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  (%rbx,%rbp,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm4
subsd  %xmm0,%xmm3
mulsd  (%r11,%rbp,8),%xmm4
subsd  %xmm4,%xmm3
add    $0x2,%rdx
add    %r12,%rbp
cmp    %rdx,%rdi
jne    1430 <dAx_eq_b_LU_noLapack+0x2e0>
test   $0x1,%cl
je     13e0 <dAx_eq_b_LU_noLapack+0x290>
add    %rdx,%rax
movsd  (%rbx,%rax,8),%xmm0
imul   %r8,%rdx
add    %r15,%rdx
mulsd  (%rbx,%rdx,8),%xmm0
subsd  %xmm0,%xmm3
jmp    13e0 <dAx_eq_b_LU_noLapack+0x290>
nopl   0x0(%rax)
mov    %r13,0x80(%rsp)
mov    %r15,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r8,%rcx
imul   %r15,%rcx
mov    0x8(%rsp),%rax
mov    %rcx,0x28(%rsp)
lea    (%rax,%rcx,8),%r13
xorpd  %xmm3,%xmm3
mov    %r13,%rsi
mov    %r15,%r14
mov    (%rsp),%rax
jmp    1522 <dAx_eq_b_LU_noLapack+0x3d2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm4,(%rbx,%rdi,8)
movapd %xmm4,%xmm0
xorpd  %xmm1,%xmm0
xorpd  %xmm5,%xmm5
cmplesd %xmm4,%xmm5
andpd  %xmm5,%xmm4
andnpd %xmm0,%xmm5
orpd   %xmm4,%xmm5
mov    0x10(%rsp),%rcx
mulsd  (%rcx,%r14,8),%xmm5
ucomisd %xmm3,%xmm5
cmovae %r14d,%r9d
movapd %xmm3,%xmm0
cmpnlesd %xmm5,%xmm0
movapd %xmm0,%xmm4
andnpd %xmm5,%xmm4
andpd  %xmm3,%xmm0
orpd   %xmm4,%xmm0
add    $0x1,%r14
add    %r10,%rsi
movapd %xmm0,%xmm3
cmp    %rax,%r14
je     15c0 <dAx_eq_b_LU_noLapack+0x470>
mov    %r14,%rcx
imul   %r8,%rcx
lea    (%rcx,%r15,1),%rdi
movsd  (%rbx,%rdi,8),%xmm4
test   %r15,%r15
je     14c0 <dAx_eq_b_LU_noLapack+0x370>
cmp    $0x1,%r15
jne    1550 <dAx_eq_b_LU_noLapack+0x400>
xor    %edx,%edx
jmp    158a <dAx_eq_b_LU_noLapack+0x43a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm5
subsd  %xmm0,%xmm4
mulsd  (%r11,%rax,8),%xmm5
subsd  %xmm5,%xmm4
add    $0x2,%rdx
add    %r12,%rax
cmp    %rdx,%rbp
jne    1560 <dAx_eq_b_LU_noLapack+0x410>
test   $0x1,%r15b
mov    (%rsp),%rax
je     14c0 <dAx_eq_b_LU_noLapack+0x370>
add    %rdx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
imul   %r8,%rdx
add    %r15,%rdx
mulsd  (%rbx,%rdx,8),%xmm0
subsd  %xmm0,%xmm4
jmp    14c0 <dAx_eq_b_LU_noLapack+0x370>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%eax
cmp    %rax,%r15
mov    0x78(%rsp),%r14
je     179e <dAx_eq_b_LU_noLapack+0x64e>
mov    %r9d,%eax
imul   %r14d,%eax
movslq %eax,%rsi
cmp    $0x4,%r14d
jae    1600 <dAx_eq_b_LU_noLapack+0x4b0>
xor    %ecx,%ecx
mov    (%rsp),%rdx
mov    0x28(%rsp),%rbp
jmp    1700 <dAx_eq_b_LU_noLapack+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rsi,8),%rax
mov    0x60(%rsp),%rdx
mov    0x28(%rsp),%rbp
lea    (%rdx,%rbp,8),%rcx
cmp    %rcx,%rax
jae    162f <dAx_eq_b_LU_noLapack+0x4df>
lea    (%rdx,%rsi,8),%rax
lea    (%rbx,%rbp,8),%rcx
cmp    %rax,%rcx
jae    162f <dAx_eq_b_LU_noLapack+0x4df>
xor    %ecx,%ecx
mov    (%rsp),%rdx
jmp    1700 <dAx_eq_b_LU_noLapack+0x5b0>
cmpq   $0x0,0x50(%rsp)
je     182d <dAx_eq_b_LU_noLapack+0x6dd>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rsi,8),%rax
lea    (%rcx,%rbp,8),%rdx
mov    0x40(%rsp),%rdi
xor    %ecx,%ecx
nop
movups -0x30(%rax,%rcx,8),%xmm0
movups -0x20(%rax,%rcx,8),%xmm3
movups -0x30(%rdx,%rcx,8),%xmm4
movups -0x20(%rdx,%rcx,8),%xmm5
movups %xmm4,-0x30(%rax,%rcx,8)
movups %xmm5,-0x20(%rax,%rcx,8)
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm3,-0x20(%rdx,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm3
movupd -0x10(%rdx,%rcx,8),%xmm4
movupd (%rdx,%rcx,8),%xmm5
movupd %xmm4,-0x10(%rax,%rcx,8)
movupd %xmm5,(%rax,%rcx,8)
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm3,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1650 <dAx_eq_b_LU_noLapack+0x500>
testb  $0x1,0x48(%rsp)
je     16e8 <dAx_eq_b_LU_noLapack+0x598>
lea    (%rcx,%rsi,1),%rax
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm3
add    %rbp,%rcx
movupd (%rbx,%rcx,8),%xmm4
movupd 0x10(%rbx,%rcx,8),%xmm5
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
movupd %xmm0,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
mov    0x58(%rsp),%rax
mov    %rax,%rcx
mov    (%rsp),%rdx
cmp    %rdx,%rax
je     178b <dAx_eq_b_LU_noLapack+0x63b>
nopl   (%rax)
mov    %rcx,%rax
test   $0x1,%dl
je     172a <dAx_eq_b_LU_noLapack+0x5da>
lea    (%rcx,%rsi,1),%rax
movsd  (%rbx,%rax,8),%xmm0
add    %rcx,%rbp
movsd  (%rbx,%rbp,8),%xmm3
movsd  %xmm3,(%rbx,%rax,8)
movsd  %xmm0,(%rbx,%rbp,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x68(%rsp),%rcx
mov    (%rsp),%rdx
je     178b <dAx_eq_b_LU_noLapack+0x63b>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  -0x8(%r13,%rax,8),%xmm3
movsd  %xmm3,-0x8(%rcx,%rax,8)
movsd  %xmm0,-0x8(%r13,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
movsd  0x0(%r13,%rax,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1750 <dAx_eq_b_LU_noLapack+0x600>
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm0
movslq %r9d,%rax
movsd  %xmm0,(%rcx,%rax,8)
mov    0x30(%rsp),%rax
mov    %r9d,(%rax,%r15,4)
mov    %r15d,%eax
imul   %r14d,%eax
cltq
add    %r15,%rax
movsd  (%rbx,%rax,8),%xmm4
ucomisd %xmm2,%xmm4
jne    17d0 <dAx_eq_b_LU_noLapack+0x680>
jp     17d0 <dAx_eq_b_LU_noLapack+0x680>
mov    0x2821(%rip),%rcx
movsd  (%rcx),%xmm4
movsd  %xmm4,(%rbx,%rax,8)
cmp    0x70(%rsp),%r15
mov    0x80(%rsp),%r13
je     13a0 <dAx_eq_b_LU_noLapack+0x250>
lea    0x1(%r15),%rcx
cmp    %r8,%rcx
jge    13a7 <dAx_eq_b_LU_noLapack+0x257>
movapd %xmm8,%xmm3
divsd  %xmm4,%xmm3
add    0x20(%rsp),%r15
lea    (%rbx,%r15,8),%rax
mov    (%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rax)
add    %r10,%rax
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%r13
jne    1810 <dAx_eq_b_LU_noLapack+0x6c0>
jmp    13a7 <dAx_eq_b_LU_noLapack+0x257>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    16b5 <dAx_eq_b_LU_noLapack+0x565>
jmp    16e8 <dAx_eq_b_LU_noLapack+0x598>
mov    $0x1,%r12d
jmp    1867 <dAx_eq_b_LU_noLapack+0x717>
mov    0x278a(%rip),%rax
mov    (%rax),%edi
lea    0x7f6(%rip),%rsi
call   1040 <fprintf@plt>
xor    %r12d,%r12d
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r14d,%r14d
mov    $0x1,%r12d
jle    185f <dAx_eq_b_LU_noLapack+0x70f>
xor    %esi,%esi
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
xor    %edx,%edx
mov    0x18(%rsp),%rbp
jmp    18c1 <dAx_eq_b_LU_noLapack+0x771>
nopl   0x0(%rax)
ucomisd %xmm0,%xmm1
jne    18a8 <dAx_eq_b_LU_noLapack+0x758>
jnp    191d <dAx_eq_b_LU_noLapack+0x7cd>
lea    0x1(%rsi),%edx
mov    (%rsp),%rax
movsd  %xmm1,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
add    %r10,%rdi
cmp    %rax,%rsi
je     1921 <dAx_eq_b_LU_noLapack+0x7d1>
mov    0x30(%rsp),%rax
movslq (%rax,%rsi,4),%rax
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x0(%rbp,%rsi,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rax,8)
test   %edx,%edx
je     18a0 <dAx_eq_b_LU_noLapack+0x750>
movslq %edx,%rax
cmp    %rax,%rsi
jl     18ab <dAx_eq_b_LU_noLapack+0x75b>
lea    -0x1(%rdx),%eax
cltq
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rax,8),%xmm2
mulsd  -0x8(%rbp,%rax,8),%xmm2
subsd  %xmm2,%xmm1
mov    %eax,%ecx
add    $0x1,%rax
cmp    %rsi,%rcx
jne    1900 <dAx_eq_b_LU_noLapack+0x7b0>
jmp    18ab <dAx_eq_b_LU_noLapack+0x75b>
xor    %edx,%edx
jmp    18ab <dAx_eq_b_LU_noLapack+0x75b>
test   %r14d,%r14d
jle    185f <dAx_eq_b_LU_noLapack+0x70f>
lea    -0x1(%r8),%rax
imul   %r8,%rax
lea    (%rbx,%rax,8),%rsi
add    $0x8,%rsi
neg    %r10
xor    %edi,%edi
mov    %r8,%r9
jmp    1978 <dAx_eq_b_LU_noLapack+0x828>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9d,%eax
imul   %r14d,%eax
cltq
add    %r9,%rax
divsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r9,8)
add    $0x1,%edi
add    %r10,%rsi
cmp    $0x1,%rcx
jle    185f <dAx_eq_b_LU_noLapack+0x70f>
mov    %r9,%rcx
add    $0xffffffffffffffff,%r9
movsd  -0x8(%rbp,%rcx,8),%xmm0
cmp    %r8,%rcx
jge    1950 <dAx_eq_b_LU_noLapack+0x800>
test   $0x1,%dil
jne    19a0 <dAx_eq_b_LU_noLapack+0x850>
mov    %rcx,%rdx
jmp    19bd <dAx_eq_b_LU_noLapack+0x86d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9,%rax
imul   %r8,%rax
add    %rcx,%rax
movsd  (%rbx,%rax,8),%xmm1
mulsd  0x0(%rbp,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
lea    0x1(%rcx),%rdx
mov    (%rsp),%rax
cmp    $0x1,%edi
je     1950 <dAx_eq_b_LU_noLapack+0x800>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm1
movsd  (%rsi,%rdx,8),%xmm2
mulsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  0x8(%rbp,%rdx,8),%xmm2
subsd  %xmm1,%xmm0
subsd  %xmm2,%xmm0
add    $0x2,%rdx
cmp    %edx,%eax
jne    19d0 <dAx_eq_b_LU_noLapack+0x880>
jmp    1950 <dAx_eq_b_LU_noLapack+0x800>
mov    0x25d5(%rip),%rax
mov    (%rax),%edi
lea    0x60c(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>

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

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