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


x86 assembly (clang, -O0):
<slevmar_LUinverse_noLapack>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movq   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
add    -0x5c(%rbp),%eax
cltq
shl    $0x2,%rax
movslq -0x50(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    11d3 <slevmar_LUinverse_noLapack+0xa3>
mov    0x2e1f(%rip),%rax
mov    (%rax),%edi
lea    0xe42(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a06 <slevmar_LUinverse_noLapack+0x8d6>
mov    -0x28(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x5c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    124f <slevmar_LUinverse_noLapack+0x11f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    121b <slevmar_LUinverse_noLapack+0xeb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    139a <slevmar_LUinverse_noLapack+0x26a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132c <slevmar_LUinverse_noLapack+0x1fc>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12c7 <slevmar_LUinverse_noLapack+0x197>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    12f2 <slevmar_LUinverse_noLapack+0x1c2>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
ucomiss -0x7c(%rbp),%xmm0
jbe    1319 <slevmar_LUinverse_noLapack+0x1e9>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
jmp    131e <slevmar_LUinverse_noLapack+0x1ee>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1271 <slevmar_LUinverse_noLapack+0x141>
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1372 <slevmar_LUinverse_noLapack+0x242>
jp     1372 <slevmar_LUinverse_noLapack+0x242>
mov    0x2c89(%rip),%rax
mov    (%rax),%edi
lea    0xce7(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a06 <slevmar_LUinverse_noLapack+0x8d6>
movss  0xc86(%rip),%xmm0
divss  -0x7c(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1256 <slevmar_LUinverse_noLapack+0x126>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    176f <slevmar_LUinverse_noLapack+0x63f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1470 <slevmar_LUinverse_noLapack+0x340>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1447 <slevmar_LUinverse_noLapack+0x317>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13e2 <slevmar_LUinverse_noLapack+0x2b2>
movss  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b4 <slevmar_LUinverse_noLapack+0x284>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15cf <slevmar_LUinverse_noLapack+0x49f>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1511 <slevmar_LUinverse_noLapack+0x3e1>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14ac <slevmar_LUinverse_noLapack+0x37c>
movss  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1569 <slevmar_LUinverse_noLapack+0x439>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    1583 <slevmar_LUinverse_noLapack+0x453>
movss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
ucomiss -0x7c(%rbp),%xmm0
jb     15bc <slevmar_LUinverse_noLapack+0x48c>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    15c1 <slevmar_LUinverse_noLapack+0x491>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    147e <slevmar_LUinverse_noLapack+0x34e>
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     167e <slevmar_LUinverse_noLapack+0x54e>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1664 <slevmar_LUinverse_noLapack+0x534>
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15e2 <slevmar_LUinverse_noLapack+0x4b2>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16da <slevmar_LUinverse_noLapack+0x5aa>
jp     16da <slevmar_LUinverse_noLapack+0x5aa>
mov    0x2920(%rip),%rax
movss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     175c <slevmar_LUinverse_noLapack+0x62c>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  0x8fc(%rip),%xmm0
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1757 <slevmar_LUinverse_noLapack+0x627>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    171a <slevmar_LUinverse_noLapack+0x5ea>
jmp    175c <slevmar_LUinverse_noLapack+0x62c>
jmp    1761 <slevmar_LUinverse_noLapack+0x631>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a1 <slevmar_LUinverse_noLapack+0x271>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19f6 <slevmar_LUinverse_noLapack+0x8c6>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17b3 <slevmar_LUinverse_noLapack+0x683>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1789 <slevmar_LUinverse_noLapack+0x659>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  0x83d(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18df <slevmar_LUinverse_noLapack+0x7af>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x38(%rbp)
je     1890 <slevmar_LUinverse_noLapack+0x760>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    188b <slevmar_LUinverse_noLapack+0x75b>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    182f <slevmar_LUinverse_noLapack+0x6ff>
jmp    18bf <slevmar_LUinverse_noLapack+0x78f>
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18b1 <slevmar_LUinverse_noLapack+0x781>
jp     18b1 <slevmar_LUinverse_noLapack+0x781>
jmp    18ba <slevmar_LUinverse_noLapack+0x78a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18bf <slevmar_LUinverse_noLapack+0x78f>
movss  -0x80(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17d6 <slevmar_LUinverse_noLapack+0x6a6>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     199f <slevmar_LUinverse_noLapack+0x86f>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1969 <slevmar_LUinverse_noLapack+0x839>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    190d <slevmar_LUinverse_noLapack+0x7dd>
movss  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    18e8 <slevmar_LUinverse_noLapack+0x7b8>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19e3 <slevmar_LUinverse_noLapack+0x8b3>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19a6 <slevmar_LUinverse_noLapack+0x876>
jmp    19e8 <slevmar_LUinverse_noLapack+0x8b8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1776 <slevmar_LUinverse_noLapack+0x646>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slevmar_LUinverse_noLapack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rsi,0x58(%rsp)
mov    %rdi,%r13
mov    %edx,%ebp
imul   %edx,%ebp
mov    %rdx,0x50(%rsp)
lea    (%rdx,%rdx,2),%edi
add    %ebp,%edi
shl    $0x2,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1231 <slevmar_LUinverse_noLapack+0xf1>
mov    %rax,%rbx
mov    %ebp,%r11d
lea    (%rax,%r11,4),%r12
test   %ebp,%ebp
mov    0x50(%rsp),%r8
je     1324 <slevmar_LUinverse_noLapack+0x1e4>
cmp    $0x8,%ebp
jb     11b2 <slevmar_LUinverse_noLapack+0x72>
lea    0x0(,%r11,4),%rax
add    %r13,%rax
cmp    %rax,%rbx
jae    124d <slevmar_LUinverse_noLapack+0x10d>
cmp    %r13,%r12
jbe    124d <slevmar_LUinverse_noLapack+0x10d>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     11e6 <slevmar_LUinverse_noLapack+0xa6>
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11d0 <slevmar_LUinverse_noLapack+0x90>
cmp    $0x3,%rcx
jb     1324 <slevmar_LUinverse_noLapack+0x1e4>
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x8(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
movss  0xc(%r13,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    11f0 <slevmar_LUinverse_noLapack+0xb0>
jmp    1324 <slevmar_LUinverse_noLapack+0x1e4>
mov    0x2da0(%rip),%rax
mov    (%rax),%edi
lea    0xdd3(%rip),%rsi
call   1050 <fprintf@plt>
xor    %eax,%eax
jmp    1c37 <slevmar_LUinverse_noLapack+0xaf7>
mov    %r11d,%eax
and    $0x7ffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1273 <slevmar_LUinverse_noLapack+0x133>
xor    %esi,%esi
jmp    12e1 <slevmar_LUinverse_noLapack+0x1a1>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,4)
movups %xmm1,0x10(%rbx,%rsi,4)
movups 0x20(%r13,%rsi,4),%xmm0
movups 0x30(%r13,%rsi,4),%xmm1
movups %xmm0,0x20(%rbx,%rsi,4)
movups %xmm1,0x30(%rbx,%rsi,4)
movups 0x40(%r13,%rsi,4),%xmm0
movups 0x50(%r13,%rsi,4),%xmm1
movups %xmm0,0x40(%rbx,%rsi,4)
movups %xmm1,0x50(%rbx,%rsi,4)
movups 0x60(%r13,%rsi,4),%xmm0
movups 0x70(%r13,%rsi,4),%xmm1
movups %xmm0,0x60(%rbx,%rsi,4)
movups %xmm1,0x70(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1280 <slevmar_LUinverse_noLapack+0x140>
test   %rcx,%rcx
je     131b <slevmar_LUinverse_noLapack+0x1db>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,4),%rsi
add    %r13,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nop
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1300 <slevmar_LUinverse_noLapack+0x1c0>
cmp    %r11,%rax
jne    11b4 <slevmar_LUinverse_noLapack+0x74>
test   %r8d,%r8d
jle    1c2a <slevmar_LUinverse_noLapack+0xaea>
movslq %r8d,%r15
lea    (%r12,%r15,4),%rax
mov    %rax,0x10(%rsp)
lea    (%rax,%r15,4),%r9
mov    %r8d,%r13d
lea    -0x1(%r13),%rbp
mov    %r13d,%eax
and    $0xfffffffe,%eax
lea    0x4(%rbx),%rdx
lea    0x0(,%r15,4),%r10
xor    %esi,%esi
xorps  %xmm2,%xmm2
movss  0xcad(%rip),%xmm0
movaps 0xc96(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
test   %rbp,%rbp
je     1430 <slevmar_LUinverse_noLapack+0x2f0>
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xchg   %ax,%ax
movss  -0x4(%rdx,%rcx,4),%xmm4
movss  (%rdx,%rcx,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,%rcx
cmp    %rcx,%rax
jne    1380 <slevmar_LUinverse_noLapack+0x240>
test   $0x1,%r13b
je     13fd <slevmar_LUinverse_noLapack+0x2bd>
mov    %rsi,%rdi
imul   %r15,%rdi
add    %rdi,%rcx
movss  (%rbx,%rcx,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    1404 <slevmar_LUinverse_noLapack+0x2c4>
jnp    143d <slevmar_LUinverse_noLapack+0x2fd>
movaps %xmm0,%xmm4
divss  %xmm3,%xmm4
mov    0x10(%rsp),%rcx
movss  %xmm4,(%rcx,%rsi,4)
add    $0x1,%rsi
add    %r10,%rdx
cmp    %r13,%rsi
jne    1370 <slevmar_LUinverse_noLapack+0x230>
jmp    1461 <slevmar_LUinverse_noLapack+0x321>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
xorps  %xmm3,%xmm3
test   $0x1,%r13b
jne    13d0 <slevmar_LUinverse_noLapack+0x290>
jmp    13fd <slevmar_LUinverse_noLapack+0x2bd>
mov    0x2b94(%rip),%rax
mov    (%rax),%edi
lea    0xc02(%rip),%rsi
call   1050 <fprintf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    1c37 <slevmar_LUinverse_noLapack+0xaf7>
mov    %rbp,0xa0(%rsp)
mov    %r9,0x60(%rsp)
test   %r8d,%r8d
jle    1c2a <slevmar_LUinverse_noLapack+0xaea>
mov    %r11,0x70(%rsp)
mov    %r10,0x28(%rsp)
lea    -0x1(%r8),%eax
mov    %rax,0x48(%rsp)
lea    (%rbx,%r13,4),%rsi
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x90(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0x88(%rsp)
and    %rax,%rdx
mov    %rdx,0x80(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x38(%rsp)
lea    0x4(%rbx),%rax
mov    %rax,0x20(%rsp)
lea    (%rbx,%r15,4),%r10
lea    (%r15,%r15,1),%r9
lea    0x30(%rbx),%rax
mov    %rax,0x78(%rsp)
mov    $0xffffffff,%r11d
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
xorps  %xmm2,%xmm2
mov    %r15,0x18(%rsp)
mov    %r15,0x68(%rsp)
mov    %rsi,0x40(%rsp)
jmp    1546 <slevmar_LUinverse_noLapack+0x406>
add    $0x1,%r14
mov    %r14,%rax
mov    0x8(%rsp),%rdi
add    $0x1,%rdi
mov    %rdi,0x8(%rsp)
add    %r15,0x18(%rsp)
mov    %rax,%r14
cmp    %r13,%rax
je     195d <slevmar_LUinverse_noLapack+0x81d>
test   %r14,%r14
je     1600 <slevmar_LUinverse_noLapack+0x4c0>
mov    0x20(%rsp),%rax
xor    %esi,%esi
jmp    1578 <slevmar_LUinverse_noLapack+0x438>
nopl   0x0(%rax,%rax,1)
movss  %xmm3,(%rbx,%r8,4)
add    $0x1,%rsi
add    0x28(%rsp),%rax
cmp    %r14,%rsi
je     1600 <slevmar_LUinverse_noLapack+0x4c0>
mov    %rsi,%rbp
imul   %r15,%rbp
lea    (%r14,%rbp,1),%r8
movss  (%rbx,%r8,4),%xmm3
test   %rsi,%rsi
je     1560 <slevmar_LUinverse_noLapack+0x420>
cmp    $0x1,%rsi
jne    15a0 <slevmar_LUinverse_noLapack+0x460>
xor    %ecx,%ecx
jmp    15da <slevmar_LUinverse_noLapack+0x49a>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r14,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  -0x4(%rax,%rcx,4),%xmm4
mulss  (%rbx,%rdi,4),%xmm4
movss  (%rax,%rcx,4),%xmm5
subss  %xmm4,%xmm3
mulss  (%r10,%rdi,4),%xmm5
subss  %xmm5,%xmm3
add    $0x2,%rcx
add    %r9,%rdi
cmp    %rcx,%rdx
jne    15b0 <slevmar_LUinverse_noLapack+0x470>
test   $0x1,%sil
je     1560 <slevmar_LUinverse_noLapack+0x420>
add    %rcx,%rbp
movss  (%rbx,%rbp,4),%xmm4
imul   %r15,%rcx
add    %r14,%rcx
mulss  (%rbx,%rcx,4),%xmm4
subss  %xmm4,%xmm3
jmp    1560 <slevmar_LUinverse_noLapack+0x420>
nopl   (%rax)
mov    %r14,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r15,%rbp
imul   %r14,%rbp
mov    0x20(%rsp),%rax
lea    (%rax,%rbp,4),%rdi
xorps  %xmm3,%xmm3
mov    %rdi,%rax
mov    %r14,%r8
mov    %rbp,0x30(%rsp)
jmp    168c <slevmar_LUinverse_noLapack+0x54c>
nopw   0x0(%rax,%rax,1)
movss  %xmm4,(%rbx,%rsi,4)
movaps %xmm4,%xmm5
xorps  %xmm1,%xmm5
xorps  %xmm6,%xmm6
cmpless %xmm4,%xmm6
andps  %xmm6,%xmm4
andnps %xmm5,%xmm6
orps   %xmm4,%xmm6
mov    0x10(%rsp),%rcx
mulss  (%rcx,%r8,4),%xmm6
ucomiss %xmm3,%xmm6
cmovae %r8d,%r11d
movaps %xmm3,%xmm4
cmpnless %xmm6,%xmm4
movaps %xmm4,%xmm5
andnps %xmm6,%xmm5
andps  %xmm3,%xmm4
orps   %xmm5,%xmm4
add    $0x1,%r8
add    0x28(%rsp),%rax
movaps %xmm4,%xmm3
cmp    %r13,%r8
mov    0x68(%rsp),%r15
je     1720 <slevmar_LUinverse_noLapack+0x5e0>
mov    %r8,%rcx
imul   %r15,%rcx
lea    (%rcx,%r14,1),%rsi
movss  (%rbx,%rsi,4),%xmm4
test   %r14,%r14
je     1630 <slevmar_LUinverse_noLapack+0x4f0>
cmp    $0x1,%r14
jne    16b0 <slevmar_LUinverse_noLapack+0x570>
xor    %r15d,%r15d
jmp    16ec <slevmar_LUinverse_noLapack+0x5ac>
nopl   0x0(%rax)
mov    %r14,%rbp
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rax,%r15,4),%xmm5
mulss  (%rbx,%rbp,4),%xmm5
movss  (%rax,%r15,4),%xmm6
subss  %xmm5,%xmm4
mulss  (%r10,%rbp,4),%xmm6
subss  %xmm6,%xmm4
add    $0x2,%r15
add    %r9,%rbp
cmp    %r15,%rdx
jne    16c0 <slevmar_LUinverse_noLapack+0x580>
test   $0x1,%r14b
mov    0x30(%rsp),%rbp
je     1630 <slevmar_LUinverse_noLapack+0x4f0>
add    %r15,%rcx
movss  (%rbx,%rcx,4),%xmm5
imul   0x68(%rsp),%r15
add    %r14,%r15
mulss  (%rbx,%r15,4),%xmm5
subss  %xmm5,%xmm4
jmp    1630 <slevmar_LUinverse_noLapack+0x4f0>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%eax
cmp    %rax,%r14
mov    0x50(%rsp),%r8
mov    0x40(%rsp),%rsi
je     18d3 <slevmar_LUinverse_noLapack+0x793>
mov    %r11d,%eax
imul   %r8d,%eax
cltq
cmp    $0x8,%r8d
jb     1767 <slevmar_LUinverse_noLapack+0x627>
lea    (%rbx,%rax,4),%rcx
lea    (%rsi,%rbp,4),%rdx
cmp    %rdx,%rcx
jae    17ea <slevmar_LUinverse_noLapack+0x6aa>
lea    (%rsi,%rax,4),%rcx
lea    (%rbx,%rbp,4),%rdx
cmp    %rcx,%rdx
jae    17ea <slevmar_LUinverse_noLapack+0x6aa>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r13b
je     1794 <slevmar_LUinverse_noLapack+0x654>
lea    (%rdx,%rax,1),%rcx
movss  (%rbx,%rcx,4),%xmm3
add    %rdx,%rbp
movss  (%rbx,%rbp,4),%xmm4
movss  %xmm4,(%rbx,%rcx,4)
movss  %xmm3,(%rbx,%rbp,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x38(%rsp),%rdx
je     18c0 <slevmar_LUinverse_noLapack+0x780>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rax,%rcx,4),%xmm3
movss  -0x4(%rdi,%rcx,4),%xmm4
movss  %xmm4,-0x4(%rax,%rcx,4)
movss  %xmm3,-0x4(%rdi,%rcx,4)
movss  (%rax,%rcx,4),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  %xmm4,(%rax,%rcx,4)
movss  %xmm3,(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    17b0 <slevmar_LUinverse_noLapack+0x670>
jmp    18c0 <slevmar_LUinverse_noLapack+0x780>
cmpq   $0x0,0x90(%rsp)
je     1868 <slevmar_LUinverse_noLapack+0x728>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
lea    (%rcx,%rbp,4),%rsi
mov    0x80(%rsp),%rbp
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x30(%rdx,%rcx,4),%xmm3
movups -0x20(%rdx,%rcx,4),%xmm4
movups -0x30(%rsi,%rcx,4),%xmm5
movups -0x20(%rsi,%rcx,4),%xmm6
movups %xmm5,-0x30(%rdx,%rcx,4)
movups %xmm6,-0x20(%rdx,%rcx,4)
movups %xmm3,-0x30(%rsi,%rcx,4)
movups %xmm4,-0x20(%rsi,%rcx,4)
movups -0x10(%rdx,%rcx,4),%xmm3
movups (%rdx,%rcx,4),%xmm4
movups -0x10(%rsi,%rcx,4),%xmm5
movups (%rsi,%rcx,4),%xmm6
movups %xmm5,-0x10(%rdx,%rcx,4)
movups %xmm6,(%rdx,%rcx,4)
movups %xmm3,-0x10(%rsi,%rcx,4)
movups %xmm4,(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1810 <slevmar_LUinverse_noLapack+0x6d0>
jmp    186a <slevmar_LUinverse_noLapack+0x72a>
xor    %ecx,%ecx
testb  $0x1,0x88(%rsp)
01
mov    0x30(%rsp),%rbp
je     18a4 <slevmar_LUinverse_noLapack+0x764>
lea    (%rcx,%rax,1),%rdx
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm4
add    %rbp,%rcx
movups (%rbx,%rcx,4),%xmm5
movups 0x10(%rbx,%rcx,4),%xmm6
movups %xmm5,(%rbx,%rdx,4)
movups %xmm6,0x10(%rbx,%rdx,4)
movups %xmm3,(%rbx,%rcx,4)
movups %xmm4,0x10(%rbx,%rcx,4)
mov    0x98(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r13,%rcx
jne    1769 <slevmar_LUinverse_noLapack+0x629>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm3
movslq %r11d,%rax
movss  %xmm3,(%rcx,%rax,4)
mov    0x60(%rsp),%rax
mov    %r11d,(%rax,%r14,4)
mov    %r14d,%eax
imul   %r8d,%eax
cltq
add    %r14,%rax
movss  (%rbx,%rax,4),%xmm4
ucomiss %xmm2,%xmm4
jne    1904 <slevmar_LUinverse_noLapack+0x7c4>
jp     1904 <slevmar_LUinverse_noLapack+0x7c4>
mov    0x26e5(%rip),%rcx
movss  (%rcx),%xmm4
movss  %xmm4,(%rbx,%rax,4)
cmp    0x48(%rsp),%r14
je     1520 <slevmar_LUinverse_noLapack+0x3e0>
lea    0x1(%r14),%rax
cmp    %r15,%rax
jge    1527 <slevmar_LUinverse_noLapack+0x3e7>
movaps %xmm0,%xmm3
divss  %xmm4,%xmm3
add    0x18(%rsp),%r14
lea    (%rbx,%r14,4),%rcx
mov    %r13,%rdx
mov    0x28(%rsp),%rsi
mov    0x8(%rsp),%rdi
nopl   0x0(%rax)
movss  (%rcx),%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,(%rcx)
add    %rsi,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rdi
jne    1940 <slevmar_LUinverse_noLapack+0x800>
jmp    152c <slevmar_LUinverse_noLapack+0x3ec>
test   %r8d,%r8d
mov    0x28(%rsp),%rcx
mov    0x70(%rsp),%rax
jle    1c2a <slevmar_LUinverse_noLapack+0xaea>
lea    0x0(,%r13,4),%rdx
mov    %rdx,0x30(%rsp)
mov    %r13d,%esi
and    $0x3,%esi
mov    %r13d,%r8d
and    $0xfffffffc,%r8d
lea    (%rbx,%rax,4),%r14
add    $0x4,%r14
lea    -0x1(%r15),%rax
imul   %r15,%rax
lea    (%rbx,%rax,4),%rax
add    $0x4,%rax
mov    %rax,0x8(%rsp)
mov    %rcx,%r10
neg    %r10
mov    %r15,%rbp
shl    $0x4,%rbp
lea    (%rcx,%rcx,2),%rdi
xor    %r11d,%r11d
mov    0x58(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r8,0x48(%rsp)
mov    %r10,0x20(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rdi,0x38(%rsp)
jmp    19f3 <slevmar_LUinverse_noLapack+0x8b3>
add    $0x1,%r11
addq   $0x4,0x10(%rsp)
cmp    %r13,%r11
je     1c2a <slevmar_LUinverse_noLapack+0xaea>
mov    %r12,%rdi
xor    %esi,%esi
mov    0x30(%rsp),%rdx
mov    %r11,%rbp
call   1040 <memset@plt>
xorps  %xmm2,%xmm2
mov    %rbp,%r11
mov    0x28(%rsp),%r9
movl   $0x3f800000,(%r12,%rbp,4)
3f
mov    %rbx,%rax
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x60(%rsp),%rbp
mov    0xa0(%rsp),%r8
jmp    1a4c <slevmar_LUinverse_noLapack+0x90c>
xchg   %ax,%ax
ucomiss %xmm2,%xmm0
jne    1a37 <slevmar_LUinverse_noLapack+0x8f7>
jnp    1a9e <slevmar_LUinverse_noLapack+0x95e>
lea    0x1(%rcx),%edx
movss  %xmm0,(%r12,%rcx,4)
add    $0x1,%rcx
add    %r9,%rax
cmp    %r13,%rcx
je     1ab0 <slevmar_LUinverse_noLapack+0x970>
movslq 0x0(%rbp,%rcx,4),%rsi
movss  (%r12,%rsi,4),%xmm0
movss  (%r12,%rcx,4),%xmm1
movss  %xmm1,(%r12,%rsi,4)
test   %edx,%edx
je     1a30 <slevmar_LUinverse_noLapack+0x8f0>
movslq %edx,%rsi
cmp    %rsi,%rcx
jl     1a3a <slevmar_LUinverse_noLapack+0x8fa>
lea    -0x1(%rdx),%esi
movslq %esi,%rsi
add    $0x1,%rsi
nopl   0x0(%rax)
movss  -0x4(%rax,%rsi,4),%xmm1
mulss  -0x4(%r12,%rsi,4),%xmm1
subss  %xmm1,%xmm0
mov    %esi,%edi
add    $0x1,%rsi
cmp    %rcx,%rdi
jne    1a80 <slevmar_LUinverse_noLapack+0x940>
jmp    1a3a <slevmar_LUinverse_noLapack+0x8fa>
xor    %edx,%edx
jmp    1a3a <slevmar_LUinverse_noLapack+0x8fa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
mov    0x8(%rsp),%rcx
mov    %r15,%rdx
mov    0x50(%rsp),%rbp
mov    0x20(%rsp),%r10
jmp    1af6 <slevmar_LUinverse_noLapack+0x9b6>
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%edi
imul   %ebp,%edi
movslq %edi,%rdi
add    %rdx,%rdi
divss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
add    $0x1,%eax
add    %r10,%rcx
cmp    $0x1,%rsi
jle    1b80 <slevmar_LUinverse_noLapack+0xa40>
mov    %rdx,%rsi
add    $0xffffffffffffffff,%rdx
movss  -0x4(%r12,%rsi,4),%xmm0
cmp    %r15,%rsi
jge    1ad0 <slevmar_LUinverse_noLapack+0x990>
test   $0x1,%al
jne    1b20 <slevmar_LUinverse_noLapack+0x9e0>
mov    %rsi,%rdi
cmp    $0x1,%eax
jne    1b50 <slevmar_LUinverse_noLapack+0xa10>
jmp    1ad0 <slevmar_LUinverse_noLapack+0x990>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rdi
imul   %r15,%rdi
add    %rsi,%rdi
movss  (%rbx,%rdi,4),%xmm1
mulss  (%r12,%rsi,4),%xmm1
subss  %xmm1,%xmm0
lea    0x1(%rsi),%rdi
cmp    $0x1,%eax
je     1ad0 <slevmar_LUinverse_noLapack+0x990>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rcx,%rdi,4),%xmm1
movss  (%rcx,%rdi,4),%xmm2
mulss  -0x4(%r14,%rdi,4),%xmm1
mulss  (%r14,%rdi,4),%xmm2
subss  %xmm1,%xmm0
subss  %xmm2,%xmm0
add    $0x2,%rdi
cmp    %edi,%r13d
jne    1b50 <slevmar_LUinverse_noLapack+0xa10>
jmp    1ad0 <slevmar_LUinverse_noLapack+0x990>
xchg   %ax,%ax
cmp    $0x3,%r8
jae    1b90 <slevmar_LUinverse_noLapack+0xa50>
xor    %eax,%eax
mov    0x18(%rsp),%rsi
jmp    1bec <slevmar_LUinverse_noLapack+0xaac>
nop
mov    0x10(%rsp),%rcx
xor    %eax,%eax
mov    0x18(%rsp),%rsi
mov    0x48(%rsp),%r8
mov    0x40(%rsp),%rbp
mov    0x38(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx)
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx,%r15,4)
movss  0x4(%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx,%r15,8)
movss  0x8(%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    $0x4,%rax
add    %rbp,%rcx
cmp    %rax,%r8
jne    1bb0 <slevmar_LUinverse_noLapack+0xa70>
test   %rsi,%rsi
je     19e0 <slevmar_LUinverse_noLapack+0x8a0>
mov    %r15,%rcx
imul   %rax,%rcx
add    %r11,%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
lea    (%r12,%rax,4),%rax
xor    %edx,%edx
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rcx)
add    $0x1,%rdx
add    %r9,%rcx
cmp    %rdx,%rsi
jne    1c10 <slevmar_LUinverse_noLapack+0xad0>
jmp    19e0 <slevmar_LUinverse_noLapack+0x8a0>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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