#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 */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ sgeqp3_(int *, int *, float *, int *, int *, float *,
                           float *, int *, int *);
int /*<<< orphan*/ sorgqr_(int *, int *, int *, float *, int *, float *,
                           float *, int *, int *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strtri_(char *, char *, int *, float *, int *, int *);
int slmlec_elim(float *A, float *b, float *c, float *Y, float *Z, int m,
                int n) {
  static float eps = -1.0F;
  float *buf = NULL;
  float *a, *tau, *work, *r, aux;
  register float tmp;
  int a_sz, jpvt_sz, tau_sz, r_sz, Y_sz, worksz;
  int info, rank, *jpvt, tot_sz, mintmn, tm, tn;
  register int i, j, k;
  if (m > n) {
    fprintf(stderr,
            "matrix of constraints cannot have more rows than columns in"
            "slmlec_elim"
            "()!\n");
    return -1;
  }
  tm = n;
  tn = m;
  mintmn = m;
  worksz = -1;
  sgeqp3_((int *)&tm, (int *)&tn, NULL, (int *)&tm, NULL, NULL, (float *)&aux,
          (int *)&worksz, &info);
  worksz = (int)aux;
  a_sz = tm * tm;
  jpvt_sz = tn;
  tau_sz = mintmn;
  r_sz = mintmn * mintmn;
  Y_sz = (Y) ? 0 : tm * tn;
  tot_sz = (a_sz + tau_sz + r_sz + worksz + Y_sz) * sizeof(float) +
           jpvt_sz * sizeof(int);
  buf = (float *)malloc(tot_sz);
  if (!buf) {
    fprintf(stderr, "Memory allocation request failed in "
                    "slmlec_elim"
                    "()\n");
    return -1;
  }
  a = buf;
  tau = a + a_sz;
  r = tau + tau_sz;
  work = r + r_sz;
  if (!Y) {
    Y = work + worksz;
    jpvt = (int *)(Y + Y_sz);
  } else
    jpvt = (int *)(work + worksz);
  for (i = 0; i < tm * tn; ++i)
    a[i] = A[i];
  for (i = 0; i < jpvt_sz; ++i)
    jpvt[i] = 0;
  sgeqp3_((int *)&tm, (int *)&tn, a, (int *)&tm, jpvt, tau, work,
          (int *)&worksz, &info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "sgeqp3_"
              " in "
              "slmlec_elim"
              "()\n",
              -info);
    } else if (info > 0) {
      fprintf(stderr,
              "unknown LAPACK error (%d) for "
              "sgeqp3_"
              " in "
              "slmlec_elim"
              "()\n",
              info);
    }
    free(buf);
    return -1;
  }
  if (eps < 0.0) {
    float aux;
    for (eps = 1.0F; aux = eps + 1.0F, aux - 1.0F > 0.0; eps *= 0.5F)
      ;
    eps *= 2.0F;
  }
  tmp = tm * 10.0F * eps * (((a[0]) >= 0.0) ? (a[0]) : -(a[0]));
  tmp = (tmp > 1E-12F) ? tmp : 1E-12F;
  for (i = rank = 0; i < mintmn; ++i)
    if (a[i * (tm + 1)] > tmp || a[i * (tm + 1)] < -tmp)
      ++rank;
    else
      break;
  if (rank < tn) {
    fprintf(stderr,
            "\nConstraints matrix in "
            "slmlec_elim"
            "() is not of full row rank (i.e. %d < %d)!\n"
            "Make sure that you do not specify redundant or inconsistent "
            "constraints.\n\n",
            rank, tn);
    free(buf);
    return -1;
  }
  for (j = 0; j < rank; ++j) {
    for (i = 0; i <= j; ++i)
      r[j + i * rank] = a[i + j * tm];
    for (i = j + 1; i < rank; ++i)
      r[j + i * rank] = 0.0;
  }
  strtri_("L", "N", (int *)&rank, r, (int *)&rank, &info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "strtri_"
              " in "
              "slmlec_elim"
              "()\n",
              -info);
    } else if (info > 0) {
      fprintf(stderr,
              "A(%d, %d) is exactly zero for "
              "strtri_"
              " (singular matrix) in "
              "slmlec_elim"
              "()\n",
              info, info);
    }
    free(buf);
    return -1;
  }
  for (j = 0; j < rank; ++j)
    for (i = 0, k = jpvt[j] - 1; i < rank; ++i)
      Y[i + k * rank] = r[i + j * rank];
  for (i = 0; i < rank * rank; ++i)
    r[i] = Y[i];
  for (i = tm * tn; i < tm * tm; ++i)
    a[i] = 0.0;
  sorgqr_((int *)&tm, (int *)&tm, (int *)&mintmn, a, (int *)&tm, tau, work,
          &worksz, &info);
  if (info != 0) {
    if (info < 0) {
      fprintf(stderr,
              "LAPACK error: illegal value for argument %d of "
              "sorgqr_"
              " in "
              "slmlec_elim"
              "()\n",
              -info);
    } else if (info > 0) {
      fprintf(stderr,
              "unknown LAPACK error (%d) for "
              "sorgqr_"
              " in "
              "slmlec_elim"
              "()\n",
              info);
    }
    free(buf);
    return -1;
  }
  for (i = 0; i < tm; ++i)
    for (j = 0; j < rank; ++j) {
      for (k = 0, tmp = 0.0; k < rank; ++k)
        tmp += a[i + k * tm] * r[k + j * rank];
      Y[i * rank + j] = tmp;
    }
  if (b && c) {
    for (i = 0; i < tm; ++i) {
      for (j = 0, tmp = 0.0; j < rank; ++j)
        tmp += Y[i * rank + j] * b[j];
      c[i] = tmp;
    }
  }
  for (j = 0; j < tm - rank; ++j)
    for (i = 0, k = j + rank; i < tm; ++i)
      Z[i * (tm - rank) + j] = a[i + k * tm];
  free(buf);
  return rank;
}


x86 assembly (clang, -O0):
<slmlec_elim>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jle    11bd <slmlec_elim+0x5d>
mov    0x2e3f(%rip),%rax
mov    (%rax),%edi
lea    0xe6a(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
mov    0x10(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0xffffffff,-0x80(%rbp)
lea    -0x9c(%rbp),%rcx
lea    -0xa0(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%r9d
lea    -0x64(%rbp),%r11
lea    -0x80(%rbp),%r10
lea    -0x84(%rbp),%rax
mov    %rcx,%rdi
mov    %r9,%rdx
mov    %r9,%r8
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <sgeqp3_@plt>
cvttss2si -0x64(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x98(%rbp),%eax
imul   -0x98(%rbp),%eax
mov    %eax,-0x78(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     126f <slmlec_elim+0x10f>
xor    %eax,%eax
mov    %eax,-0xb4(%rbp)
jmp    1282 <slmlec_elim+0x122>
mov    -0x9c(%rbp),%eax
imul   -0xa0(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x74(%rbp),%eax
add    -0x78(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x7c(%rbp),%eax
cltq
shl    $0x2,%rax
movslq -0x70(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    12ee <slmlec_elim+0x18e>
mov    0x2d0e(%rip),%rax
mov    (%rax),%edi
lea    0xd84(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    1368 <slmlec_elim+0x208>
mov    -0x58(%rbp),%rax
movslq -0x80(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
jmp    137e <slmlec_elim+0x21e>
mov    -0x58(%rbp),%rax
movslq -0x80(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
cmp    %ecx,%eax
jge    13d7 <slmlec_elim+0x277>
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1388 <slmlec_elim+0x228>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1419 <slmlec_elim+0x2b9>
mov    -0x90(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    13e1 <slmlec_elim+0x281>
mov    -0x48(%rbp),%rdx
mov    -0x90(%rbp),%r8
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r11
lea    -0x9c(%rbp),%rcx
lea    -0xa0(%rbp),%rsi
lea    -0x80(%rbp),%r10
lea    -0x84(%rbp),%rax
mov    %rcx,%rdi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <sgeqp3_@plt>
cmpl   $0x0,-0x84(%rbp)
je     14dd <slmlec_elim+0x37d>
cmpl   $0x0,-0x84(%rbp)
jge    1499 <slmlec_elim+0x339>
mov    0x2b64(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x84(%rbp),%edx
lea    0xc05(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    14c8 <slmlec_elim+0x368>
cmpl   $0x0,-0x84(%rbp)
jle    14c3 <slmlec_elim+0x363>
mov    0x2b33(%rip),%rax
mov    (%rax),%edi
mov    -0x84(%rbp),%edx
lea    0xc1f(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    14c8 <slmlec_elim+0x368>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
movss  0x2b6b(%rip),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    157d <slmlec_elim+0x41d>
movss  0xb02(%rip),%xmm0
movss  %xmm0,0x2b4a(%rip)
movss  0xaf2(%rip),%xmm0
addss  0x2b3a(%rip),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  0xad2(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1565 <slmlec_elim+0x405>
jmp    1548 <slmlec_elim+0x3e8>
movss  0xac0(%rip),%xmm0
mulss  0x2af8(%rip),%xmm0
movss  %xmm0,0x2af0(%rip)
jmp    1506 <slmlec_elim+0x3a6>
movss  0xa97(%rip),%xmm0
mulss  0x2adb(%rip),%xmm0
movss  %xmm0,0x2ad3(%rip)
cvtsi2ssl -0x9c(%rbp),%xmm0
ff
movss  0xa7b(%rip),%xmm1
mulss  %xmm1,%xmm0
mulss  0x2ab7(%rip),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15cf <slmlec_elim+0x46f>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
jmp    15ec <slmlec_elim+0x48c>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
movss  0x9fa(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    162d <slmlec_elim+0x4cd>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
jmp    1642 <slmlec_elim+0x4e2>
movss  0x9d7(%rip),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
jmp    1642 <slmlec_elim+0x4e2>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1708 <slmlec_elim+0x5a8>
mov    -0x48(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x68(%rbp),%xmm0
ja     16d6 <slmlec_elim+0x576>
mov    -0x48(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    16ea <slmlec_elim+0x58a>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    16ef <slmlec_elim+0x58f>
jmp    1708 <slmlec_elim+0x5a8>
jmp    16f4 <slmlec_elim+0x594>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1663 <slmlec_elim+0x503>
mov    -0x88(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1752 <slmlec_elim+0x5f2>
mov    0x28bf(%rip),%rax
mov    (%rax),%edi
mov    -0x88(%rbp),%edx
mov    -0xa0(%rbp),%ecx
lea    0x9dd(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1852 <slmlec_elim+0x6f2>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     17e0 <slmlec_elim+0x680>
mov    -0x48(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
imul   -0x88(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1778 <slmlec_elim+0x618>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1839 <slmlec_elim+0x6d9>
mov    -0x60(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
imul   -0x88(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    17ef <slmlec_elim+0x68f>
jmp    183e <slmlec_elim+0x6de>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    175c <slmlec_elim+0x5fc>
mov    -0x60(%rbp),%rcx
lea    0x94e(%rip),%rdi
lea    0x949(%rip),%rsi
lea    -0x88(%rbp),%r8
lea    -0x84(%rbp),%r9
mov    %r8,%rdx
call   1080 <strtri_@plt>
cmpl   $0x0,-0x84(%rbp)
je     1902 <slmlec_elim+0x7a2>
cmpl   $0x0,-0x84(%rbp)
jge    18b8 <slmlec_elim+0x758>
mov    0x2745(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x84(%rbp),%edx
lea    0x903(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    18ed <slmlec_elim+0x78d>
cmpl   $0x0,-0x84(%rbp)
jle    18e8 <slmlec_elim+0x788>
mov    0x2714(%rip),%rax
mov    (%rax),%edi
mov    -0x84(%rbp),%edx
mov    -0x84(%rbp),%ecx
lea    0x917(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    18ed <slmlec_elim+0x78d>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    19c3 <slmlec_elim+0x863>
movl   $0x0,-0xa4(%rbp)
mov    -0x90(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    19aa <slmlec_elim+0x84a>
mov    -0x60(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x88(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xac(%rbp),%edx
imul   -0x88(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1942 <slmlec_elim+0x7e2>
jmp    19af <slmlec_elim+0x84f>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    190c <slmlec_elim+0x7ac>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x88(%rbp),%ecx
imul   -0x88(%rbp),%ecx
cmp    %ecx,%eax
jge    1a1c <slmlec_elim+0x8bc>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    19cd <slmlec_elim+0x86d>
mov    -0x9c(%rbp),%eax
imul   -0xa0(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
cmp    %ecx,%eax
jge    1a71 <slmlec_elim+0x911>
mov    -0x48(%rbp),%rax
movslq -0xa4(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1a2f <slmlec_elim+0x8cf>
mov    -0x48(%rbp),%rcx
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r11
lea    -0x9c(%rbp),%r8
lea    -0x98(%rbp),%rdx
lea    -0x80(%rbp),%r10
lea    -0x84(%rbp),%rax
mov    %r8,%rdi
mov    %r8,%rsi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1040 <sorgqr_@plt>
cmpl   $0x0,-0x84(%rbp)
je     1b31 <slmlec_elim+0x9d1>
cmpl   $0x0,-0x84(%rbp)
jge    1aed <slmlec_elim+0x98d>
mov    0x2510(%rip),%rax
mov    (%rax),%edi
xor    %edx,%edx
sub    -0x84(%rbp),%edx
lea    0x761(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b1c <slmlec_elim+0x9bc>
cmpl   $0x0,-0x84(%rbp)
jle    1b17 <slmlec_elim+0x9b7>
mov    0x24df(%rip),%rax
mov    (%rax),%edi
mov    -0x84(%rbp),%edx
lea    0x77b(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b1c <slmlec_elim+0x9bc>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df8 <slmlec_elim+0xc98>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1c46 <slmlec_elim+0xae6>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1c2d <slmlec_elim+0xacd>
movl   $0x0,-0xac(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1bf5 <slmlec_elim+0xa95>
mov    -0x48(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xac(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x88(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1b7b <slmlec_elim+0xa1b>
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1b57 <slmlec_elim+0x9f7>
jmp    1c32 <slmlec_elim+0xad2>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1b3b <slmlec_elim+0x9db>
cmpq   $0x0,-0x18(%rbp)
je     1d1f <slmlec_elim+0xbbf>
cmpq   $0x0,-0x20(%rbp)
je     1d1f <slmlec_elim+0xbbf>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1d1a <slmlec_elim+0xbba>
movl   $0x0,-0xa8(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1cf1 <slmlec_elim+0xb91>
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1c8a <slmlec_elim+0xb2a>
movss  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1c66 <slmlec_elim+0xb06>
jmp    1d1f <slmlec_elim+0xbbf>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x9c(%rbp),%ecx
sub    -0x88(%rbp),%ecx
cmp    %ecx,%eax
jge    1de6 <slmlec_elim+0xc86>
movl   $0x0,-0xa4(%rbp)
mov    -0xa8(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1dcd <slmlec_elim+0xc6d>
mov    -0x48(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xac(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
sub    -0x88(%rbp),%edx
imul   %edx,%ecx
add    -0xa8(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1d5f <slmlec_elim+0xbff>
jmp    1dd2 <slmlec_elim+0xc72>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1d29 <slmlec_elim+0xbc9>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slmlec_elim>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    0x100(%rsp),%eax
cmp    %eax,%r9d
jle    11a2 <slmlec_elim+0x32>
mov    0x2e4c(%rip),%rax
mov    (%rax),%edi
lea    0xe83(%rip),%rsi
jmp    1371 <slmlec_elim+0x201>
mov    %rcx,%r12
mov    %rdi,%rbp
mov    %rsi,0xb8(%rsp)
mov    %rdx,0xc0(%rsp)
mov    %r8,0x68(%rsp)
mov    %eax,0xc(%rsp)
mov    %r9d,0x10(%rsp)
mov    %r9d,0x3c(%rsp)
movl   $0xffffffff,0x24(%rsp)
ff
sub    $0x8,%rsp
lea    0x28(%rsp),%rax
lea    0x2c(%rsp),%rbx
lea    0x6c(%rsp),%r10
lea    0x18(%rsp),%rsi
lea    0x14(%rsp),%rcx
mov    %rcx,%rdi
xor    %edx,%edx
xor    %r8d,%r8d
xor    %r9d,%r9d
push   %rax
push   %rbx
push   %r10
call   1050 <sgeqp3_@plt>
add    $0x20,%rsp
cvttss2si 0x64(%rsp),%edi
mov    %edi,0x24(%rsp)
mov    0xc(%rsp),%r13d
mov    0x10(%rsp),%eax
movslq 0x3c(%rsp),%r14
mov    %r14d,%r15d
imul   %r14d,%r15d
mov    %eax,%ebx
imul   %r13d,%ebx
imul   %r13d,%r13d
test   %r12,%r12
mov    $0x0,%ecx
cmovne %ecx,%ebx
add    %r13d,%edi
mov    %rax,0x28(%rsp)
add    %eax,%edi
add    %r14d,%edi
add    %r15d,%edi
add    %ebx,%edi
shl    $0x2,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     1361 <slmlec_elim+0x1f1>
xor    %r9d,%r9d
test   %r12,%r12
mov    %r13d,%ecx
mov    %rcx,0x30(%rsp)
lea    (%rax,%rcx,4),%rcx
mov    %r14,0x58(%rsp)
mov    %rcx,0x50(%rsp)
lea    (%rcx,%r14,4),%r13
mov    %r15d,%ecx
lea    0x0(%r13,%rcx,4),%rdx
movslq 0x24(%rsp),%rcx
mov    %rdx,0x40(%rsp)
lea    (%rdx,%rcx,4),%r8
movslq %ebx,%rcx
cmove  %rcx,%r9
cmove  %r8,%r12
mov    %r12,0x18(%rsp)
mov    0x10(%rsp),%ecx
imul   0xc(%rsp),%ecx
test   %ecx,%ecx
mov    %rax,%r14
lea    0x24(%rsp),%r15
jle    1454 <slmlec_elim+0x2e4>
mov    %ecx,%edx
cmp    $0x8,%ecx
jb     12e6 <slmlec_elim+0x176>
lea    0x0(,%rdx,4),%rax
add    %rbp,%rax
cmp    %rax,%r14
jae    137d <slmlec_elim+0x20d>
lea    (%r14,%rdx,4),%rax
cmp    %rbp,%rax
jbe    137d <slmlec_elim+0x20d>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
add    %rdx,%rcx
mov    %rdx,%rdi
and    $0x3,%rdi
je     1316 <slmlec_elim+0x1a6>
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rsi,4),%xmm0
movss  %xmm0,(%r14,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1300 <slmlec_elim+0x190>
cmp    $0x3,%rcx
jb     1454 <slmlec_elim+0x2e4>
movss  0x0(%rbp,%rsi,4),%xmm0
movss  %xmm0,(%r14,%rsi,4)
movss  0x4(%rbp,%rsi,4),%xmm0
movss  %xmm0,0x4(%r14,%rsi,4)
movss  0x8(%rbp,%rsi,4),%xmm0
movss  %xmm0,0x8(%r14,%rsi,4)
movss  0xc(%rbp,%rsi,4),%xmm0
movss  %xmm0,0xc(%r14,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1320 <slmlec_elim+0x1b0>
jmp    1454 <slmlec_elim+0x2e4>
mov    0x2c78(%rip),%rax
mov    (%rax),%edi
lea    0xcfa(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
jmp    172e <slmlec_elim+0x5be>
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rax
jae    13a0 <slmlec_elim+0x230>
xor    %ecx,%ecx
jmp    1411 <slmlec_elim+0x2a1>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
movups %xmm0,(%r14,%rcx,4)
movups %xmm1,0x10(%r14,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm0
movups 0x30(%rbp,%rcx,4),%xmm1
movups %xmm0,0x20(%r14,%rcx,4)
movups %xmm1,0x30(%r14,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm0
movups 0x50(%rbp,%rcx,4),%xmm1
movups %xmm0,0x40(%r14,%rcx,4)
movups %xmm1,0x50(%r14,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm0
movups 0x70(%rbp,%rcx,4),%xmm1
movups %xmm0,0x60(%r14,%rcx,4)
movups %xmm1,0x70(%r14,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    13b0 <slmlec_elim+0x240>
test   %rbx,%rbx
je     144b <slmlec_elim+0x2db>
lea    (%r14,%rcx,4),%rdi
add    $0x10,%rdi
lea    0x10(,%rcx,4),%rcx
add    %rbp,%rcx
shl    $0x5,%rbx
xor    %eax,%eax
nop
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%rdi,%rax,1)
movups %xmm1,(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1430 <slmlec_elim+0x2c0>
cmp    %rdx,%rsi
jne    12e8 <slmlec_elim+0x178>
lea    (%r8,%r9,4),%rbx
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    146f <slmlec_elim+0x2ff>
shl    $0x2,%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1060 <memset@plt>
sub    $0x8,%rsp
lea    0x18(%rsp),%rsi
lea    0x14(%rsp),%rcx
mov    %rcx,%rdi
mov    %r14,%rdx
mov    %rbx,%r8
mov    0x58(%rsp),%r9
lea    0x28(%rsp),%rax
push   %rax
push   %r15
push   0x58(%rsp)
call   1050 <sgeqp3_@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%edx
test   %edx,%edx
je     14c3 <slmlec_elim+0x353>
mov    0x2b31(%rip),%rax
mov    (%rax),%edi
js     16a8 <slmlec_elim+0x538>
lea    0xc29(%rip),%rsi
jmp    16b1 <slmlec_elim+0x541>
movss  0x2b8d(%rip),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    14e5 <slmlec_elim+0x375>
movl   $0x34000000,0x2b7b(%rip)
movss  0xb1b(%rip),%xmm1
movslq 0xc(%rsp),%rdi
movss  (%r14),%xmm2
movl   $0x0,0x14(%rsp)
mov    0x3c(%rsp),%eax
test   %eax,%eax
mov    %rbx,0x48(%rsp)
jle    16ba <slmlec_elim+0x54a>
cvtsi2ss %edi,%xmm3
mulss  0xaf0(%rip),%xmm3
mulss  %xmm3,%xmm1
movaps 0xaf1(%rip),%xmm3
xorps  %xmm2,%xmm3
cmpnless %xmm2,%xmm0
andps  %xmm0,%xmm3
andnps %xmm2,%xmm0
orps   %xmm3,%xmm0
mulss  %xmm1,%xmm0
maxss  0xacc(%rip),%xmm0
movaps 0xacd(%rip),%xmm1
xorps  %xmm0,%xmm1
lea    0x4(,%rdi,4),%rcx
xor    %edx,%edx
mov    %r14,%rsi
jmp    1570 <slmlec_elim+0x400>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
mov    %edx,0x14(%rsp)
add    %rcx,%rsi
cmp    %rdx,%rax
je     157e <slmlec_elim+0x40e>
movss  (%rsi),%xmm2
ucomiss %xmm0,%xmm2
ja     1560 <slmlec_elim+0x3f0>
ucomiss %xmm2,%xmm1
ja     1560 <slmlec_elim+0x3f0>
mov    0x10(%rsp),%ecx
cmp    %ecx,%edx
jl     16c7 <slmlec_elim+0x557>
mov    %rdi,0x28(%rsp)
mov    %r13,%r8
test   %edx,%edx
jle    16d9 <slmlec_elim+0x569>
mov    %edx,%ecx
lea    0x4(%r14),%rdx
mov    0x28(%rsp),%rax
lea    0x0(,%rax,4),%r9
lea    0x0(,%rcx,8),%rdi
mov    0x58(%rsp),%rax
add    %rcx,%rax
add    0x30(%rsp),%rax
lea    (%r14,%rax,4),%r15
lea    0x0(,%rcx,4),%r13
lea    0x4(,%rcx,4),%r10
mov    $0x1,%eax
xor    %r11d,%r11d
mov    %r8,%r12
jmp    1607 <slmlec_elim+0x497>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
add    %r9,%rdx
add    $0x4,%r12
add    %r10,%r15
cmp    %rcx,%r11
je     16d9 <slmlec_elim+0x569>
test   %r11,%r11
je     16a0 <slmlec_elim+0x530>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r12,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  -0x4(%rdx,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp)
movss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x2,%rbx
add    %rdi,%rbp
cmp    %rbx,%rsi
jne    1620 <slmlec_elim+0x4b0>
test   $0x1,%al
je     1665 <slmlec_elim+0x4f5>
mov    %r11,%rsi
imul   0x28(%rsp),%rsi
add    %rbx,%rsi
movss  (%r14,%rsi,4),%xmm0
imul   %rcx,%rbx
add    %r11,%rbx
movss  %xmm0,(%r8,%rbx,4)
add    $0x1,%r11
cmp    %rcx,%r11
jae    15f0 <slmlec_elim+0x480>
mov    %rcx,%rsi
mov    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%rbx)
add    %r13,%rbx
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%rax
jne    1680 <slmlec_elim+0x510>
jmp    15f0 <slmlec_elim+0x480>
nopw   0x0(%rax,%rax,1)
xor    %ebx,%ebx
test   $0x1,%al
jne    1646 <slmlec_elim+0x4d6>
jmp    1665 <slmlec_elim+0x4f5>
neg    %edx
lea    0x9ed(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
jmp    1726 <slmlec_elim+0x5b6>
mov    %r13,%r8
mov    0x10(%rsp),%ecx
xor    %edx,%edx
test   %ecx,%ecx
jle    16d9 <slmlec_elim+0x569>
mov    0x2912(%rip),%rax
mov    (%rax),%edi
lea    0xa48(%rip),%rsi
jmp    171f <slmlec_elim+0x5af>
lea    0xad7(%rip),%rdi
lea    0xad2(%rip),%rsi
lea    0x14(%rsp),%rdx
lea    0x20(%rsp),%r9
mov    %r8,%rbx
mov    %r8,%rcx
mov    %rdx,%r8
call   1090 <strtri_@plt>
mov    0x20(%rsp),%edx
test   %edx,%edx
je     1745 <slmlec_elim+0x5d5>
mov    0x28d2(%rip),%rax
mov    (%rax),%edi
js     1a66 <slmlec_elim+0x8f6>
lea    0xae7(%rip),%rsi
mov    %edx,%ecx
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0xffffffff,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,0x28(%rsp)
mov    0x14(%rsp),%edi
test   %edi,%edi
mov    0x18(%rsp),%rsi
jle    19eb <slmlec_elim+0x87b>
lea    (%rsi,%rdi,4),%rax
mov    %rax,0x98(%rsp)
mov    0x58(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,1),%rdx
add    %rdi,%rax
add    %rcx,%rax
mov    %rax,0xb0(%rsp)
mov    %edi,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rax
mov    %rax,0x88(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
mov    %rax,%rcx
mov    %rax,0x80(%rsp)
and    %rax,%rbp
mov    %rbp,0x78(%rsp)
mov    %edi,%eax
and    $0x3,%eax
mov    %rdx,0x90(%rsp)
lea    (%r14,%rdx,4),%rcx
add    $0x30,%rcx
lea    0x0(,%rdi,4),%r8
lea    0x30(%rsi),%rdx
mov    %rdx,0x70(%rsp)
lea    0xc(%rsi),%rdx
mov    %rdx,0xa0(%rsp)
mov    $0x2,%r9d
xor    %r11d,%r11d
mov    0x28(%rsp),%r12
mov    %rcx,0xa8(%rsp)
jmp    182b <slmlec_elim+0x6bb>
nopl   0x0(%rax)
add    $0x1,%r11
add    %r8,%rcx
add    %r8,%r12
add    %rdi,%r9
cmp    %rdi,%r11
mov    0x18(%rsp),%rsi
je     19eb <slmlec_elim+0x87b>
mov    0x48(%rsp),%rdx
movslq (%rdx,%r11,4),%rdx
add    $0xffffffffffffffff,%rdx
movslq %edi,%r10
imul   %rdx,%r10
cmp    $0x8,%edi
jb     188b <slmlec_elim+0x71b>
mov    %r11,%rbx
imul   %rdi,%rbx
mov    0xb0(%rsp),%rdx
add    %rbx,%rdx
lea    (%r14,%rdx,4),%rdx
lea    (%rsi,%r10,4),%rsi
cmp    %rdx,%rsi
jae    194d <slmlec_elim+0x7dd>
mov    0x90(%rsp),%rdx
add    %rbx,%rdx
lea    (%r14,%rdx,4),%rdx
mov    0x98(%rsp),%rsi
lea    (%rsi,%r10,4),%rsi
cmp    %rsi,%rdx
jae    194d <slmlec_elim+0x7dd>
xor    %edx,%edx
mov    %rdx,%rbx
not    %rbx
add    %rdi,%rbx
test   %rax,%rax
je     18d7 <slmlec_elim+0x767>
lea    (%rdx,%r10,1),%rsi
mov    0x18(%rsp),%rbp
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
lea    (%r12,%rdx,4),%r15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    18c0 <slmlec_elim+0x750>
add    %rbp,%rdx
cmp    $0x3,%rbx
jb     1810 <slmlec_elim+0x6a0>
mov    %rdi,%rbx
sub    %rdx,%rbx
add    %rdx,%r10
mov    0xa0(%rsp),%rsi
lea    (%rsi,%r10,4),%rbp
add    %r9,%rdx
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
add    $0xffffffffffffffd0,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rdx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rbp,%rsi,4)
movss  -0x4(%rdx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rbp,%rsi,4)
movss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rsi,4)
movss  0x4(%rdx,%rsi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    1910 <slmlec_elim+0x7a0>
jmp    1810 <slmlec_elim+0x6a0>
cmpq   $0x0,0x88(%rsp)
je     19dd <slmlec_elim+0x86d>
mov    0x70(%rsp),%rdx
lea    (%rdx,%r10,4),%rdx
mov    0x78(%rsp),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,4)
movups %xmm1,-0x20(%rdx,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,4)
movups %xmm1,(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1970 <slmlec_elim+0x800>
testb  $0x1,0x80(%rsp)
01
je     19cc <slmlec_elim+0x85c>
add    %rbp,%rbx
mov    0x28(%rsp),%rdx
movups (%rdx,%rbx,4),%xmm0
movups 0x10(%rdx,%rbx,4),%xmm1
add    %r10,%rbp
mov    0x18(%rsp),%rdx
movups %xmm0,(%rdx,%rbp,4)
movups %xmm1,0x10(%rdx,%rbp,4)
mov    %r13,%rdx
cmp    %rdi,%r13
je     1810 <slmlec_elim+0x6a0>
jmp    188d <slmlec_elim+0x71d>
xor    %ebp,%ebp
testb  $0x1,0x80(%rsp)
01
jne    19aa <slmlec_elim+0x83a>
jmp    19cc <slmlec_elim+0x85c>
imul   %edi,%edi
test   %edi,%edi
mov    0x68(%rsp),%r12
mov    0x28(%rsp),%rax
mov    0x58(%rsp),%r15
je     1bbb <slmlec_elim+0xa4b>
mov    %edi,%r8d
cmp    $0x8,%edi
jb     1a30 <slmlec_elim+0x8c0>
lea    (%rsi,%r8,4),%rcx
cmp    %rcx,%rax
jae    1ad3 <slmlec_elim+0x963>
lea    (%r15,%r8,1),%rcx
add    0x30(%rsp),%rcx
lea    (%r14,%rcx,4),%rcx
cmp    %rcx,%rsi
jae    1ad3 <slmlec_elim+0x963>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     1a74 <slmlec_elim+0x904>
mov    0x18(%rsp),%rdi
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1a50 <slmlec_elim+0x8e0>
jmp    1a79 <slmlec_elim+0x909>
neg    %edx
lea    0x74c(%rip),%rsi
jmp    16b1 <slmlec_elim+0x541>
mov    0x18(%rsp),%rdi
cmp    $0x3,%rdx
jb     1bbb <slmlec_elim+0xa4b>
mov    %rdi,%rsi
mov    0x30(%rsp),%rax
lea    (%r15,%rax,1),%rdx
lea    (%r14,%rdx,4),%rdx
add    $0xc,%rdx
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1a97 <slmlec_elim+0x927>
jmp    1bbb <slmlec_elim+0xa4b>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1af7 <slmlec_elim+0x987>
xor    %edi,%edi
jmp    1b6b <slmlec_elim+0x9fb>
and    $0xfffffffffffffffc,%rsi
mov    0x30(%rsp),%rdi
add    %r15,%rdi
lea    (%r14,%rdi,4),%rbp
add    $0x70,%rbp
xor    %edi,%edi
mov    0x18(%rsp),%rbx
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x70(%rbp,%rdi,4)
movups %xmm1,-0x60(%rbp,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x50(%rbp,%rdi,4)
movups %xmm1,-0x40(%rbp,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm1,-0x20(%rbp,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm1,0x0(%rbp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1b12 <slmlec_elim+0x9a2>
test   %rdx,%rdx
je     1bb2 <slmlec_elim+0xa42>
lea    (%rdi,%r15,1),%rsi
add    0x30(%rsp),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x10,%rsi
mov    0x18(%rsp),%rbp
lea    0x10(,%rdi,4),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1b97 <slmlec_elim+0xa27>
cmp    %r8,%rcx
jne    1a32 <slmlec_elim+0x8c2>
mov    0xc(%rsp),%eax
mov    0x10(%rsp),%ecx
mov    %ecx,%edx
imul   %eax,%edx
mov    %eax,%esi
imul   %eax,%esi
cmp    %esi,%edx
jge    1bf1 <slmlec_elim+0xa81>
movslq %edx,%rdx
lea    (%r14,%rdx,4),%rdi
mov    %eax,%edx
sub    %ecx,%edx
imul   %eax,%edx
add    $0xffffffff,%edx
lea    0x4(,%rdx,4),%rdx
xor    %esi,%esi
call   1060 <memset@plt>
sub    $0x8,%rsp
lea    0x44(%rsp),%rdx
lea    0x14(%rsp),%rdi
mov    %rdi,%rsi
mov    %r14,%rcx
mov    %rdi,%r8
mov    0x58(%rsp),%r9
lea    0x28(%rsp),%rax
push   %rax
lea    0x34(%rsp),%rax
push   %rax
push   0x58(%rsp)
call   1040 <sorgqr_@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%edx
test   %edx,%edx
je     1c49 <slmlec_elim+0xad9>
mov    0x23ab(%rip),%rax
mov    (%rax),%edi
js     1d73 <slmlec_elim+0xc03>
lea    0x653(%rip),%rsi
jmp    16b1 <slmlec_elim+0x541>
movslq 0xc(%rsp),%r13
mov    %r13d,%ecx
test   %r13,%r13
jle    1e9c <slmlec_elim+0xd2c>
mov    %r13,0x48(%rsp)
mov    0x14(%rsp),%edx
movslq %edx,%rax
mov    %eax,%edi
and    $0xfffffffe,%edi
lea    0x0(,%rcx,8),%rbp
add    0x30(%rsp),%r15
lea    (%r14,%r15,4),%rsi
add    $0x4,%rsi
mov    %rsi,0x50(%rsp)
mov    %rax,0x40(%rsp)
lea    0x0(,%rax,4),%r15
xor    %r12d,%r12d
mov    %r14,%r11
mov    0x18(%rsp),%r10
jmp    1cb0 <slmlec_elim+0xb40>
add    $0x1,%r12
add    $0x4,%r11
cmp    %rcx,%r12
je     1d81 <slmlec_elim+0xc11>
test   %edx,%edx
jle    1c9f <slmlec_elim+0xb2f>
mov    %r12,%r13
imul   0x40(%rsp),%r13
mov    0x50(%rsp),%rbx
xor    %r9d,%r9d
jmp    1ce6 <slmlec_elim+0xb76>
nopw   0x0(%rax,%rax,1)
lea    (%r9,%r13,1),%rax
movss  %xmm0,(%r10,%rax,4)
add    $0x1,%r9
add    %r15,%rbx
cmp    %rdx,%r9
je     1c9f <slmlec_elim+0xb2f>
xorps  %xmm0,%xmm0
cmp    $0x1,%edx
jne    1d00 <slmlec_elim+0xb90>
xor    %r8d,%r8d
jmp    1d3a <slmlec_elim+0xbca>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,%rax
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
movss  (%rax),%xmm1
mulss  -0x4(%rbx,%r8,4),%xmm1
addss  %xmm0,%xmm1
movss  (%rax,%rcx,4),%xmm0
mulss  (%rbx,%r8,4),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%r8
add    %rbp,%rax
cmp    %r8,%rdi
jne    1d10 <slmlec_elim+0xba0>
test   $0x1,%dl
je     1cd0 <slmlec_elim+0xb60>
mov    %r9,%rax
imul   0x40(%rsp),%rax
mov    %r8,%rsi
imul   %rcx,%rsi
add    %r12,%rsi
movss  (%r14,%rsi,4),%xmm1
mov    0x18(%rsp),%r10
add    %r8,%rax
mov    0x28(%rsp),%rsi
mulss  (%rsi,%rax,4),%xmm1
addss  %xmm1,%xmm0
jmp    1cd0 <slmlec_elim+0xb60>
neg    %edx
lea    0x4d2(%rip),%rsi
jmp    16b1 <slmlec_elim+0x541>
mov    0xb8(%rsp),%rbp
test   %rbp,%rbp
mov    0x68(%rsp),%r12
mov    0xc0(%rsp),%r15
mov    0x48(%rsp),%r13
je     1e9c <slmlec_elim+0xd2c>
test   %r15,%r15
je     1e9c <slmlec_elim+0xd2c>
test   %ecx,%ecx
jle    1e9c <slmlec_elim+0xd2c>
mov    0x14(%rsp),%r10d
movslq %r10d,%r9
mov    %r10,%r8
add    $0xffffffffffffffff,%r8
mov    %r9d,%esi
and    $0x3,%esi
mov    %r9d,%r13d
and    $0xfffffffc,%r13d
mov    0x18(%rsp),%rax
add    $0xc,%rax
shl    $0x2,%r9
xor    %r11d,%r11d
jmp    1dfe <slmlec_elim+0xc8e>
movss  %xmm0,(%r15,%r11,4)
add    $0x1,%r11
add    %r9,%rax
add    %r9,0x18(%rsp)
cmp    %rcx,%r11
je     1ea3 <slmlec_elim+0xd33>
xorps  %xmm0,%xmm0
test   %r10d,%r10d
jle    1de3 <slmlec_elim+0xc73>
xor    %edx,%edx
cmp    $0x3,%r8
jb     1e58 <slmlec_elim+0xce8>
xchg   %ax,%ax
movss  -0xc(%rax,%rdx,4),%xmm1
movss  -0x8(%rax,%rdx,4),%xmm2
mulss  0x0(%rbp,%rdx,4),%xmm1
mulss  0x4(%rbp,%rdx,4),%xmm2
addss  %xmm0,%xmm1
movss  -0x4(%rax,%rdx,4),%xmm3
mulss  0x8(%rbp,%rdx,4),%xmm3
addss  %xmm1,%xmm2
movss  (%rax,%rdx,4),%xmm0
mulss  0xc(%rbp,%rdx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1e10 <slmlec_elim+0xca0>
test   %rsi,%rsi
je     1de3 <slmlec_elim+0xc73>
lea    0x0(,%rdx,4),%rdi
add    %rbp,%rdi
mov    0x18(%rsp),%rbx
lea    (%rbx,%rdx,4),%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rbx,4),%xmm1
mulss  (%rdi,%rbx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1e80 <slmlec_elim+0xd10>
jmp    1de3 <slmlec_elim+0xc73>
mov    0x14(%rsp),%r10d
jmp    1ea8 <slmlec_elim+0xd38>
mov    0x48(%rsp),%r13
mov    %ecx,%r11d
sub    %r10d,%r11d
test   %r11d,%r11d
jle    1f6e <slmlec_elim+0xdfe>
movslq %r10d,%r8
mov    %r11d,%r9d
mov    %ecx,%r15d
and    $0xfffffffe,%r15d
lea    (%rcx,%rcx,1),%ebx
add    %r10d,%r10d
sub    %r10d,%ebx
mov    %r8,%rax
imul   %r13,%rax
lea    (%r14,%rax,4),%rdx
add    $0x4,%rdx
lea    0x0(,%r13,4),%r10
xor    %edi,%edi
jmp    1ef4 <slmlec_elim+0xd84>
add    $0x1,%rdi
add    %r10,%rdx
cmp    %r9,%rdi
je     1f6e <slmlec_elim+0xdfe>
test   %ecx,%ecx
jle    1ee8 <slmlec_elim+0xd78>
cmp    $0x1,%r13d
jne    1f02 <slmlec_elim+0xd92>
xor    %esi,%esi
jmp    1f42 <slmlec_elim+0xdd2>
xor    %eax,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rdx,%rsi,4),%xmm0
cltq
lea    (%rdi,%rax,1),%rbp
movss  %xmm0,(%r12,%rbp,4)
movss  (%rdx,%rsi,4),%xmm0
lea    (%r11,%rax,1),%ebp
movslq %ebp,%rbp
add    %rdi,%rbp
movss  %xmm0,(%r12,%rbp,4)
add    $0x2,%rsi
add    %ebx,%eax
cmp    %rsi,%r15
jne    1f10 <slmlec_elim+0xda0>
test   $0x1,%cl
je     1ee8 <slmlec_elim+0xd78>
lea    (%rdi,%r8,1),%rax
imul   %r13,%rax
add    %rsi,%rax
movss  (%r14,%rax,4),%xmm0
mov    %r11d,%eax
imul   %esi,%eax
cltq
add    %rdi,%rax
movss  %xmm0,(%r12,%rax,4)
jmp    1ee8 <slmlec_elim+0xd78>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x14(%rsp),%eax
jmp    1733 <slmlec_elim+0x5c3>

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

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