#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 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 = idx_sz * sizeof(int) + (a_sz + x_sz + work_sz) * sizeof(float);
  buf_sz = tot_sz;
  buf = (void *)malloc(tot_sz);
  if (!buf) {
    fprintf(stderr, "memory allocation in "
                    "slevmar_LUinverse_noLapack"
                    "() failed!\n");
    exit(1);
  }
  idx = (int *)buf;
  a = (float *)(idx + idx_sz);
  x = a + a_sz;
  work = x + x_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)
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
mov    -0x54(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%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    11e2 <slevmar_LUinverse_noLapack+0xa2>
mov    0x2e0e(%rip),%rax
mov    (%rax),%edi
lea    0xe31(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%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)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    125e <slevmar_LUinverse_noLapack+0x11e>
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    122a <slevmar_LUinverse_noLapack+0xea>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13a9 <slevmar_LUinverse_noLapack+0x269>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133b <slevmar_LUinverse_noLapack+0x1fb>
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     12d6 <slevmar_LUinverse_noLapack+0x196>
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    1301 <slevmar_LUinverse_noLapack+0x1c1>
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)
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
ucomiss -0x7c(%rbp),%xmm0
jbe    1328 <slevmar_LUinverse_noLapack+0x1e8>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
jmp    132d <slevmar_LUinverse_noLapack+0x1ed>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1280 <slevmar_LUinverse_noLapack+0x140>
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1381 <slevmar_LUinverse_noLapack+0x241>
jp     1381 <slevmar_LUinverse_noLapack+0x241>
mov    0x2c7a(%rip),%rax
mov    (%rax),%edi
lea    0xcd8(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a15 <slevmar_LUinverse_noLapack+0x8d5>
movss  0xc77(%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    1265 <slevmar_LUinverse_noLapack+0x125>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    177e <slevmar_LUinverse_noLapack+0x63e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    147f <slevmar_LUinverse_noLapack+0x33f>
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    1456 <slevmar_LUinverse_noLapack+0x316>
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    13f1 <slevmar_LUinverse_noLapack+0x2b1>
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    13c3 <slevmar_LUinverse_noLapack+0x283>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15de <slevmar_LUinverse_noLapack+0x49e>
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    1520 <slevmar_LUinverse_noLapack+0x3e0>
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    14bb <slevmar_LUinverse_noLapack+0x37b>
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     1578 <slevmar_LUinverse_noLapack+0x438>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    1592 <slevmar_LUinverse_noLapack+0x452>
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     15cb <slevmar_LUinverse_noLapack+0x48b>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    15d0 <slevmar_LUinverse_noLapack+0x490>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    148d <slevmar_LUinverse_noLapack+0x34d>
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     168d <slevmar_LUinverse_noLapack+0x54d>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1673 <slevmar_LUinverse_noLapack+0x533>
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    15f1 <slevmar_LUinverse_noLapack+0x4b1>
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    16e9 <slevmar_LUinverse_noLapack+0x5a9>
jp     16e9 <slevmar_LUinverse_noLapack+0x5a9>
mov    0x2911(%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     176b <slevmar_LUinverse_noLapack+0x62b>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  0x8ed(%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    1766 <slevmar_LUinverse_noLapack+0x626>
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    1729 <slevmar_LUinverse_noLapack+0x5e9>
jmp    176b <slevmar_LUinverse_noLapack+0x62b>
jmp    1770 <slevmar_LUinverse_noLapack+0x630>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13b0 <slevmar_LUinverse_noLapack+0x270>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a05 <slevmar_LUinverse_noLapack+0x8c5>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17c2 <slevmar_LUinverse_noLapack+0x682>
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    1798 <slevmar_LUinverse_noLapack+0x658>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  0x82e(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18ee <slevmar_LUinverse_noLapack+0x7ae>
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     189f <slevmar_LUinverse_noLapack+0x75f>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    189a <slevmar_LUinverse_noLapack+0x75a>
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    183e <slevmar_LUinverse_noLapack+0x6fe>
jmp    18ce <slevmar_LUinverse_noLapack+0x78e>
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18c0 <slevmar_LUinverse_noLapack+0x780>
jp     18c0 <slevmar_LUinverse_noLapack+0x780>
jmp    18c9 <slevmar_LUinverse_noLapack+0x789>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18ce <slevmar_LUinverse_noLapack+0x78e>
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    17e5 <slevmar_LUinverse_noLapack+0x6a5>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     19ae <slevmar_LUinverse_noLapack+0x86e>
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    1978 <slevmar_LUinverse_noLapack+0x838>
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    191c <slevmar_LUinverse_noLapack+0x7dc>
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    18f7 <slevmar_LUinverse_noLapack+0x7b7>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19f2 <slevmar_LUinverse_noLapack+0x8b2>
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    19b5 <slevmar_LUinverse_noLapack+0x875>
jmp    19f7 <slevmar_LUinverse_noLapack+0x8b7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1785 <slevmar_LUinverse_noLapack+0x645>
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    $0xb8,%rsp
mov    %edx,%r14d
mov    %rsi,0x68(%rsp)
mov    %rdi,%rbp
mov    %edx,%ebx
imul   %edx,%ebx
lea    (%r14,%r14,2),%edi
add    %ebx,%edi
shl    $0x2,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1d6b <slevmar_LUinverse_noLapack+0xc1b>
mov    %rax,%r8
movslq %r14d,%r10
lea    (%rax,%r10,4),%r15
mov    %ebx,%r11d
test   %ebx,%ebx
mov    %r14,%r9
je     1364 <slevmar_LUinverse_noLapack+0x214>
cmp    $0x8,%ebx
jb     11ca <slevmar_LUinverse_noLapack+0x7a>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
cmp    %rax,%r15
jae    127d <slevmar_LUinverse_noLapack+0x12d>
lea    (%r10,%r11,1),%rax
lea    (%r8,%rax,4),%rax
cmp    %rbp,%rax
jbe    127d <slevmar_LUinverse_noLapack+0x12d>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdx
and    $0x7,%rdx
je     11f6 <slevmar_LUinverse_noLapack+0xa6>
xchg   %ax,%ax
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    11e0 <slevmar_LUinverse_noLapack+0x90>
cmp    $0x7,%rax
jb     1364 <slevmar_LUinverse_noLapack+0x214>
lea    (%r8,%r10,4),%rax
add    $0x1c,%rax
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x10(%rax,%rcx,4)
movss  0x10(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rcx,4)
movss  0x14(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rcx,4)
movss  0x18(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rcx,4)
movss  0x1c(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r11
jne    1210 <slevmar_LUinverse_noLapack+0xc0>
jmp    1364 <slevmar_LUinverse_noLapack+0x214>
mov    %r11d,%ecx
and    $0x7ffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x18,%rsi
jae    12a4 <slevmar_LUinverse_noLapack+0x154>
xor    %esi,%esi
jmp    1319 <slevmar_LUinverse_noLapack+0x1c9>
and    $0xfffffffffffffffc,%rdx
lea    (%r8,%r10,4),%rdi
add    $0x70,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%rbp,%rsi,4),%xmm0
movups 0x10(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x70(%rdi,%rsi,4)
movups %xmm1,-0x60(%rdi,%rsi,4)
movups 0x20(%rbp,%rsi,4),%xmm0
movups 0x30(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x50(%rdi,%rsi,4)
movups %xmm1,-0x40(%rdi,%rsi,4)
movups 0x40(%rbp,%rsi,4),%xmm0
movups 0x50(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x30(%rdi,%rsi,4)
movups %xmm1,-0x20(%rdi,%rsi,4)
movups 0x60(%rbp,%rsi,4),%xmm0
movups 0x70(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,4)
movups %xmm1,(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    12c0 <slevmar_LUinverse_noLapack+0x170>
test   %rax,%rax
je     135b <slevmar_LUinverse_noLapack+0x20b>
lea    (%rsi,%r10,1),%rdx
lea    (%r8,%rdx,4),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
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,%rax
jne    1340 <slevmar_LUinverse_noLapack+0x1f0>
cmp    %r11,%rcx
jne    11cc <slevmar_LUinverse_noLapack+0x7c>
mov    $0x1,%ebx
test   %r9d,%r9d
jle    1d4f <slevmar_LUinverse_noLapack+0xbff>
lea    (%r15,%r11,4),%r12
lea    (%r12,%r10,4),%rax
mov    %rax,0x10(%rsp)
mov    %r9d,%r13d
lea    -0x1(%r13),%rbp
mov    %r13d,%eax
and    $0xfffffffe,%eax
lea    (%r8,%r10,4),%rdx
add    $0x4,%rdx
lea    0x0(,%r10,4),%r14
xor    %esi,%esi
xorps  %xmm2,%xmm2
movss  0xc67(%rip),%xmm0
movaps 0xc50(%rip),%xmm1
mov    %r8,0x28(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
test   %rbp,%rbp
je     1480 <slevmar_LUinverse_noLapack+0x330>
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    13d0 <slevmar_LUinverse_noLapack+0x280>
test   $0x1,%r13b
je     144e <slevmar_LUinverse_noLapack+0x2fe>
mov    %rsi,%rdi
imul   %r10,%rdi
add    %rdi,%rcx
movss  (%r15,%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    1455 <slevmar_LUinverse_noLapack+0x305>
jnp    148d <slevmar_LUinverse_noLapack+0x33d>
movaps %xmm0,%xmm4
divss  %xmm3,%xmm4
mov    0x10(%rsp),%rcx
movss  %xmm4,(%rcx,%rsi,4)
add    $0x1,%rsi
add    %r14,%rdx
cmp    %r13,%rsi
jne    13c0 <slevmar_LUinverse_noLapack+0x270>
jmp    14ae <slevmar_LUinverse_noLapack+0x35e>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
xorps  %xmm3,%xmm3
test   $0x1,%r13b
jne    1420 <slevmar_LUinverse_noLapack+0x2d0>
jmp    144e <slevmar_LUinverse_noLapack+0x2fe>
mov    0x2b44(%rip),%rax
mov    (%rax),%edi
lea    0xbb2(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x28(%rsp),%r8
xor    %ebx,%ebx
jmp    1d4f <slevmar_LUinverse_noLapack+0xbff>
test   %r9d,%r9d
jle    1d4a <slevmar_LUinverse_noLapack+0xbfa>
mov    %r11,0x70(%rsp)
mov    %rbp,0xb0(%rsp)
mov    %r9,0x40(%rsp)
lea    -0x1(%r9),%eax
mov    %rax,0x58(%rsp)
lea    (%r8,%r10,4),%rax
mov    %rax,0x18(%rsp)
lea    (%r10,%r13,1),%rax
lea    (%r8,%rax,4),%rax
mov    %rax,0xa0(%rsp)
lea    (%r8,%r13,4),%rax
mov    %rax,0xa8(%rsp)
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,0x48(%rsp)
lea    (%r8,%r10,4),%rax
add    $0x4,%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%r10,8),%r9
lea    0x4(%r8),%rax
mov    %rax,0x30(%rsp)
lea    0x30(%r8),%rax
mov    %rax,0x78(%rsp)
mov    $0xffffffff,%r11d
mov    $0x1,%esi
xorps  %xmm2,%xmm2
mov    %r10,%rax
xor    %r10d,%r10d
mov    %rax,0x8(%rsp)
mov    %rax,%rdi
jmp    15af <slevmar_LUinverse_noLapack+0x45f>
nopl   (%rax)
add    $0x1,%r10
mov    %r10,%rax
mov    0x8(%rsp),%rcx
add    $0x1,%rsi
add    %rcx,%rdi
mov    %rax,%r10
cmp    %r13,%rax
je     1a62 <slevmar_LUinverse_noLapack+0x912>
mov    %rdi,0x60(%rsp)
mov    %rsi,0x38(%rsp)
test   %r10,%r10
je     1690 <slevmar_LUinverse_noLapack+0x540>
mov    0x28(%rsp),%rax
lea    (%rax,%r10,4),%r8
mov    0x50(%rsp),%rdx
xor    %ecx,%ecx
jmp    15f6 <slevmar_LUinverse_noLapack+0x4a6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm3,(%r15,%rbx,4)
add    $0x1,%rcx
add    %r14,%rdx
cmp    %r10,%rcx
je     1690 <slevmar_LUinverse_noLapack+0x540>
mov    %rcx,%rbp
imul   0x8(%rsp),%rbp
lea    (%r10,%rbp,1),%rbx
movss  (%r15,%rbx,4),%xmm3
test   %rcx,%rcx
je     15e0 <slevmar_LUinverse_noLapack+0x490>
cmp    $0x1,%rcx
jne    1620 <slevmar_LUinverse_noLapack+0x4d0>
xor    %eax,%eax
jmp    165b <slevmar_LUinverse_noLapack+0x50b>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r8,%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movss  -0x4(%rdx,%rax,4),%xmm4
mulss  (%rdi,%r14,1),%xmm4
movss  (%rdx,%rax,4),%xmm5
subss  %xmm4,%xmm3
mulss  (%rdi,%r9,1),%xmm5
add    %r9,%rdi
subss  %xmm5,%xmm3
add    $0x2,%rax
cmp    %rax,%rsi
jne    1630 <slevmar_LUinverse_noLapack+0x4e0>
test   $0x1,%cl
je     15e0 <slevmar_LUinverse_noLapack+0x490>
add    %rax,%rbp
movss  (%r15,%rbp,4),%xmm4
imul   0x8(%rsp),%rax
add    %r10,%rax
mulss  (%r15,%rax,4),%xmm4
subss  %xmm4,%xmm3
jmp    15e0 <slevmar_LUinverse_noLapack+0x490>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x4(,%r10,4),%rcx
imul   0x8(%rsp),%rcx
mov    0x30(%rsp),%rax
mov    %rcx,0x20(%rsp)
add    %rcx,%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%r10,4),%rdi
xorps  %xmm3,%xmm3
mov    %r10,%rdx
jmp    1725 <slevmar_LUinverse_noLapack+0x5d5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm4,(%r15,%r8,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,%rdx,4),%xmm6
ucomiss %xmm3,%xmm6
cmovae %edx,%r11d
movaps %xmm3,%xmm4
cmpnless %xmm6,%xmm4
movaps %xmm4,%xmm5
andnps %xmm6,%xmm5
andps  %xmm3,%xmm4
orps   %xmm5,%xmm4
add    $0x1,%rdx
add    %r14,%rax
movaps %xmm4,%xmm3
cmp    %r13,%rdx
je     17c0 <slevmar_LUinverse_noLapack+0x670>
mov    %rdx,%rcx
imul   0x8(%rsp),%rcx
lea    (%rcx,%r10,1),%r8
movss  (%r15,%r8,4),%xmm4
test   %r10,%r10
je     16d0 <slevmar_LUinverse_noLapack+0x580>
cmp    $0x1,%r10
jne    1750 <slevmar_LUinverse_noLapack+0x600>
xor    %ebx,%ebx
jmp    178d <slevmar_LUinverse_noLapack+0x63d>
nopw   0x0(%rax,%rax,1)
mov    %rdi,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rax,%rbx,4),%xmm5
mulss  0x0(%rbp,%r14,1),%xmm5
movss  (%rax,%rbx,4),%xmm6
subss  %xmm5,%xmm4
mulss  0x0(%rbp,%r9,1),%xmm6
add    %r9,%rbp
subss  %xmm6,%xmm4
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    1760 <slevmar_LUinverse_noLapack+0x610>
test   $0x1,%r10b
je     16d0 <slevmar_LUinverse_noLapack+0x580>
add    %rbx,%rcx
movss  (%r15,%rcx,4),%xmm5
imul   0x8(%rsp),%rbx
add    %r10,%rbx
mulss  (%r15,%rbx,4),%xmm5
subss  %xmm5,%xmm4
jmp    16d0 <slevmar_LUinverse_noLapack+0x580>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%eax
cmp    %rax,%r10
mov    0x28(%rsp),%r8
je     19c6 <slevmar_LUinverse_noLapack+0x876>
mov    %r11d,%eax
mov    0x40(%rsp),%rcx
imul   %ecx,%eax
mov    %r10,%rdx
imul   0x8(%rsp),%rdx
cltq
cmp    $0x8,%ecx
jae    1800 <slevmar_LUinverse_noLapack+0x6b0>
xor    %esi,%esi
mov    0x20(%rsp),%rdi
jmp    1920 <slevmar_LUinverse_noLapack+0x7d0>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    0xa8(%rsp),%rsi
mov    0x20(%rsp),%rdi
add    %rdi,%rsi
cmp    %rcx,%rsi
jbe    183a <slevmar_LUinverse_noLapack+0x6ea>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
lea    (%r8,%rdi,1),%rsi
cmp    %rcx,%rsi
jae    183a <slevmar_LUinverse_noLapack+0x6ea>
xor    %esi,%esi
jmp    1920 <slevmar_LUinverse_noLapack+0x7d0>
cmpq   $0x0,0x90(%rsp)
je     1a4d <slevmar_LUinverse_noLapack+0x8fd>
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
add    $0x30,%rsi
mov    0x78(%rsp),%rcx
lea    (%rcx,%rdi,1),%rbp
mov    0x80(%rsp),%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x30(%rsi,%rcx,4),%xmm3
movups -0x20(%rsi,%rcx,4),%xmm4
movups -0x30(%rbp,%rcx,4),%xmm5
movups -0x20(%rbp,%rcx,4),%xmm6
movups %xmm5,-0x30(%rsi,%rcx,4)
movups %xmm6,-0x20(%rsi,%rcx,4)
movups %xmm3,-0x30(%rbp,%rcx,4)
movups %xmm4,-0x20(%rbp,%rcx,4)
movups -0x10(%rsi,%rcx,4),%xmm3
movups (%rsi,%rcx,4),%xmm4
movups -0x10(%rbp,%rcx,4),%xmm5
movups 0x0(%rbp,%rcx,4),%xmm6
movups %xmm5,-0x10(%rsi,%rcx,4)
movups %xmm6,(%rsi,%rcx,4)
movups %xmm3,-0x10(%rbp,%rcx,4)
movups %xmm4,0x0(%rbp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1870 <slevmar_LUinverse_noLapack+0x720>
testb  $0x1,0x88(%rsp)
01
je     1905 <slevmar_LUinverse_noLapack+0x7b5>
lea    (%rcx,%rax,1),%rsi
movups (%r15,%rsi,4),%xmm3
movups 0x10(%r15,%rsi,4),%xmm4
add    %rdx,%rcx
movups (%r15,%rcx,4),%xmm5
movups 0x10(%r15,%rcx,4),%xmm6
movups %xmm5,(%r15,%rsi,4)
movups %xmm6,0x10(%r15,%rsi,4)
movups %xmm3,(%r15,%rcx,4)
movups %xmm4,0x10(%r15,%rcx,4)
mov    0x98(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r13,%rcx
mov    0x20(%rsp),%rdi
je     19b3 <slevmar_LUinverse_noLapack+0x863>
xchg   %ax,%ax
mov    %rsi,%rcx
test   $0x1,%r13b
je     194f <slevmar_LUinverse_noLapack+0x7ff>
lea    (%rsi,%rax,1),%rcx
movss  (%r15,%rcx,4),%xmm3
add    %rsi,%rdx
movss  (%r15,%rdx,4),%xmm4
movss  %xmm4,(%r15,%rcx,4)
movss  %xmm3,(%r15,%rdx,4)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x48(%rsp),%rsi
je     19b3 <slevmar_LUinverse_noLapack+0x863>
add    %r8,%rdi
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
lea    0x1(%r10),%rdx
imul   0x8(%rsp),%rdx
mov    0x30(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  %xmm4,(%rax,%rcx,4)
movss  %xmm3,(%rdi,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rax,%rcx,4)
movss  %xmm3,(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1980 <slevmar_LUinverse_noLapack+0x830>
mov    0x10(%rsp),%rcx
movss  (%rcx,%r10,4),%xmm3
movslq %r11d,%rax
movss  %xmm3,(%rcx,%rax,4)
mov    %r11d,(%r8,%r10,4)
mov    %r10d,%eax
imul   0x40(%rsp),%eax
cltq
add    %r10,%rax
movss  (%r15,%rax,4),%xmm4
ucomiss %xmm2,%xmm4
mov    0x38(%rsp),%rsi
mov    0x60(%rsp),%rdi
jne    19ff <slevmar_LUinverse_noLapack+0x8af>
jp     19ff <slevmar_LUinverse_noLapack+0x8af>
mov    0x25eb(%rip),%rcx
movss  (%rcx),%xmm4
movss  %xmm4,(%r15,%rax,4)
cmp    0x58(%rsp),%r10
je     1590 <slevmar_LUinverse_noLapack+0x440>
lea    0x1(%r10),%rax
cmp    0x8(%rsp),%rax
jge    1597 <slevmar_LUinverse_noLapack+0x447>
movaps %xmm0,%xmm3
divss  %xmm4,%xmm3
add    %rdi,%r10
mov    0x18(%rsp),%rcx
lea    (%rcx,%r10,4),%rcx
mov    %r13,%rdx
nop
movss  (%rcx),%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rsi
jne    1a30 <slevmar_LUinverse_noLapack+0x8e0>
jmp    1597 <slevmar_LUinverse_noLapack+0x447>
xor    %ecx,%ecx
testb  $0x1,0x88(%rsp)
01
jne    18d2 <slevmar_LUinverse_noLapack+0x782>
jmp    1905 <slevmar_LUinverse_noLapack+0x7b5>
cmpl   $0x0,0x40(%rsp)
jle    1d4a <slevmar_LUinverse_noLapack+0xbfa>
lea    0x0(,%r13,4),%rax
mov    %rax,0x60(%rsp)
mov    %r13d,%esi
and    $0x3,%esi
mov    %r13d,%r9d
and    $0xfffffffc,%r9d
mov    0x8(%rsp),%rcx
mov    0x70(%rsp),%rax
add    %rcx,%rax
lea    (%r8,%rax,4),%rbx
add    $0x4,%rbx
mov    %rcx,%rax
imul   %rcx,%rax
lea    (%r8,%rax,4),%rax
add    $0x4,%rax
mov    %rax,0x30(%rsp)
mov    %r14,%r11
neg    %r11
mov    %rcx,%r10
shl    $0x4,%r10
lea    (%r14,%r14,2),%rdi
xor    %eax,%eax
mov    0x68(%rsp),%rcx
mov    %rcx,0x38(%rsp)
mov    %rsi,0x20(%rsp)
mov    %r9,0x18(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x50(%rsp)
mov    %rdi,0x48(%rsp)
mov    0x8(%rsp),%rbp
jmp    1b08 <slevmar_LUinverse_noLapack+0x9b8>
nopl   (%rax)
mov    0x10(%rsp),%rax
add    $0x1,%rax
addq   $0x4,0x38(%rsp)
cmp    %r13,%rax
je     1d4a <slevmar_LUinverse_noLapack+0xbfa>
mov    %rax,0x10(%rsp)
mov    %r12,%rdi
xor    %esi,%esi
mov    0x60(%rsp),%rdx
call   1040 <memset@plt>
xorps  %xmm2,%xmm2
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%rax
movl   $0x3f800000,(%r12,%rax,4)
3f
mov    %r15,%rax
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x40(%rsp),%r9
mov    0xb0(%rsp),%r10
jmp    1b6c <slevmar_LUinverse_noLapack+0xa1c>
nopw   0x0(%rax,%rax,1)
ucomiss %xmm2,%xmm0
jne    1b57 <slevmar_LUinverse_noLapack+0xa07>
jnp    1bbe <slevmar_LUinverse_noLapack+0xa6e>
lea    0x1(%rcx),%edx
movss  %xmm0,(%r12,%rcx,4)
add    $0x1,%rcx
add    %r14,%rax
cmp    %r13,%rcx
je     1bd0 <slevmar_LUinverse_noLapack+0xa80>
movslq (%r8,%rcx,4),%rsi
movss  (%r12,%rsi,4),%xmm0
movss  (%r12,%rcx,4),%xmm1
movss  %xmm1,(%r12,%rsi,4)
test   %edx,%edx
je     1b50 <slevmar_LUinverse_noLapack+0xa00>
movslq %edx,%rsi
cmp    %rsi,%rcx
jl     1b5a <slevmar_LUinverse_noLapack+0xa0a>
lea    -0x1(%rdx),%esi
movslq %esi,%rsi
add    $0x1,%rsi
nopl   0x0(%rax,%rax,1)
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    1ba0 <slevmar_LUinverse_noLapack+0xa50>
jmp    1b5a <slevmar_LUinverse_noLapack+0xa0a>
xor    %edx,%edx
jmp    1b5a <slevmar_LUinverse_noLapack+0xa0a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
mov    0x30(%rsp),%rcx
mov    %rbp,%rdx
mov    0x58(%rsp),%r11
jmp    1c18 <slevmar_LUinverse_noLapack+0xac8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
imul   %r9d,%edi
movslq %edi,%rdi
add    %rdx,%rdi
divss  (%r15,%rdi,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
add    $0x1,%eax
add    %r11,%rcx
cmp    $0x1,%rsi
jle    1ca0 <slevmar_LUinverse_noLapack+0xb50>
mov    %rdx,%rsi
add    $0xffffffffffffffff,%rdx
movss  -0x4(%r12,%rsi,4),%xmm0
cmp    %rbp,%rsi
jge    1bf0 <slevmar_LUinverse_noLapack+0xaa0>
test   $0x1,%al
jne    1c40 <slevmar_LUinverse_noLapack+0xaf0>
mov    %rsi,%rdi
cmp    $0x1,%eax
jne    1c70 <slevmar_LUinverse_noLapack+0xb20>
jmp    1bf0 <slevmar_LUinverse_noLapack+0xaa0>
nopl   0x0(%rax)
mov    %rdx,%rdi
imul   %rbp,%rdi
add    %rsi,%rdi
movss  (%r15,%rdi,4),%xmm1
mulss  (%r12,%rsi,4),%xmm1
subss  %xmm1,%xmm0
lea    0x1(%rsi),%rdi
cmp    $0x1,%eax
je     1bf0 <slevmar_LUinverse_noLapack+0xaa0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rcx,%rdi,4),%xmm1
movss  (%rcx,%rdi,4),%xmm2
mulss  -0x4(%rbx,%rdi,4),%xmm1
mulss  (%rbx,%rdi,4),%xmm2
subss  %xmm1,%xmm0
subss  %xmm2,%xmm0
add    $0x2,%rdi
cmp    %edi,%r13d
jne    1c70 <slevmar_LUinverse_noLapack+0xb20>
jmp    1bf0 <slevmar_LUinverse_noLapack+0xaa0>
nopl   0x0(%rax)
cmp    $0x3,%r10
jae    1cb0 <slevmar_LUinverse_noLapack+0xb60>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
jmp    1d06 <slevmar_LUinverse_noLapack+0xbb6>
nop
mov    0x38(%rsp),%rcx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%r9
mov    0x50(%rsp),%r10
mov    0x48(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rbp,4)
movss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rbp,8)
movss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    $0x4,%rax
add    %r10,%rcx
cmp    %rax,%r9
jne    1cd0 <slevmar_LUinverse_noLapack+0xb80>
test   %rsi,%rsi
je     1af0 <slevmar_LUinverse_noLapack+0x9a0>
mov    %rbp,%rcx
imul   %rax,%rcx
add    0x10(%rsp),%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
lea    (%rbx,%rax,4),%rax
add    $0xfffffffffffffffc,%rax
xor    %edx,%edx
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rcx)
add    $0x1,%rdx
add    %r14,%rcx
cmp    %rdx,%rsi
jne    1d30 <slevmar_LUinverse_noLapack+0xbe0>
jmp    1af0 <slevmar_LUinverse_noLapack+0x9a0>
mov    $0x1,%ebx
mov    %r8,%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2266(%rip),%rax
mov    (%rax),%edi
lea    0x299(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>

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

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