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


x86 assembly (clang, -O0):
<sAx_eq_b_LU_noLapack>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0xffffffff,-0x3c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    119c <sAx_eq_b_LU_noLapack+0x5c>
cmpq   $0x0,0x2ed4(%rip)
je     1186 <sAx_eq_b_LU_noLapack+0x46>
mov    0x2ec7(%rip),%rdi
call   1030 <free@plt>
movl   $0x0,0x2ec0(%rip)
movl   $0x1,-0x4(%rbp)
jmp    19c4 <sAx_eq_b_LU_noLapack+0x884>
mov    -0x24(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x48(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x2e7a(%rip),%eax
jle    1240 <sAx_eq_b_LU_noLapack+0x100>
cmpq   $0x0,0x2e64(%rip)
je     11f6 <sAx_eq_b_LU_noLapack+0xb6>
mov    0x2e57(%rip),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,0x2e51(%rip)
mov    -0x4c(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,0x2e3a(%rip)
cmpq   $0x0,0x2e32(%rip)
jne    123b <sAx_eq_b_LU_noLapack+0xfb>
mov    0x2db5(%rip),%rax
mov    (%rax),%edi
lea    0xdd8(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
jmp    1240 <sAx_eq_b_LU_noLapack+0x100>
mov    0x2e01(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12c6 <sAx_eq_b_LU_noLapack+0x186>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1278 <sAx_eq_b_LU_noLapack+0x138>
jmp    12cb <sAx_eq_b_LU_noLapack+0x18b>
mov    -0x28(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12ff <sAx_eq_b_LU_noLapack+0x1bf>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12cb <sAx_eq_b_LU_noLapack+0x18b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1432 <sAx_eq_b_LU_noLapack+0x2f2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13cd <sAx_eq_b_LU_noLapack+0x28d>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1374 <sAx_eq_b_LU_noLapack+0x234>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    139c <sAx_eq_b_LU_noLapack+0x25c>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
ucomiss -0x64(%rbp),%xmm0
jbe    13ba <sAx_eq_b_LU_noLapack+0x27a>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    13bf <sAx_eq_b_LU_noLapack+0x27f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1321 <sAx_eq_b_LU_noLapack+0x1e1>
movss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    140a <sAx_eq_b_LU_noLapack+0x2ca>
jp     140a <sAx_eq_b_LU_noLapack+0x2ca>
mov    0x2be8(%rip),%rax
mov    (%rax),%edi
lea    0xc40(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    19c4 <sAx_eq_b_LU_noLapack+0x884>
movss  0xbee(%rip),%xmm0
divss  -0x64(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1306 <sAx_eq_b_LU_noLapack+0x1c6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17e6 <sAx_eq_b_LU_noLapack+0x6a6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1508 <sAx_eq_b_LU_noLapack+0x3c8>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14df <sAx_eq_b_LU_noLapack+0x39f>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    147a <sAx_eq_b_LU_noLapack+0x33a>
movss  -0x68(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    144c <sAx_eq_b_LU_noLapack+0x30c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1652 <sAx_eq_b_LU_noLapack+0x512>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15a9 <sAx_eq_b_LU_noLapack+0x469>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1544 <sAx_eq_b_LU_noLapack+0x404>
movss  -0x68(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15fb <sAx_eq_b_LU_noLapack+0x4bb>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1612 <sAx_eq_b_LU_noLapack+0x4d2>
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
ucomiss -0x64(%rbp),%xmm0
jb     163f <sAx_eq_b_LU_noLapack+0x4ff>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1644 <sAx_eq_b_LU_noLapack+0x504>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1516 <sAx_eq_b_LU_noLapack+0x3d6>
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     16fb <sAx_eq_b_LU_noLapack+0x5bb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16e1 <sAx_eq_b_LU_noLapack+0x5a1>
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1665 <sAx_eq_b_LU_noLapack+0x525>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1757 <sAx_eq_b_LU_noLapack+0x617>
jp     1757 <sAx_eq_b_LU_noLapack+0x617>
mov    0x28a3(%rip),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     17d3 <sAx_eq_b_LU_noLapack+0x693>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  0x87f(%rip),%xmm0
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17ce <sAx_eq_b_LU_noLapack+0x68e>
movss  -0x6c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1794 <sAx_eq_b_LU_noLapack+0x654>
jmp    17d3 <sAx_eq_b_LU_noLapack+0x693>
jmp    17d8 <sAx_eq_b_LU_noLapack+0x698>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1439 <sAx_eq_b_LU_noLapack+0x2f9>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18fd <sAx_eq_b_LU_noLapack+0x7bd>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x30(%rbp)
je     18ae <sAx_eq_b_LU_noLapack+0x76e>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18a9 <sAx_eq_b_LU_noLapack+0x769>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    184d <sAx_eq_b_LU_noLapack+0x70d>
jmp    18dd <sAx_eq_b_LU_noLapack+0x79d>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18cf <sAx_eq_b_LU_noLapack+0x78f>
jp     18cf <sAx_eq_b_LU_noLapack+0x78f>
jmp    18d8 <sAx_eq_b_LU_noLapack+0x798>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18dd <sAx_eq_b_LU_noLapack+0x79d>
movss  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17f4 <sAx_eq_b_LU_noLapack+0x6b4>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     19bd <sAx_eq_b_LU_noLapack+0x87d>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1987 <sAx_eq_b_LU_noLapack+0x847>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    192b <sAx_eq_b_LU_noLapack+0x7eb>
movss  -0x68(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1906 <sAx_eq_b_LU_noLapack+0x7c6>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sAx_eq_b_LU_noLapack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
test   %rdi,%rdi
je     11c9 <sAx_eq_b_LU_noLapack+0x89>
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
mov    %ecx,%r13d
imul   %r13d,%r13d
lea    0x0(%r13,%rcx,2),%ebp
shl    $0x2,%ebp
cmp    0x2edc(%rip),%ebp
mov    %rcx,0x10(%rsp)
jle    11ee <sAx_eq_b_LU_noLapack+0xae>
mov    0x2ec6(%rip),%rdi
test   %rdi,%rdi
je     118c <sAx_eq_b_LU_noLapack+0x4c>
call   1030 <free@plt>
mov    %ebp,0x2ebe(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ea8(%rip)
test   %rax,%rax
mov    0x10(%rsp),%rcx
jne    11f5 <sAx_eq_b_LU_noLapack+0xb5>
mov    0x2e27(%rip),%rax
mov    (%rax),%edi
lea    0xe5a(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    0x2e78(%rip),%rdi
test   %rdi,%rdi
je     11da <sAx_eq_b_LU_noLapack+0x9a>
call   1030 <free@plt>
movl   $0x0,0x2e6c(%rip)
mov    $0x1,%eax
jmp    1d26 <sAx_eq_b_LU_noLapack+0xbe6>
mov    0x2e53(%rip),%rax
movslq %ecx,%r10
mov    %rax,(%rsp)
lea    (%rax,%r10,4),%r8
mov    %r13d,%r14d
mov    %ecx,%eax
mov    %rax,0x8(%rsp)
test   %ecx,%ecx
jle    121a <sAx_eq_b_LU_noLapack+0xda>
cmp    $0x8,%ecx
jae    1221 <sAx_eq_b_LU_noLapack+0xe1>
xor    %edi,%edi
jmp    13ad <sAx_eq_b_LU_noLapack+0x26d>
xor    %edx,%edx
jmp    147f <sAx_eq_b_LU_noLapack+0x33f>
mov    0x8(%rsp),%rcx
lea    (%r10,%rcx,1),%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
lea    (%r15,%rcx,4),%rdi
lea    (%rbx,%rcx,4),%rsi
lea    (%r12,%rcx,4),%rbp
cmp    %rdi,%r8
setb   0x20(%rsp)
cmp    %r15,%rdx
seta   %r11b
cmp    %rsi,%r8
setb   %al
cmp    %rbx,%rdx
seta   %r9b
cmp    %rbp,%r8
mov    %r15,%rcx
setb   %r15b
cmp    %r12,%rdx
seta   0x38(%rsp)
cmp    %rcx,%rsi
seta   %dl
cmp    %rbx,%rdi
seta   0x30(%rsp)
mov    %rcx,0x18(%rsp)
cmp    %rcx,%rbp
seta   %sil
cmp    %r12,%rdi
seta   %bpl
xor    %edi,%edi
test   %r11b,0x20(%rsp)
jne    13a3 <sAx_eq_b_LU_noLapack+0x263>
and    %r9b,%al
mov    0x10(%rsp),%rcx
jne    13a8 <sAx_eq_b_LU_noLapack+0x268>
and    0x38(%rsp),%r15b
jne    13a8 <sAx_eq_b_LU_noLapack+0x268>
and    0x30(%rsp),%dl
mov    0x18(%rsp),%r15
jne    13ad <sAx_eq_b_LU_noLapack+0x26d>
and    %bpl,%sil
jne    13ad <sAx_eq_b_LU_noLapack+0x26d>
mov    0x8(%rsp),%rdi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rdx
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rdx,%rdx
je     139b <sAx_eq_b_LU_noLapack+0x25b>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
mov    (%rsp),%rdx
lea    (%rdx,%r10,4),%rbp
add    $0x30,%rbp
xor    %edx,%edx
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdx,4)
movups %xmm1,-0x20(%rbp,%rdx,4)
movups (%r12,%rdx,4),%xmm0
movups 0x10(%r12,%rdx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm0
movups 0x30(%rbx,%rdx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdx,4)
movups %xmm1,0x0(%rbp,%rdx,4)
movups 0x20(%r12,%rdx,4),%xmm0
movups 0x30(%r12,%rdx,4),%xmm1
movups %xmm0,0x20(%r15,%rdx,4)
movups %xmm1,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1300 <sAx_eq_b_LU_noLapack+0x1c0>
test   $0x1,%al
je     138d <sAx_eq_b_LU_noLapack+0x24d>
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%r8,%rdx,4)
movups %xmm1,0x10(%r8,%rdx,4)
movups (%r12,%rdx,4),%xmm0
movups 0x10(%r12,%rdx,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
mov    %ecx,%edx
cmp    0x8(%rsp),%rdi
jne    13ad <sAx_eq_b_LU_noLapack+0x26d>
jmp    147f <sAx_eq_b_LU_noLapack+0x33f>
xor    %edx,%edx
test   $0x1,%al
jne    1363 <sAx_eq_b_LU_noLapack+0x223>
jmp    138d <sAx_eq_b_LU_noLapack+0x24d>
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%r15
mov    %rdi,%rax
not    %rax
mov    0x8(%rsp),%rdx
add    %rdx,%rax
and    $0x3,%rdx
je     13f1 <sAx_eq_b_LU_noLapack+0x2b1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%r8,%rdi,4)
movss  (%r12,%rdi,4),%xmm0
movss  %xmm0,(%r15,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    13d0 <sAx_eq_b_LU_noLapack+0x290>
mov    %ecx,%edx
cmp    $0x3,%rax
jb     147f <sAx_eq_b_LU_noLapack+0x33f>
mov    (%rsp),%rax
lea    (%rax,%r10,4),%rax
add    $0xc,%rax
mov    0x8(%rsp),%rdx
xchg   %ax,%ax
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%r12,%rdi,4),%xmm0
movss  %xmm0,(%r15,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  0x4(%r12,%rdi,4),%xmm0
movss  %xmm0,0x4(%r15,%rdi,4)
movss  0x8(%rbx,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  0x8(%r12,%rdi,4),%xmm0
movss  %xmm0,0x8(%r15,%rdi,4)
movss  0xc(%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
movss  0xc(%r12,%rdi,4),%xmm0
movss  %xmm0,0xc(%r15,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1410 <sAx_eq_b_LU_noLapack+0x2d0>
mov    %ecx,%edx
cmp    %r13d,%edx
jae    16a7 <sAx_eq_b_LU_noLapack+0x567>
mov    %edx,%ebp
mov    %r14,%r11
sub    %rbp,%r11
cmp    $0x8,%r11
jb     15dc <sAx_eq_b_LU_noLapack+0x49c>
lea    (%r10,%rbp,1),%rax
mov    (%rsp),%rsi
lea    (%rsi,%rax,4),%rcx
lea    (%rbx,%r14,4),%rdx
cmp    %rdx,%rcx
jae    14c4 <sAx_eq_b_LU_noLapack+0x384>
lea    (%r10,%r14,1),%rcx
lea    (%rsi,%rcx,4),%rcx
lea    (%rbx,%rbp,4),%rdx
cmp    %rcx,%rdx
jb     15dc <sAx_eq_b_LU_noLapack+0x49c>
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%edi
and    $0x3,%edi
cmp    $0x18,%rcx
jae    14ec <sAx_eq_b_LU_noLapack+0x3ac>
xor    %esi,%esi
jmp    1578 <sAx_eq_b_LU_noLapack+0x438>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rdx
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rax
add    $0x70,%rax
lea    (%rbx,%rbp,4),%rcx
add    $0x70,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%rcx,%rsi,4),%xmm0
movups -0x60(%rcx,%rsi,4),%xmm1
movups %xmm0,-0x70(%rax,%rsi,4)
movups %xmm1,-0x60(%rax,%rsi,4)
movups -0x50(%rcx,%rsi,4),%xmm0
movups -0x40(%rcx,%rsi,4),%xmm1
movups %xmm0,-0x50(%rax,%rsi,4)
movups %xmm1,-0x40(%rax,%rsi,4)
movups -0x30(%rcx,%rsi,4),%xmm0
movups -0x20(%rcx,%rsi,4),%xmm1
movups %xmm0,-0x30(%rax,%rsi,4)
movups %xmm1,-0x20(%rax,%rsi,4)
movups -0x10(%rcx,%rsi,4),%xmm0
movups (%rcx,%rsi,4),%xmm1
movups %xmm0,-0x10(%rax,%rsi,4)
movups %xmm1,(%rax,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1520 <sAx_eq_b_LU_noLapack+0x3e0>
test   %rdi,%rdi
je     15cb <sAx_eq_b_LU_noLapack+0x48b>
lea    (%rsi,%r10,1),%rax
add    %rbp,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rax
add    $0x10,%rax
add    %rbp,%rsi
lea    (%rbx,%rsi,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    15b0 <sAx_eq_b_LU_noLapack+0x470>
cmp    %r9,%r11
mov    0x10(%rsp),%rcx
je     16a7 <sAx_eq_b_LU_noLapack+0x567>
add    %r9,%rbp
mov    %r14d,%edx
sub    %ebp,%edx
mov    %rbp,%rax
not    %rax
add    %r14,%rax
and    $0x7,%rdx
je     1620 <sAx_eq_b_LU_noLapack+0x4e0>
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%r8,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1600 <sAx_eq_b_LU_noLapack+0x4c0>
cmp    $0x7,%rax
jae    162b <sAx_eq_b_LU_noLapack+0x4eb>
jmp    16a7 <sAx_eq_b_LU_noLapack+0x567>
mov    0x10(%rsp),%rcx
cmp    $0x7,%rax
jb     16a7 <sAx_eq_b_LU_noLapack+0x567>
mov    (%rsp),%rax
lea    (%rax,%r10,4),%rax
add    $0x1c,%rax
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x1c(%rax,%rbp,4)
movss  0x4(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x18(%rax,%rbp,4)
movss  0x8(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x14(%rax,%rbp,4)
movss  0xc(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x10(%rax,%rbp,4)
movss  0x10(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0xc(%rax,%rbp,4)
movss  0x14(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x8(%rax,%rbp,4)
movss  0x18(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
movss  0x1c(%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%r14
jne    1640 <sAx_eq_b_LU_noLapack+0x500>
mov    $0x1,%eax
test   %ecx,%ecx
jle    1d26 <sAx_eq_b_LU_noLapack+0xbe6>
lea    (%r8,%r14,4),%rdx
mov    %rdx,0x20(%rsp)
mov    0x8(%rsp),%r9
mov    %r9d,%edi
and    $0xfffffffe,%edi
mov    (%rsp),%r14
lea    (%r14,%r10,4),%rbx
add    $0x4,%rbx
lea    0x0(,%r10,4),%rbp
xor    %r11d,%r11d
xorps  %xmm2,%xmm2
movss  0x926(%rip),%xmm0
movaps 0x90f(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%ecx
jne    1710 <sAx_eq_b_LU_noLapack+0x5d0>
xor    %edx,%edx
xorps  %xmm3,%xmm3
jmp    176a <sAx_eq_b_LU_noLapack+0x62a>
nopl   0x0(%rax)
xorps  %xmm3,%xmm3
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rbx,%rdx,4),%xmm4
movss  (%rbx,%rdx,4),%xmm5
movaps %xmm4,%xmm6
xorps  %xmm1,%xmm6
xorps  %xmm7,%xmm7
cmpnless %xmm4,%xmm7
andps  %xmm7,%xmm6
andnps %xmm4,%xmm7
orps   %xmm6,%xmm7
maxss  %xmm3,%xmm7
movaps %xmm5,%xmm4
xorps  %xmm1,%xmm4
xorps  %xmm3,%xmm3
cmpnless %xmm5,%xmm3
andps  %xmm3,%xmm4
andnps %xmm5,%xmm3
orps   %xmm4,%xmm3
maxss  %xmm7,%xmm3
add    $0x2,%rdx
cmp    %rdx,%rdi
jne    1720 <sAx_eq_b_LU_noLapack+0x5e0>
test   $0x1,%r9b
je     179e <sAx_eq_b_LU_noLapack+0x65e>
mov    %r11,%rsi
imul   %r10,%rsi
add    %rsi,%rdx
movss  (%r8,%rdx,4),%xmm4
movaps %xmm4,%xmm5
xorps  %xmm1,%xmm5
xorps  %xmm6,%xmm6
cmpnless %xmm4,%xmm6
andps  %xmm6,%xmm5
andnps %xmm4,%xmm6
orps   %xmm5,%xmm6
maxss  %xmm3,%xmm6
movaps %xmm6,%xmm3
ucomiss %xmm2,%xmm3
jne    17a9 <sAx_eq_b_LU_noLapack+0x669>
jnp    1d0f <sAx_eq_b_LU_noLapack+0xbcf>
movaps %xmm0,%xmm4
divss  %xmm3,%xmm4
mov    0x20(%rsp),%rdx
movss  %xmm4,(%rdx,%r11,4)
add    $0x1,%r11
add    %rbp,%rbx
cmp    %r9,%r11
jne    1700 <sAx_eq_b_LU_noLapack+0x5c0>
test   %ecx,%ecx
jle    1d26 <sAx_eq_b_LU_noLapack+0xbe6>
mov    %r15,0x18(%rsp)
lea    -0x1(%rcx),%eax
mov    %rax,0x90(%rsp)
lea    (%r14,%r10,4),%rax
mov    %rax,0x28(%rsp)
lea    (%r10,%r9,1),%rax
lea    (%r14,%rax,4),%rax
mov    %rax,0x70(%rsp)
lea    (%r14,%r9,4),%rax
mov    %rax,0x78(%rsp)
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x50(%rsp)
neg    %r9
mov    %r9,0x80(%rsp)
lea    (%r14,%r10,4),%rax
add    $0x4,%rax
mov    %rax,0x88(%rsp)
lea    0x0(,%r10,8),%r13
lea    0x4(%r14),%rax
mov    %rax,0x40(%rsp)
lea    0x30(%r14),%rax
mov    %rax,0x48(%rsp)
mov    $0xffffffff,%r12d
mov    $0x1,%esi
xorps  %xmm2,%xmm2
xor    %r15d,%r15d
mov    %r10,%rbx
jmp    189a <sAx_eq_b_LU_noLapack+0x75a>
nopl   (%rax)
add    $0x1,%r15
mov    %r15,%rcx
add    $0x1,%rsi
add    %r10,%rbx
mov    %rcx,%r15
cmp    %rdi,%rcx
je     1d38 <sAx_eq_b_LU_noLapack+0xbf8>
mov    %rbx,0x30(%rsp)
mov    %rsi,0x38(%rsp)
test   %r15,%r15
je     1960 <sAx_eq_b_LU_noLapack+0x820>
lea    (%r14,%r15,4),%r9
mov    0x88(%rsp),%rdi
xor    %edx,%edx
jmp    18d6 <sAx_eq_b_LU_noLapack+0x796>
nopl   (%rax)
movss  %xmm3,(%r8,%r11,4)
add    $0x1,%rdx
add    %rbp,%rdi
cmp    %r15,%rdx
je     1960 <sAx_eq_b_LU_noLapack+0x820>
mov    %rdx,%rax
imul   %r10,%rax
lea    (%rax,%r15,1),%r11
movss  (%r8,%r11,4),%xmm3
test   %rdx,%rdx
je     18c0 <sAx_eq_b_LU_noLapack+0x780>
cmp    $0x1,%rdx
jne    1900 <sAx_eq_b_LU_noLapack+0x7c0>
xor    %esi,%esi
jmp    193a <sAx_eq_b_LU_noLapack+0x7fa>
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,%rbx
and    $0xfffffffffffffffe,%rbx
mov    %r9,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movss  -0x4(%rdi,%rsi,4),%xmm4
mulss  (%rcx,%rbp,1),%xmm4
movss  (%rdi,%rsi,4),%xmm5
subss  %xmm4,%xmm3
mulss  (%rcx,%r13,1),%xmm5
add    %r13,%rcx
subss  %xmm5,%xmm3
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    1910 <sAx_eq_b_LU_noLapack+0x7d0>
test   $0x1,%dl
je     18c0 <sAx_eq_b_LU_noLapack+0x780>
add    %rsi,%rax
movss  (%r8,%rax,4),%xmm4
imul   %r10,%rsi
add    %r15,%rsi
mulss  (%r8,%rsi,4),%xmm4
subss  %xmm4,%xmm3
jmp    18c0 <sAx_eq_b_LU_noLapack+0x780>
xchg   %ax,%ax
mov    %r15,%r9
and    $0xfffffffffffffffe,%r9
lea    0x4(,%r15,4),%rcx
imul   %r10,%rcx
mov    %r14,%rax
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,1),%r14
lea    (%rax,%r15,4),%r11
xorps  %xmm3,%xmm3
mov    %r15,%rdi
jmp    19e7 <sAx_eq_b_LU_noLapack+0x8a7>
nopl   0x0(%rax,%rax,1)
movss  %xmm4,(%r8,%rbx,4)
movaps %xmm4,%xmm5
xorps  %xmm1,%xmm5
xorps  %xmm6,%xmm6
cmpless %xmm4,%xmm6
andps  %xmm6,%xmm4
andnps %xmm5,%xmm6
orps   %xmm4,%xmm6
mov    0x20(%rsp),%rax
mulss  (%rax,%rdi,4),%xmm6
ucomiss %xmm3,%xmm6
cmovae %edi,%r12d
movaps %xmm3,%xmm4
cmpnless %xmm6,%xmm4
movaps %xmm4,%xmm5
andnps %xmm6,%xmm5
andps  %xmm3,%xmm4
orps   %xmm5,%xmm4
add    $0x1,%rdi
add    %rbp,%r14
movaps %xmm4,%xmm3
cmp    0x8(%rsp),%rdi
je     1a80 <sAx_eq_b_LU_noLapack+0x940>
mov    %rdi,%rdx
imul   %r10,%rdx
lea    (%rdx,%r15,1),%rbx
movss  (%r8,%rbx,4),%xmm4
test   %r15,%r15
je     1990 <sAx_eq_b_LU_noLapack+0x850>
cmp    $0x1,%r15
jne    1a10 <sAx_eq_b_LU_noLapack+0x8d0>
xor    %esi,%esi
jmp    1a4c <sAx_eq_b_LU_noLapack+0x90c>
nopw   0x0(%rax,%rax,1)
mov    %r11,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%r14,%rsi,4),%xmm5
mulss  (%rax,%rbp,1),%xmm5
movss  (%r14,%rsi,4),%xmm6
subss  %xmm5,%xmm4
mulss  (%rax,%r13,1),%xmm6
add    %r13,%rax
subss  %xmm6,%xmm4
add    $0x2,%rsi
cmp    %rsi,%r9
jne    1a20 <sAx_eq_b_LU_noLapack+0x8e0>
test   $0x1,%r15b
je     1990 <sAx_eq_b_LU_noLapack+0x850>
add    %rsi,%rdx
movss  (%r8,%rdx,4),%xmm5
imul   %r10,%rsi
add    %r15,%rsi
mulss  (%r8,%rsi,4),%xmm5
subss  %xmm5,%xmm4
jmp    1990 <sAx_eq_b_LU_noLapack+0x850>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%eax
cmp    %rax,%r15
mov    0x10(%rsp),%r11
mov    0x8(%rsp),%rdi
je     1c73 <sAx_eq_b_LU_noLapack+0xb33>
mov    %r12d,%eax
imul   %r11d,%eax
mov    %r15,%r14
imul   %r10,%r14
movslq %eax,%r9
cmp    $0x8,%r11d
jb     1ae0 <sAx_eq_b_LU_noLapack+0x9a0>
mov    0x28(%rsp),%rax
lea    (%rax,%r9,4),%rax
mov    0x78(%rsp),%rdx
add    %rcx,%rdx
cmp    %rax,%rdx
jbe    1b78 <sAx_eq_b_LU_noLapack+0xa38>
mov    0x70(%rsp),%rax
lea    (%rax,%r9,4),%rax
mov    (%rsp),%rdx
add    %rcx,%rdx
cmp    %rax,%rdx
jae    1b78 <sAx_eq_b_LU_noLapack+0xa38>
xor    %eax,%eax
mov    %rax,%rdx
test   $0x1,%dil
je     1b11 <sAx_eq_b_LU_noLapack+0x9d1>
lea    (%rax,%r9,1),%rdx
movss  (%r8,%rdx,4),%xmm3
add    %rax,%r14
movss  (%r8,%r14,4),%xmm4
movss  %xmm4,(%r8,%rdx,4)
movss  %xmm3,(%r8,%r14,4)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0x80(%rsp),%rax
je     1c60 <sAx_eq_b_LU_noLapack+0xb20>
add    (%rsp),%rcx
mov    0x28(%rsp),%rax
lea    (%rax,%r9,4),%rax
lea    0x1(%r15),%rsi
imul   %r10,%rsi
mov    0x40(%rsp),%rbx
lea    (%rbx,%rsi,4),%rsi
movss  (%rax,%rdx,4),%xmm3
movss  (%rcx,%rdx,4),%xmm4
movss  %xmm4,(%rax,%rdx,4)
movss  %xmm3,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm3
movss  (%rsi,%rdx,4),%xmm4
movss  %xmm4,0x4(%rax,%rdx,4)
movss  %xmm3,(%rsi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rdi
jne    1b40 <sAx_eq_b_LU_noLapack+0xa00>
jmp    1c60 <sAx_eq_b_LU_noLapack+0xb20>
cmpq   $0x0,0x60(%rsp)
je     1cfd <sAx_eq_b_LU_noLapack+0xbbd>
mov    0x28(%rsp),%rax
lea    (%rax,%r9,4),%rax
add    $0x30,%rax
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,1),%rsi
mov    0x50(%rsp),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%rdx,4),%xmm3
movups -0x20(%rax,%rdx,4),%xmm4
movups -0x30(%rsi,%rdx,4),%xmm5
movups -0x20(%rsi,%rdx,4),%xmm6
movups %xmm5,-0x30(%rax,%rdx,4)
movups %xmm6,-0x20(%rax,%rdx,4)
movups %xmm3,-0x30(%rsi,%rdx,4)
movups %xmm4,-0x20(%rsi,%rdx,4)
movups -0x10(%rax,%rdx,4),%xmm3
movups (%rax,%rdx,4),%xmm4
movups -0x10(%rsi,%rdx,4),%xmm5
movups (%rsi,%rdx,4),%xmm6
movups %xmm5,-0x10(%rax,%rdx,4)
movups %xmm6,(%rax,%rdx,4)
movups %xmm3,-0x10(%rsi,%rdx,4)
movups %xmm4,(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    1bb0 <sAx_eq_b_LU_noLapack+0xa70>
testb  $0x1,0x58(%rsp)
je     1c40 <sAx_eq_b_LU_noLapack+0xb00>
lea    (%rdx,%r9,1),%rax
movups (%r8,%rax,4),%xmm3
movups 0x10(%r8,%rax,4),%xmm4
add    %r14,%rdx
movups (%r8,%rdx,4),%xmm5
movups 0x10(%r8,%rdx,4),%xmm6
movups %xmm5,(%r8,%rax,4)
movups %xmm6,0x10(%r8,%rax,4)
movups %xmm3,(%r8,%rdx,4)
movups %xmm4,0x10(%r8,%rdx,4)
mov    0x68(%rsp),%rdx
mov    %rdx,%rax
cmp    %rdi,%rdx
jne    1ae2 <sAx_eq_b_LU_noLapack+0x9a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
movss  (%rcx,%r15,4),%xmm3
movslq %r12d,%rax
movss  %xmm3,(%rcx,%rax,4)
mov    (%rsp),%r14
mov    %r12d,(%r14,%r15,4)
mov    %r15d,%eax
imul   %r11d,%eax
cltq
add    %r15,%rax
movss  (%r8,%rax,4),%xmm4
ucomiss %xmm2,%xmm4
mov    0x38(%rsp),%rsi
mov    0x30(%rsp),%rbx
jne    1caf <sAx_eq_b_LU_noLapack+0xb6f>
jp     1caf <sAx_eq_b_LU_noLapack+0xb6f>
mov    0x233b(%rip),%rcx
movss  (%rcx),%xmm4
movss  %xmm4,(%r8,%rax,4)
cmp    0x90(%rsp),%r15
je     1880 <sAx_eq_b_LU_noLapack+0x740>
lea    0x1(%r15),%rcx
cmp    %r10,%rcx
jge    1887 <sAx_eq_b_LU_noLapack+0x747>
movaps %xmm0,%xmm3
divss  %xmm4,%xmm3
add    %rbx,%r15
mov    0x28(%rsp),%rax
lea    (%rax,%r15,4),%rax
mov    %rdi,%rdx
movss  (%rax),%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,(%rax)
add    %rbp,%rax
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rsi
jne    1ce0 <sAx_eq_b_LU_noLapack+0xba0>
jmp    1887 <sAx_eq_b_LU_noLapack+0x747>
xor    %edx,%edx
testb  $0x1,0x58(%rsp)
jne    1c0d <sAx_eq_b_LU_noLapack+0xacd>
jmp    1c40 <sAx_eq_b_LU_noLapack+0xb00>
mov    0x22c2(%rip),%rax
mov    (%rax),%edi
lea    0x32a(%rip),%rsi
call   1040 <fprintf@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r11d,%r11d
jle    11e4 <sAx_eq_b_LU_noLapack+0xa4>
xor    %eax,%eax
xorps  %xmm0,%xmm0
mov    %r8,%rcx
xor    %r9d,%r9d
mov    0x18(%rsp),%rbx
jmp    1d7c <sAx_eq_b_LU_noLapack+0xc3c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomiss %xmm0,%xmm1
jne    1d67 <sAx_eq_b_LU_noLapack+0xc27>
jnp    1dcd <sAx_eq_b_LU_noLapack+0xc8d>
lea    0x1(%rax),%r9d
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
add    %rbp,%rcx
cmp    %rdi,%rax
je     1dd2 <sAx_eq_b_LU_noLapack+0xc92>
movslq (%r14,%rax,4),%rdx
movss  (%rbx,%rdx,4),%xmm1
movss  (%rbx,%rax,4),%xmm2
movss  %xmm2,(%rbx,%rdx,4)
test   %r9d,%r9d
je     1d60 <sAx_eq_b_LU_noLapack+0xc20>
movslq %r9d,%rdx
cmp    %rdx,%rax
jl     1d6b <sAx_eq_b_LU_noLapack+0xc2b>
lea    -0x1(%r9),%edx
movslq %edx,%rdx
add    $0x1,%rdx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rdx,4),%xmm2
mulss  -0x4(%rbx,%rdx,4),%xmm2
subss  %xmm2,%xmm1
mov    %edx,%esi
add    $0x1,%rdx
cmp    %rax,%rsi
jne    1db0 <sAx_eq_b_LU_noLapack+0xc70>
jmp    1d6b <sAx_eq_b_LU_noLapack+0xc2b>
xor    %r9d,%r9d
jmp    1d6b <sAx_eq_b_LU_noLapack+0xc2b>
test   %r11d,%r11d
jle    11e4 <sAx_eq_b_LU_noLapack+0xa4>
mov    %r10,%rax
imul   %r10,%rax
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
neg    %rbp
xor    %ecx,%ecx
mov    %r10,%r9
jmp    1e29 <sAx_eq_b_LU_noLapack+0xce9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9d,%edx
imul   %r11d,%edx
movslq %edx,%rdx
add    %r9,%rdx
divss  (%r8,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%r9,4)
add    $0x1,%ecx
add    %rbp,%rax
cmp    $0x1,%rsi
jle    11e4 <sAx_eq_b_LU_noLapack+0xa4>
mov    %r9,%rsi
add    $0xffffffffffffffff,%r9
movss  -0x4(%rbx,%rsi,4),%xmm0
cmp    %r10,%rsi
jge    1e00 <sAx_eq_b_LU_noLapack+0xcc0>
test   $0x1,%cl
jne    1e50 <sAx_eq_b_LU_noLapack+0xd10>
mov    %rsi,%rdx
cmp    $0x1,%ecx
jne    1e80 <sAx_eq_b_LU_noLapack+0xd40>
jmp    1e00 <sAx_eq_b_LU_noLapack+0xcc0>
nopw   0x0(%rax,%rax,1)
mov    %r9,%rdx
imul   %r10,%rdx
add    %rsi,%rdx
movss  (%r8,%rdx,4),%xmm1
mulss  (%rbx,%rsi,4),%xmm1
subss  %xmm1,%xmm0
lea    0x1(%rsi),%rdx
cmp    $0x1,%ecx
je     1e00 <sAx_eq_b_LU_noLapack+0xcc0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rax,%rdx,4),%xmm1
movss  (%rax,%rdx,4),%xmm2
mulss  (%rbx,%rdx,4),%xmm1
mulss  0x4(%rbx,%rdx,4),%xmm2
subss  %xmm1,%xmm0
subss  %xmm2,%xmm0
add    $0x2,%rdx
cmp    %edx,%edi
jne    1e80 <sAx_eq_b_LU_noLapack+0xd40>
jmp    1e00 <sAx_eq_b_LU_noLapack+0xcc0>

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

LLVM IR (-O2):
@sAx_eq_b_LU_noLapack.buf = internal unnamed_addr global i8* null
@sAx_eq_b_LU_noLapack.buf_sz = internal unnamed_addr global i32 0
@stderr = global i32 0
@.str = [53 x i8] c"memory allocation in sAx_eq_b_LU_noLapack() failed!\0A\00"
@.str.1 = [46 x i8] c"Singular matrix A in sAx_eq_b_LU_noLapack()!\0A\00"
@FLT_EPSILON = global float 0.000000e+00
define i32 @sAx_eq_b_LU_noLapack(float* %0, float* nocapture %1, float* nocapture %2, i32 %3) {
%5 = icmp eq float* %0, null
br i1 %5, label %6, label %12
6: ; preds = %4
%7 = load i8*, i8** @sAx_eq_b_LU_noLapack.buf
%8 = icmp eq i8* %7, null
br i1 %8, label %11, label %9
9: ; preds = %6
%10 = tail call i32 @free(i8* %7)
br label %11
11: ; preds = %9, %6
store i32 0, i32* @sAx_eq_b_LU_noLapack.buf_sz
br label %886
12: ; preds = %4
%13 = mul i32 %3, %3
%14 = sext i32 %3 to i64
%15 = shl i32 %3, 1
%16 = add i32 %13, %15
%17 = shl i32 %16, 2
%18 = load i32, i32* @sAx_eq_b_LU_noLapack.buf_sz
%19 = icmp sgt i32 %17, %18
br i1 %19, label %22, label %20
20: ; preds = %12
%21 = load i32*, i32** bitcast (i8** @sAx_eq_b_LU_noLapack.buf to i32**)
br label %36
22: ; preds = %12
%23 = load i8*, i8** @sAx_eq_b_LU_noLapack.buf
%24 = icmp eq i8* %23, null
br i1 %24, label %27, label %25
25: ; preds = %22
%26 = tail call i32 @free(i8* %23)
br label %27
27: ; preds = %25, %22
store i32 %17, i32* @sAx_eq_b_LU_noLapack.buf_sz
%28 = tail call i64 @malloc(i32 %17)
%29 = inttoptr i64 %28 to i8*
store i8* %29, i8** @sAx_eq_b_LU_noLapack.buf
%30 = icmp eq i64 %28, 0
%31 = inttoptr i64 %28 to i32*
br i1 %30, label %32, label %36
32: ; preds = %27
%33 = load i32, i32* @stderr
%34 = tail call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str, i64 0, i64 0))
%35 = tail call i32 @exit(i32 1)
unreachable
36: ; preds = %20, %27
%37 = phi i32* [ %21, %20 ], [ %31, %27 ]
%38 = bitcast i32* %37 to i8*
%39 = getelementptr i32, i32* %37, i64 %14
%40 = zext i32 %13 to i64
%41 = getelementptr inbounds i32, i32* %39, i64 %40
%42 = icmp sgt i32 %3, 0
br i1 %42, label %43, label %181
43: ; preds = %36
%44 = zext i32 %3 to i64
%45 = icmp ult i32 %3, 8
br i1 %45, label %159, label %46
46: ; preds = %43
%47 = add nsw i64 %14, %44
%48 = getelementptr i32, i32* %37, i64 %47
%49 = getelementptr float, float* %2, i64 %44
%50 = getelementptr float, float* %0, i64 %44
%51 = getelementptr float, float* %1, i64 %44
%52 = bitcast float* %49 to i32*
%53 = icmp ult i32* %39, %52
%54 = bitcast i32* %48 to float*
%55 = icmp ugt float* %54, %2
%56 = and i1 %53, %55
%57 = bitcast float* %50 to i32*
%58 = icmp ult i32* %39, %57
%59 = bitcast i32* %48 to float*
%60 = icmp ugt float* %59, %0
%61 = and i1 %58, %60
%62 = or i1 %56, %61
%63 = bitcast float* %51 to i32*
%64 = icmp ult i32* %39, %63
%65 = bitcast i32* %48 to float*
%66 = icmp ugt float* %65, %1
%67 = and i1 %64, %66
%68 = or i1 %62, %67
%69 = icmp ugt float* %50, %2
%70 = icmp ugt float* %49, %0
%71 = and i1 %69, %70
%72 = or i1 %68, %71
%73 = icmp ugt float* %51, %2
%74 = icmp ugt float* %49, %1
%75 = and i1 %73, %74
%76 = or i1 %72, %75
br i1 %76, label %159, label %77
77: ; preds = %46
%78 = and i64 %44, 4294967288
%79 = add nsw i64 %78, -8
%80 = lshr exact i64 %79, 3
%81 = add nuw nsw i64 %80, 1
%82 = and i64 %81, 1
%83 = icmp eq i64 %79, 0
br i1 %83, label %133, label %84
84: ; preds = %77
%85 = and i64 %81, 4611686018427387902
br label %86
86: ; preds = %86, %84
%87 = phi i64 [ 0, %84 ], [ %130, %86 ]
%88 = phi i64 [ 0, %84 ], [ %131, %86 ]
%89 = getelementptr inbounds float, float* %0, i64 %87
%90 = bitcast float* %89 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = getelementptr inbounds float, float* %89, i64 4
%93 = bitcast float* %92 to <4 x float>*
%94 = load <4 x float>, <4 x float>* %93
%95 = getelementptr inbounds i32, i32* %39, i64 %87
%96 = bitcast i32* %95 to <4 x float>*
store <4 x float> %91, <4 x float>* %96
%97 = getelementptr inbounds i32, i32* %95, i64 4
%98 = bitcast i32* %97 to <4 x float>*
store <4 x float> %94, <4 x float>* %98
%99 = getelementptr inbounds float, float* %1, i64 %87
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = getelementptr inbounds float, float* %99, i64 4
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %2, i64 %87
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %101, <4 x float>* %106
%107 = getelementptr inbounds float, float* %105, i64 4
%108 = bitcast float* %107 to <4 x float>*
store <4 x float> %104, <4 x float>* %108
%109 = or i64 %87, 8
%110 = getelementptr inbounds float, float* %0, i64 %109
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = getelementptr inbounds float, float* %110, i64 4
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = getelementptr inbounds i32, i32* %39, i64 %109
%117 = bitcast i32* %116 to <4 x float>*
store <4 x float> %112, <4 x float>* %117
%118 = getelementptr inbounds i32, i32* %116, i64 4
%119 = bitcast i32* %118 to <4 x float>*
store <4 x float> %115, <4 x float>* %119
%120 = getelementptr inbounds float, float* %1, i64 %109
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds float, float* %120, i64 4
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = getelementptr inbounds float, float* %2, i64 %109
%127 = bitcast float* %126 to <4 x float>*
store <4 x float> %122, <4 x float>* %127
%128 = getelementptr inbounds float, float* %126, i64 4
%129 = bitcast float* %128 to <4 x float>*
store <4 x float> %125, <4 x float>* %129
%130 = add nuw i64 %87, 16
%131 = add i64 %88, 2
%132 = icmp eq i64 %131, %85
br i1 %132, label %133, label %86
133: ; preds = %86, %77
%134 = phi i64 [ 0, %77 ], [ %130, %86 ]
%135 = icmp eq i64 %82, 0
br i1 %135, label %157, label %136
136: ; preds = %133
%137 = getelementptr inbounds float, float* %0, i64 %134
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = getelementptr inbounds float, float* %137, i64 4
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = getelementptr inbounds i32, i32* %39, i64 %134
%144 = bitcast i32* %143 to <4 x float>*
store <4 x float> %139, <4 x float>* %144
%145 = getelementptr inbounds i32, i32* %143, i64 4
%146 = bitcast i32* %145 to <4 x float>*
store <4 x float> %142, <4 x float>* %146
%147 = getelementptr inbounds float, float* %1, i64 %134
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %147, i64 4
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = getelementptr inbounds float, float* %2, i64 %134
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %149, <4 x float>* %154
%155 = getelementptr inbounds float, float* %153, i64 4
%156 = bitcast float* %155 to <4 x float>*
store <4 x float> %152, <4 x float>* %156
br label %157
157: ; preds = %133, %136
%158 = icmp eq i64 %78, %44
br i1 %158, label %181, label %159
159: ; preds = %46, %43, %157
%160 = phi i64 [ 0, %46 ], [ 0, %43 ], [ %78, %157 ]
%161 = xor i64 %160, -1
%162 = add nsw i64 %161, %44
%163 = and i64 %44, 3
%164 = icmp eq i64 %163, 0
br i1 %164, label %178, label %165
165: ; preds = %159, %165
%166 = phi i64 [ %175, %165 ], [ %160, %159 ]
%167 = phi i64 [ %176, %165 ], [ 0, %159 ]
%168 = getelementptr inbounds float, float* %0, i64 %166
%169 = load float, float* %168
%170 = getelementptr inbounds i32, i32* %39, i64 %166
%171 = bitcast i32* %170 to float*
store float %169, float* %171
%172 = getelementptr inbounds float, float* %1, i64 %166
%173 = load float, float* %172
%174 = getelementptr inbounds float, float* %2, i64 %166
store float %173, float* %174
%175 = add nuw nsw i64 %166, 1
%176 = add i64 %167, 1
%177 = icmp eq i64 %176, %163
br i1 %177, label %178, label %165
178: ; preds = %165, %159
%179 = phi i64 [ %160, %159 ], [ %175, %165 ]
%180 = icmp ult i64 %162, 3
br i1 %180, label %181, label %305
181: ; preds = %178, %305, %157, %36
%182 = phi i32 [ 0, %36 ], [ %3, %157 ], [ %3, %305 ], [ %3, %178 ]
%183 = icmp ult i32 %182, %13
br i1 %183, label %184, label %340
184: ; preds = %181
%185 = zext i32 %182 to i64
%186 = sub nsw i64 %40, %185
%187 = icmp ult i64 %186, 8
br i1 %187, label %285, label %188
188: ; preds = %184
%189 = add nsw i64 %14, %185
%190 = getelementptr i32, i32* %37, i64 %189
%191 = add nsw i64 %14, %40
%192 = getelementptr i32, i32* %37, i64 %191
%193 = getelementptr float, float* %0, i64 %185
%194 = getelementptr float, float* %0, i64 %40
%195 = bitcast float* %194 to i32*
%196 = icmp ult i32* %190, %195
%197 = bitcast i32* %192 to float*
%198 = icmp ult float* %193, %197
%199 = and i1 %196, %198
br i1 %199, label %285, label %200
200: ; preds = %188
%201 = and i64 %186, -8
%202 = add nsw i64 %201, %185
%203 = add nsw i64 %201, -8
%204 = lshr exact i64 %203, 3
%205 = add nuw nsw i64 %204, 1
%206 = and i64 %205, 3
%207 = icmp ult i64 %203, 24
br i1 %207, label %263, label %208
208: ; preds = %200
%209 = and i64 %205, 4611686018427387900
br label %210
210: ; preds = %210, %208
%211 = phi i64 [ 0, %208 ], [ %260, %210 ]
%212 = phi i64 [ 0, %208 ], [ %261, %210 ]
%213 = add i64 %211, %185
%214 = getelementptr inbounds float, float* %0, i64 %213
%215 = bitcast float* %214 to <4 x float>*
%216 = load <4 x float>, <4 x float>* %215
%217 = getelementptr inbounds float, float* %214, i64 4
%218 = bitcast float* %217 to <4 x float>*
%219 = load <4 x float>, <4 x float>* %218
%220 = getelementptr inbounds i32, i32* %39, i64 %213
%221 = bitcast i32* %220 to <4 x float>*
store <4 x float> %216, <4 x float>* %221
%222 = getelementptr inbounds i32, i32* %220, i64 4
%223 = bitcast i32* %222 to <4 x float>*
store <4 x float> %219, <4 x float>* %223
%224 = or i64 %211, 8
%225 = add i64 %224, %185
%226 = getelementptr inbounds float, float* %0, i64 %225
%227 = bitcast float* %226 to <4 x float>*
%228 = load <4 x float>, <4 x float>* %227
%229 = getelementptr inbounds float, float* %226, i64 4
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = getelementptr inbounds i32, i32* %39, i64 %225
%233 = bitcast i32* %232 to <4 x float>*
store <4 x float> %228, <4 x float>* %233
%234 = getelementptr inbounds i32, i32* %232, i64 4
%235 = bitcast i32* %234 to <4 x float>*
store <4 x float> %231, <4 x float>* %235
%236 = or i64 %211, 16
%237 = add i64 %236, %185
%238 = getelementptr inbounds float, float* %0, i64 %237
%239 = bitcast float* %238 to <4 x float>*
%240 = load <4 x float>, <4 x float>* %239
%241 = getelementptr inbounds float, float* %238, i64 4
%242 = bitcast float* %241 to <4 x float>*
%243 = load <4 x float>, <4 x float>* %242
%244 = getelementptr inbounds i32, i32* %39, i64 %237
%245 = bitcast i32* %244 to <4 x float>*
store <4 x float> %240, <4 x float>* %245
%246 = getelementptr inbounds i32, i32* %244, i64 4
%247 = bitcast i32* %246 to <4 x float>*
store <4 x float> %243, <4 x float>* %247
%248 = or i64 %211, 24
%249 = add i64 %248, %185
%250 = getelementptr inbounds float, float* %0, i64 %249
%251 = bitcast float* %250 to <4 x float>*
%252 = load <4 x float>, <4 x float>* %251
%253 = getelementptr inbounds float, float* %250, i64 4
%254 = bitcast float* %253 to <4 x float>*
%255 = load <4 x float>, <4 x float>* %254
%256 = getelementptr inbounds i32, i32* %39, i64 %249
%257 = bitcast i32* %256 to <4 x float>*
store <4 x float> %252, <4 x float>* %257
%258 = getelementptr inbounds i32, i32* %256, i64 4
%259 = bitcast i32* %258 to <4 x float>*
store <4 x float> %255, <4 x float>* %259
%260 = add nuw i64 %211, 32
%261 = add i64 %212, 4
%262 = icmp eq i64 %261, %209
br i1 %262, label %263, label %210
263: ; preds = %210, %200
%264 = phi i64 [ 0, %200 ], [ %260, %210 ]
%265 = icmp eq i64 %206, 0
br i1 %265, label %283, label %266
266: ; preds = %263, %266
%267 = phi i64 [ %280, %266 ], [ %264, %263 ]
%268 = phi i64 [ %281, %266 ], [ 0, %263 ]
%269 = add i64 %267, %185
%270 = getelementptr inbounds float, float* %0, i64 %269
%271 = bitcast float* %270 to <4 x float>*
%272 = load <4 x float>, <4 x float>* %271
%273 = getelementptr inbounds float, float* %270, i64 4
%274 = bitcast float* %273 to <4 x float>*
%275 = load <4 x float>, <4 x float>* %274
%276 = getelementptr inbounds i32, i32* %39, i64 %269
%277 = bitcast i32* %276 to <4 x float>*
store <4 x float> %272, <4 x float>* %277
%278 = getelementptr inbounds i32, i32* %276, i64 4
%279 = bitcast i32* %278 to <4 x float>*
store <4 x float> %275, <4 x float>* %279
%280 = add nuw i64 %267, 8
%281 = add i64 %268, 1
%282 = icmp eq i64 %281, %206
br i1 %282, label %283, label %266
283: ; preds = %266, %263
%284 = icmp eq i64 %186, %201
br i1 %284, label %340, label %285
285: ; preds = %188, %184, %283
%286 = phi i64 [ %185, %188 ], [ %185, %184 ], [ %202, %283 ]
%287 = sub nsw i64 %40, %286
%288 = xor i64 %286, -1
%289 = add nsw i64 %288, %40
%290 = and i64 %287, 7
%291 = icmp eq i64 %290, 0
br i1 %291, label %302, label %292
292: ; preds = %285, %292
%293 = phi i64 [ %299, %292 ], [ %286, %285 ]
%294 = phi i64 [ %300, %292 ], [ 0, %285 ]
%295 = getelementptr inbounds float, float* %0, i64 %293
%296 = load float, float* %295
%297 = getelementptr inbounds i32, i32* %39, i64 %293
%298 = bitcast i32* %297 to float*
store float %296, float* %298
%299 = add nuw nsw i64 %293, 1
%300 = add i64 %294, 1
%301 = icmp eq i64 %300, %290
br i1 %301, label %302, label %292
302: ; preds = %292, %285
%303 = phi i64 [ %286, %285 ], [ %299, %292 ]
%304 = icmp ult i64 %289, 7
br i1 %304, label %340, label %347
305: ; preds = %178, %305
%306 = phi i64 [ %338, %305 ], [ %179, %178 ]
%307 = getelementptr inbounds float, float* %0, i64 %306
%308 = load float, float* %307
%309 = getelementptr inbounds i32, i32* %39, i64 %306
%310 = bitcast i32* %309 to float*
store float %308, float* %310
%311 = getelementptr inbounds float, float* %1, i64 %306
%312 = load float, float* %311
%313 = getelementptr inbounds float, float* %2, i64 %306
store float %312, float* %313
%314 = add nuw nsw i64 %306, 1
%315 = getelementptr inbounds float, float* %0, i64 %314
%316 = load float, float* %315
%317 = getelementptr inbounds i32, i32* %39, i64 %314
%318 = bitcast i32* %317 to float*
store float %316, float* %318
%319 = getelementptr inbounds float, float* %1, i64 %314
%320 = load float, float* %319
%321 = getelementptr inbounds float, float* %2, i64 %314
store float %320, float* %321
%322 = add nuw nsw i64 %306, 2
%323 = getelementptr inbounds float, float* %0, i64 %322
%324 = load float, float* %323
%325 = getelementptr inbounds i32, i32* %39, i64 %322
%326 = bitcast i32* %325 to float*
store float %324, float* %326
%327 = getelementptr inbounds float, float* %1, i64 %322
%328 = load float, float* %327
%329 = getelementptr inbounds float, float* %2, i64 %322
store float %328, float* %329
%330 = add nuw nsw i64 %306, 3
%331 = getelementptr inbounds float, float* %0, i64 %330
%332 = load float, float* %331
%333 = getelementptr inbounds i32, i32* %39, i64 %330
%334 = bitcast i32* %333 to float*
store float %332, float* %334
%335 = getelementptr inbounds float, float* %1, i64 %330
%336 = load float, float* %335
%337 = getelementptr inbounds float, float* %2, i64 %330
store float %336, float* %337
%338 = add nuw nsw i64 %306, 4
%339 = icmp eq i64 %338, %44
br i1 %339, label %181, label %305
340: ; preds = %302, %347, %283, %181
br i1 %42, label %341, label %886
341: ; preds = %340
%342 = zext i32 %3 to i64
%343 = and i64 %342, 1
%344 = icmp eq i32 %3, 1
%345 = and i64 %342, 4294967294
%346 = icmp eq i64 %343, 0
br label %390
347: ; preds = %302, %347
%348 = phi i64 [ %388, %347 ], [ %303, %302 ]
%349 = getelementptr inbounds float, float* %0, i64 %348
%350 = load float, float* %349
%351 = getelementptr inbounds i32, i32* %39, i64 %348
%352 = bitcast i32* %351 to float*
store float %350, float* %352
%353 = add nuw nsw i64 %348, 1
%354 = getelementptr inbounds float, float* %0, i64 %353
%355 = load float, float* %354
%356 = getelementptr inbounds i32, i32* %39, i64 %353
%357 = bitcast i32* %356 to float*
store float %355, float* %357
%358 = add nuw nsw i64 %348, 2
%359 = getelementptr inbounds float, float* %0, i64 %358
%360 = load float, float* %359
%361 = getelementptr inbounds i32, i32* %39, i64 %358
%362 = bitcast i32* %361 to float*
store float %360, float* %362
%363 = add nuw nsw i64 %348, 3
%364 = getelementptr inbounds float, float* %0, i64 %363
%365 = load float, float* %364
%366 = getelementptr inbounds i32, i32* %39, i64 %363
%367 = bitcast i32* %366 to float*
store float %365, float* %367
%368 = add nuw nsw i64 %348, 4
%369 = getelementptr inbounds float, float* %0, i64 %368
%370 = load float, float* %369
%371 = getelementptr inbounds i32, i32* %39, i64 %368
%372 = bitcast i32* %371 to float*
store float %370, float* %372
%373 = add nuw nsw i64 %348, 5
%374 = getelementptr inbounds float, float* %0, i64 %373
%375 = load float, float* %374
%376 = getelementptr inbounds i32, i32* %39, i64 %373
%377 = bitcast i32* %376 to float*
store float %375, float* %377
%378 = add nuw nsw i64 %348, 6
%379 = getelementptr inbounds float, float* %0, i64 %378
%380 = load float, float* %379
%381 = getelementptr inbounds i32, i32* %39, i64 %378
%382 = bitcast i32* %381 to float*
store float %380, float* %382
%383 = add nuw nsw i64 %348, 7
%384 = getelementptr inbounds float, float* %0, i64 %383
%385 = load float, float* %384
%386 = getelementptr inbounds i32, i32* %39, i64 %383
%387 = bitcast i32* %386 to float*
store float %385, float* %387
%388 = add nuw nsw i64 %348, 8
%389 = icmp eq i64 %388, %40
br i1 %389, label %340, label %347
390: ; preds = %463, %341
%391 = phi i64 [ 0, %341 ], [ %467, %463 ]
%392 = mul nsw i64 %391, %14
br i1 %344, label %443, label %417
393: ; preds = %463
br i1 %42, label %394, label %886
394: ; preds = %393
%395 = add nsw i32 %3, -1
%396 = zext i32 %395 to i64
%397 = zext i32 %3 to i64
%398 = getelementptr i32, i32* %37, i64 %14
%399 = add nsw i64 %14, %342
%400 = getelementptr i32, i32* %37, i64 %399
%401 = getelementptr i32, i32* %37, i64 %342
%402 = bitcast i32* %401 to i8*
%403 = and i64 %342, 4294967288
%404 = add nsw i64 %403, -8
%405 = lshr exact i64 %404, 3
%406 = add nuw nsw i64 %405, 1
%407 = icmp ult i32 %3, 8
%408 = and i64 %342, 4294967288
%409 = and i64 %406, 1
%410 = icmp eq i64 %404, 0
%411 = and i64 %406, 4611686018427387902
%412 = icmp eq i64 %409, 0
%413 = icmp eq i64 %408, %342
%414 = and i64 %342, 1
%415 = icmp eq i64 %414, 0
%416 = sub nsw i64 0, %342
br label %469
417: ; preds = %390, %417
%418 = phi i64 [ %440, %417 ], [ 0, %390 ]
%419 = phi float [ %439, %417 ], [ 0.000000e+00, %390 ]
%420 = phi i64 [ %441, %417 ], [ 0, %390 ]
%421 = add nsw i64 %418, %392
%422 = getelementptr inbounds i32, i32* %39, i64 %421
%423 = bitcast i32* %422 to float*
%424 = load float, float* %423
%425 = fcmp ult float %424, 0.000000e+00
%426 = fneg float %424
%427 = select i1 %425, float %426, float %424
%428 = fcmp ogt float %427, %419
%429 = select i1 %428, float %427, float %419
%430 = or i64 %418, 1
%431 = add nsw i64 %430, %392
%432 = getelementptr inbounds i32, i32* %39, i64 %431
%433 = bitcast i32* %432 to float*
%434 = load float, float* %433
%435 = fcmp ult float %434, 0.000000e+00
%436 = fneg float %434
%437 = select i1 %435, float %436, float %434
%438 = fcmp ogt float %437, %429
%439 = select i1 %438, float %437, float %429
%440 = add nuw nsw i64 %418, 2
%441 = add i64 %420, 2
%442 = icmp eq i64 %441, %345
br i1 %442, label %443, label %417
443: ; preds = %417, %390
%444 = phi float [ undef, %390 ], [ %439, %417 ]
%445 = phi i64 [ 0, %390 ], [ %440, %417 ]
%446 = phi float [ 0.000000e+00, %390 ], [ %439, %417 ]
br i1 %346, label %457, label %447
447: ; preds = %443
%448 = add nsw i64 %445, %392
%449 = getelementptr inbounds i32, i32* %39, i64 %448
%450 = bitcast i32* %449 to float*
%451 = load float, float* %450
%452 = fcmp ult float %451, 0.000000e+00
%453 = fneg float %451
%454 = select i1 %452, float %453, float %451
%455 = fcmp ogt float %454, %446
%456 = select i1 %455, float %454, float %446
br label %457
457: ; preds = %443, %447
%458 = phi float [ %444, %443 ], [ %456, %447 ]
%459 = fcmp oeq float %458, 0.000000e+00
br i1 %459, label %460, label %463
460: ; preds = %457
%461 = load i32, i32* @stderr
%462 = tail call i32 @fprintf(i32 %461, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0))
br label %886
463: ; preds = %457
%464 = fdiv float 1.000000e+00, %458
%465 = getelementptr inbounds i32, i32* %41, i64 %391
%466 = bitcast i32* %465 to float*
store float %464, float* %466
%467 = add nuw nsw i64 %391, 1
%468 = icmp eq i64 %467, %342
br i1 %468, label %393, label %390
469: ; preds = %394, %778
%470 = phi i64 [ 1, %394 ], [ %780, %778 ]
%471 = phi i64 [ 0, %394 ], [ %779, %778 ]
%472 = phi i32 [ -1, %394 ], [ %614, %778 ]
%473 = trunc i64 %471 to i32
%474 = icmp eq i64 %471, 0
br i1 %474, label %542, label %478
475: ; preds = %778
br i1 %42, label %476, label %886
476: ; preds = %475
%477 = zext i32 %3 to i64
br label %783
478: ; preds = %469, %538
%479 = phi i64 [ %540, %538 ], [ 0, %469 ]
%480 = mul nsw i64 %479, %14
%481 = add nsw i64 %480, %471
%482 = getelementptr inbounds i32, i32* %39, i64 %481
%483 = bitcast i32* %482 to float*
%484 = load float, float* %483
%485 = icmp eq i64 %479, 0
br i1 %485, label %538, label %486
486: ; preds = %478
%487 = and i64 %479, 1
%488 = icmp eq i64 %479, 1
br i1 %488, label %521, label %489
489: ; preds = %486
%490 = and i64 %479, 9223372036854775806
br label %491
491: ; preds = %491, %489
%492 = phi i64 [ 0, %489 ], [ %518, %491 ]
%493 = phi float [ %484, %489 ], [ %517, %491 ]
%494 = phi i64 [ 0, %489 ], [ %519, %491 ]
%495 = add nsw i64 %492, %480
%496 = getelementptr inbounds i32, i32* %39, i64 %495
%497 = bitcast i32* %496 to float*
%498 = load float, float* %497
%499 = mul nsw i64 %492, %14
%500 = add nsw i64 %499, %471
%501 = getelementptr inbounds i32, i32* %39, i64 %500
%502 = bitcast i32* %501 to float*
%503 = load float, float* %502
%504 = fneg float %498
%505 = tail call float @llvm.fmuladd.f32(float %504, float %503, float %493)
%506 = or i64 %492, 1
%507 = add nsw i64 %506, %480
%508 = getelementptr inbounds i32, i32* %39, i64 %507
%509 = bitcast i32* %508 to float*
%510 = load float, float* %509
%511 = mul nsw i64 %506, %14
%512 = add nsw i64 %511, %471
%513 = getelementptr inbounds i32, i32* %39, i64 %512
%514 = bitcast i32* %513 to float*
%515 = load float, float* %514
%516 = fneg float %510
%517 = tail call float @llvm.fmuladd.f32(float %516, float %515, float %505)
%518 = add nuw nsw i64 %492, 2
%519 = add i64 %494, 2
%520 = icmp eq i64 %519, %490
br i1 %520, label %521, label %491
521: ; preds = %491, %486
%522 = phi float [ undef, %486 ], [ %517, %491 ]
%523 = phi i64 [ 0, %486 ], [ %518, %491 ]
%524 = phi float [ %484, %486 ], [ %517, %491 ]
%525 = icmp eq i64 %487, 0
br i1 %525, label %538, label %526
526: ; preds = %521
%527 = add nsw i64 %523, %480
%528 = getelementptr inbounds i32, i32* %39, i64 %527
%529 = bitcast i32* %528 to float*
%530 = load float, float* %529
%531 = mul nsw i64 %523, %14
%532 = add nsw i64 %531, %471
%533 = getelementptr inbounds i32, i32* %39, i64 %532
%534 = bitcast i32* %533 to float*
%535 = load float, float* %534
%536 = fneg float %530
%537 = tail call float @llvm.fmuladd.f32(float %536, float %535, float %524)
br label %538
538: ; preds = %526, %521, %478
%539 = phi float [ %484, %478 ], [ %522, %521 ], [ %537, %526 ]
store float %539, float* %483
%540 = add nuw nsw i64 %479, 1
%541 = icmp eq i64 %540, %471
br i1 %541, label %542, label %478
542: ; preds = %538, %469
%543 = and i64 %471, 1
%544 = icmp eq i64 %471, 1
%545 = and i64 %471, -2
%546 = icmp eq i64 %543, 0
br label %547
547: ; preds = %542, %603
%548 = phi i64 [ %616, %603 ], [ %471, %542 ]
%549 = phi float [ %615, %603 ], [ 0.000000e+00, %542 ]
%550 = phi i32 [ %614, %603 ], [ %472, %542 ]
%551 = mul nsw i64 %548, %14
%552 = add nsw i64 %551, %471
%553 = getelementptr inbounds i32, i32* %39, i64 %552
%554 = bitcast i32* %553 to float*
%555 = load float, float* %554
br i1 %474, label %603, label %556
556: ; preds = %547
br i1 %544, label %587, label %557
557: ; preds = %556, %557
%558 = phi i64 [ %584, %557 ], [ 0, %556 ]
%559 = phi float [ %583, %557 ], [ %555, %556 ]
%560 = phi i64 [ %585, %557 ], [ 0, %556 ]
%561 = add nsw i64 %558, %551
%562 = getelementptr inbounds i32, i32* %39, i64 %561
%563 = bitcast i32* %562 to float*
%564 = load float, float* %563
%565 = mul nsw i64 %558, %14
%566 = add nsw i64 %565, %471
%567 = getelementptr inbounds i32, i32* %39, i64 %566
%568 = bitcast i32* %567 to float*
%569 = load float, float* %568
%570 = fneg float %564
%571 = tail call float @llvm.fmuladd.f32(float %570, float %569, float %559)
%572 = or i64 %558, 1
%573 = add nsw i64 %572, %551
%574 = getelementptr inbounds i32, i32* %39, i64 %573
%575 = bitcast i32* %574 to float*
%576 = load float, float* %575
%577 = mul nsw i64 %572, %14
%578 = add nsw i64 %577, %471
%579 = getelementptr inbounds i32, i32* %39, i64 %578
%580 = bitcast i32* %579 to float*
%581 = load float, float* %580
%582 = fneg float %576
%583 = tail call float @llvm.fmuladd.f32(float %582, float %581, float %571)
%584 = add nuw nsw i64 %558, 2
%585 = add i64 %560, 2
%586 = icmp eq i64 %585, %545
br i1 %586, label %587, label %557
587: ; preds = %557, %556
%588 = phi float [ undef, %556 ], [ %583, %557 ]
%589 = phi i64 [ 0, %556 ], [ %584, %557 ]
%590 = phi float [ %555, %556 ], [ %583, %557 ]
br i1 %546, label %603, label %591
591: ; preds = %587
%592 = add nsw i64 %589, %551
%593 = getelementptr inbounds i32, i32* %39, i64 %592
%594 = bitcast i32* %593 to float*
%595 = load float, float* %594
%596 = mul nsw i64 %589, %14
%597 = add nsw i64 %596, %471
%598 = getelementptr inbounds i32, i32* %39, i64 %597
%599 = bitcast i32* %598 to float*
%600 = load float, float* %599
%601 = fneg float %595
%602 = tail call float @llvm.fmuladd.f32(float %601, float %600, float %590)
br label %603
603: ; preds = %591, %587, %547
%604 = phi float [ %555, %547 ], [ %588, %587 ], [ %602, %591 ]
store float %604, float* %554
%605 = getelementptr inbounds i32, i32* %41, i64 %548
%606 = bitcast i32* %605 to float*
%607 = load float, float* %606
%608 = fcmp oge float %604, 0.000000e+00
%609 = fneg float %604
%610 = select i1 %608, float %604, float %609
%611 = fmul float %610, %607
%612 = fcmp ult float %611, %549
%613 = trunc i64 %548 to i32
%614 = select i1 %612, i32 %550, i32 %613
%615 = select i1 %612, float %549, float %611
%616 = add nuw nsw i64 %548, 1
%617 = icmp eq i64 %616, %397
br i1 %617, label %618, label %547
618: ; preds = %603
%619 = zext i32 %614 to i64
%620 = icmp eq i64 %471, %619
br i1 %620, label %748, label %621
621: ; preds = %618
%622 = mul nsw i32 %614, %3
%623 = mul nsw i64 %471, %14
%624 = sext i32 %622 to i64
br i1 %407, label %704, label %625
625: ; preds = %621
%626 = getelementptr i32, i32* %398, i64 %624
%627 = bitcast i32* %626 to i8*
%628 = getelementptr i32, i32* %400, i64 %624
%629 = bitcast i32* %628 to i8*
%630 = shl i64 %471, 2
%631 = add i64 %630, 4
%632 = mul i64 %631, %14
%633 = getelementptr i8, i8* %38, i64 %632
%634 = getelementptr i8, i8* %402, i64 %632
%635 = icmp ugt i8* %634, %627
%636 = icmp ult i8* %633, %629
%637 = and i1 %635, %636
br i1 %637, label %704, label %638
638: ; preds = %625
br i1 %410, label %682, label %639
639: ; preds = %638, %639
%640 = phi i64 [ %679, %639 ], [ 0, %638 ]
%641 = phi i64 [ %680, %639 ], [ 0, %638 ]
%642 = add nsw i64 %640, %624
%643 = getelementptr inbounds i32, i32* %39, i64 %642
%644 = bitcast i32* %643 to <4 x float>*
%645 = load <4 x float>, <4 x float>* %644
%646 = getelementptr inbounds i32, i32* %643, i64 4
%647 = bitcast i32* %646 to <4 x float>*
%648 = load <4 x float>, <4 x float>* %647
%649 = add nsw i64 %640, %623
%650 = getelementptr inbounds i32, i32* %39, i64 %649
%651 = bitcast i32* %650 to <4 x float>*
%652 = load <4 x float>, <4 x float>* %651
%653 = getelementptr inbounds i32, i32* %650, i64 4
%654 = bitcast i32* %653 to <4 x float>*
%655 = load <4 x float>, <4 x float>* %654
%656 = bitcast i32* %643 to <4 x float>*
store <4 x float> %652, <4 x float>* %656
%657 = bitcast i32* %646 to <4 x float>*
store <4 x float> %655, <4 x float>* %657
%658 = bitcast i32* %650 to <4 x float>*
store <4 x float> %645, <4 x float>* %658
%659 = bitcast i32* %653 to <4 x float>*
store <4 x float> %648, <4 x float>* %659
%660 = or i64 %640, 8
%661 = add nsw i64 %660, %624
%662 = getelementptr inbounds i32, i32* %39, i64 %661
%663 = bitcast i32* %662 to <4 x float>*
%664 = load <4 x float>, <4 x float>* %663
%665 = getelementptr inbounds i32, i32* %662, i64 4
%666 = bitcast i32* %665 to <4 x float>*
%667 = load <4 x float>, <4 x float>* %666
%668 = add nsw i64 %660, %623
%669 = getelementptr inbounds i32, i32* %39, i64 %668
%670 = bitcast i32* %669 to <4 x float>*
%671 = load <4 x float>, <4 x float>* %670
%672 = getelementptr inbounds i32, i32* %669, i64 4
%673 = bitcast i32* %672 to <4 x float>*
%674 = load <4 x float>, <4 x float>* %673
%675 = bitcast i32* %662 to <4 x float>*
store <4 x float> %671, <4 x float>* %675
%676 = bitcast i32* %665 to <4 x float>*
store <4 x float> %674, <4 x float>* %676
%677 = bitcast i32* %669 to <4 x float>*
store <4 x float> %664, <4 x float>* %677
%678 = bitcast i32* %672 to <4 x float>*
store <4 x float> %667, <4 x float>* %678
%679 = add nuw i64 %640, 16
%680 = add i64 %641, 2
%681 = icmp eq i64 %680, %411
br i1 %681, label %682, label %639
682: ; preds = %639, %638
%683 = phi i64 [ 0, %638 ], [ %679, %639 ]
br i1 %412, label %703, label %684
684: ; preds = %682
%685 = add nsw i64 %683, %624
%686 = getelementptr inbounds i32, i32* %39, i64 %685
%687 = bitcast i32* %686 to <4 x float>*
%688 = load <4 x float>, <4 x float>* %687
%689 = getelementptr inbounds i32, i32* %686, i64 4
%690 = bitcast i32* %689 to <4 x float>*
%691 = load <4 x float>, <4 x float>* %690
%692 = add nsw i64 %683, %623
%693 = getelementptr inbounds i32, i32* %39, i64 %692
%694 = bitcast i32* %693 to <4 x float>*
%695 = load <4 x float>, <4 x float>* %694
%696 = getelementptr inbounds i32, i32* %693, i64 4
%697 = bitcast i32* %696 to <4 x float>*
%698 = load <4 x float>, <4 x float>* %697
%699 = bitcast i32* %686 to <4 x float>*
store <4 x float> %695, <4 x float>* %699
%700 = bitcast i32* %689 to <4 x float>*
store <4 x float> %698, <4 x float>* %700
%701 = bitcast i32* %693 to <4 x float>*
store <4 x float> %688, <4 x float>* %701
%702 = bitcast i32* %696 to <4 x float>*
store <4 x float> %691, <4 x float>* %702
br label %703
703: ; preds = %682, %684
br i1 %413, label %741, label %704
704: ; preds = %625, %621, %703
%705 = phi i64 [ 0, %625 ], [ 0, %621 ], [ %408, %703 ]
%706 = xor i64 %705, -1
br i1 %415, label %717, label %707
707: ; preds = %704
%708 = add nsw i64 %705, %624
%709 = getelementptr inbounds i32, i32* %39, i64 %708
%710 = bitcast i32* %709 to float*
%711 = load float, float* %710
%712 = add nsw i64 %705, %623
%713 = getelementptr inbounds i32, i32* %39, i64 %712
%714 = bitcast i32* %713 to float*
%715 = load float, float* %714
store float %715, float* %710
store float %711, float* %714
%716 = or i64 %705, 1
br label %717
717: ; preds = %707, %704
%718 = phi i64 [ %705, %704 ], [ %716, %707 ]
%719 = icmp eq i64 %706, %416
br i1 %719, label %741, label %720
720: ; preds = %717, %720
%721 = phi i64 [ %739, %720 ], [ %718, %717 ]
%722 = add nsw i64 %721, %624
%723 = getelementptr inbounds i32, i32* %39, i64 %722
%724 = bitcast i32* %723 to float*
%725 = load float, float* %724
%726 = add nsw i64 %721, %623
%727 = getelementptr inbounds i32, i32* %39, i64 %726
%728 = bitcast i32* %727 to float*
%729 = load float, float* %728
store float %729, float* %724
store float %725, float* %728
%730 = add nuw nsw i64 %721, 1
%731 = add nsw i64 %730, %624
%732 = getelementptr inbounds i32, i32* %39, i64 %731
%733 = bitcast i32* %732 to float*
%734 = load float, float* %733
%735 = add nsw i64 %730, %623
%736 = getelementptr inbounds i32, i32* %39, i64 %735
%737 = bitcast i32* %736 to float*
%738 = load float, float* %737
store float %738, float* %733
store float %734, float* %737
%739 = add nuw nsw i64 %721, 2
%740 = icmp eq i64 %739, %397
br i1 %740, label %741, label %720
741: ; preds = %717, %720, %703
%742 = getelementptr inbounds i32, i32* %41, i64 %471
%743 = bitcast i32* %742 to float*
%744 = load float, float* %743
%745 = sext i32 %614 to i64
%746 = getelementptr inbounds i32, i32* %41, i64 %745
%747 = bitcast i32* %746 to float*
store float %744, float* %747
br label %748
748: ; preds = %741, %618
%749 = getelementptr inbounds i32, i32* %37, i64 %471
store i32 %614, i32* %749
%750 = mul nsw i32 %473, %3
%751 = sext i32 %750 to i64
%752 = add nsw i64 %471, %751
%753 = getelementptr inbounds i32, i32* %39, i64 %752
%754 = bitcast i32* %753 to float*
%755 = load float, float* %754
%756 = fcmp oeq float %755, 0.000000e+00
br i1 %756, label %757, label %759
757: ; preds = %748
%758 = load float, float* @FLT_EPSILON
store float %758, float* %754
br label %759
759: ; preds = %757, %748
%760 = phi float [ %758, %757 ], [ %755, %748 ]
%761 = icmp eq i64 %471, %396
br i1 %761, label %762, label %764
762: ; preds = %759
%763 = add nuw nsw i64 %471, 1
br label %778
764: ; preds = %759
%765 = fdiv float 1.000000e+00, %760
%766 = add nuw nsw i64 %471, 1
%767 = icmp slt i64 %766, %14
br i1 %767, label %768, label %778
768: ; preds = %764, %768
%769 = phi i64 [ %776, %768 ], [ %470, %764 ]
%770 = mul nsw i64 %769, %14
%771 = add nsw i64 %770, %471
%772 = getelementptr inbounds i32, i32* %39, i64 %771
%773 = bitcast i32* %772 to float*
%774 = load float, float* %773
%775 = fmul float %765, %774
store float %775, float* %773
%776 = add nuw nsw i64 %769, 1
%777 = icmp eq i64 %776, %397
br i1 %777, label %778, label %768
778: ; preds = %768, %762, %764
%779 = phi i64 [ %763, %762 ], [ %766, %764 ], [ %766, %768 ]
%780 = add nuw nsw i64 %470, 1
%781 = icmp eq i64 %779, %397
br i1 %781, label %475, label %469
782: ; preds = %820
br i1 %42, label %825, label %886
783: ; preds = %476, %820
%784 = phi i64 [ 0, %476 ], [ %823, %820 ]
%785 = phi i32 [ 0, %476 ], [ %821, %820 ]
%786 = getelementptr inbounds i32, i32* %37, i64 %784
%787 = load i32, i32* %786
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds float, float* %2, i64 %788
%790 = load float, float* %789
%791 = getelementptr inbounds float, float* %2, i64 %784
%792 = load float, float* %791
store float %792, float* %789
%793 = icmp eq i32 %785, 0
br i1 %793, label %815, label %794
794: ; preds = %783
%795 = sext i32 %785 to i64
%796 = icmp slt i64 %784, %795
br i1 %796, label %820, label %797
797: ; preds = %794
%798 = add i32 %785, -1
%799 = mul nsw i64 %784, %14
%800 = sext i32 %798 to i64
br label %801
801: ; preds = %797, %801
%802 = phi i64 [ %800, %797 ], [ %812, %801 ]
%803 = phi float [ %790, %797 ], [ %811, %801 ]
%804 = add nsw i64 %802, %799
%805 = getelementptr inbounds i32, i32* %39, i64 %804
%806 = bitcast i32* %805 to float*
%807 = load float, float* %806
%808 = getelementptr inbounds float, float* %2, i64 %802
%809 = load float, float* %808
%810 = fneg float %807
%811 = tail call float @llvm.fmuladd.f32(float %810, float %809, float %803)
%812 = add nsw i64 %802, 1
%813 = and i64 %812, 4294967295
%814 = icmp eq i64 %813, %784
br i1 %814, label %820, label %801
815: ; preds = %783
%816 = fcmp une float %790, 0.000000e+00
br i1 %816, label %817, label %820
817: ; preds = %815
%818 = trunc i64 %784 to i32
%819 = add i32 %818, 1
br label %820
820: ; preds = %801, %794, %815, %817
%821 = phi i32 [ %819, %817 ], [ 0, %815 ], [ %785, %794 ], [ %785, %801 ]
%822 = phi float [ %790, %817 ], [ %790, %815 ], [ %790, %794 ], [ %811, %801 ]
store float %822, float* %791
%823 = add nuw nsw i64 %784, 1
%824 = icmp eq i64 %823, %477
br i1 %824, label %782, label %783
825: ; preds = %782, %875
%826 = phi i32 [ %885, %875 ], [ 0, %782 ]
%827 = phi i64 [ %828, %875 ], [ %14, %782 ]
%828 = add nsw i64 %827, -1
%829 = trunc i64 %828 to i32
%830 = getelementptr inbounds float, float* %2, i64 %828
%831 = load float, float* %830
%832 = icmp slt i64 %827, %14
br i1 %832, label %833, label %875
833: ; preds = %825
%834 = mul nsw i64 %828, %14
%835 = and i32 %826, 1
%836 = icmp eq i32 %835, 0
br i1 %836, label %847, label %837
837: ; preds = %833
%838 = add nsw i64 %827, %834
%839 = getelementptr inbounds i32, i32* %39, i64 %838
%840 = bitcast i32* %839 to float*
%841 = load float, float* %840
%842 = getelementptr inbounds float, float* %2, i64 %827
%843 = load float, float* %842
%844 = fneg float %841
%845 = tail call float @llvm.fmuladd.f32(float %844, float %843, float %831)
%846 = add nsw i64 %827, 1
br label %847
847: ; preds = %837, %833
%848 = phi float [ undef, %833 ], [ %845, %837 ]
%849 = phi i64 [ %827, %833 ], [ %846, %837 ]
%850 = phi float [ %831, %833 ], [ %845, %837 ]
%851 = icmp eq i32 %826, 1
br i1 %851, label %875, label %852
852: ; preds = %847, %852
%853 = phi i64 [ %872, %852 ], [ %849, %847 ]
%854 = phi float [ %871, %852 ], [ %850, %847 ]
%855 = add nsw i64 %853, %834
%856 = getelementptr inbounds i32, i32* %39, i64 %855
%857 = bitcast i32* %856 to float*
%858 = load float, float* %857
%859 = getelementptr inbounds float, float* %2, i64 %853
%860 = load float, float* %859
%861 = fneg float %858
%862 = tail call float @llvm.fmuladd.f32(float %861, float %860, float %854)
%863 = add nsw i64 %853, 1
%864 = add nsw i64 %863, %834
%865 = getelementptr inbounds i32, i32* %39, i64 %864
%866 = bitcast i32* %865 to float*
%867 = load float, float* %866
%868 = getelementptr inbounds float, float* %2, i64 %863
%869 = load float, float* %868
%870 = fneg float %867
%871 = tail call float @llvm.fmuladd.f32(float %870, float %869, float %862)
%872 = add nsw i64 %853, 2
%873 = trunc i64 %872 to i32
%874 = icmp eq i32 %873, %3
br i1 %874, label %875, label %852
875: ; preds = %847, %852, %825
%876 = phi float [ %831, %825 ], [ %848, %847 ], [ %871, %852 ]
%877 = mul nsw i32 %829, %3
%878 = sext i32 %877 to i64
%879 = add nsw i64 %828, %878
%880 = getelementptr inbounds i32, i32* %39, i64 %879
%881 = bitcast i32* %880 to float*
%882 = load float, float* %881
%883 = fdiv float %876, %882
store float %883, float* %830
%884 = icmp sgt i64 %827, 1
%885 = add i32 %826, 1
br i1 %884, label %825, label %886
886: ; preds = %875, %340, %393, %475, %782, %460, %11
%887 = phi i32 [ 0, %460 ], [ 1, %11 ], [ 1, %782 ], [ 1, %475 ], [ 1, %393 ], [ 1, %340 ], [ 1, %875 ]
ret i32 %887
}