#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*/ free_ivector(int *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ nrerror(char *);
void simplx(float **a, int m, int n, int m1, int m2, int m3, int *icase,
            int izrov[], int iposv[]) {
  void simp1(float **a, int mm, int ll[], int nll, int iabf, int *kp,
             float *bmax);
  void simp2(float **a, int n, int l2[], int nl2, int *ip, int kp, float *q1);
  void simp3(float **a, int i1, int k1, int ip, int kp);
  int i, ip, ir, is, k, kh, kp, m12, nl1, nl2;
  int *l1, *l2, *l3;
  float q1, bmax;
  if (m != (m1 + m2 + m3))
    nrerror("Bad input constraint counts in simplx");
  l1 = ivector(1, n + 1);
  l2 = ivector(1, m);
  l3 = ivector(1, m);
  nl1 = n;
  for (k = 1; k <= n; k++)
    l1[k] = izrov[k] = k;
  nl2 = m;
  for (i = 1; i <= m; i++) {
    if (a[i + 1][1] < 0.0)
      nrerror("Bad input tableau in simplx");
    l2[i] = i;
    iposv[i] = n + i;
  }
  for (i = 1; i <= m2; i++)
    l3[i] = 1;
  ir = 0;
  if (m2 + m3) {
    ir = 1;
    for (k = 1; k <= (n + 1); k++) {
      q1 = 0.0;
      for (i = m1 + 1; i <= m; i++)
        q1 += a[i + 1][k];
      a[m + 2][k] = -q1;
    }
    do {
      simp1(a, m + 1, l1, nl1, 0, &kp, &bmax);
      if (bmax <= 1.0e-6 && a[m + 2][1] < -1.0e-6) {
        *icase = -1;
        free_ivector(l3, 1, m);
        free_ivector(l2, 1, m);
        free_ivector(l1, 1, n + 1);
        return;
      } else if (bmax <= 1.0e-6 && a[m + 2][1] <= 1.0e-6) {
        m12 = m1 + m2 + 1;
        if (m12 <= m) {
          for (ip = m12; ip <= m; ip++) {
            if (iposv[ip] == (ip + n)) {
              simp1(a, ip, l1, nl1, 1, &kp, &bmax);
              if (bmax > 0.0)
                goto one;
            }
          }
        }
        ir = 0;
        --m12;
        if (m1 + 1 <= m12)
          for (i = m1 + 1; i <= m12; i++)
            if (l3[i - m1] == 1)
              for (k = 1; k <= n + 1; k++)
                a[i + 1][k] = -a[i + 1][k];
        break;
      }
      simp2(a, n, l2, nl2, &ip, kp, &q1);
      if (ip == 0) {
        *icase = -1;
        free_ivector(l3, 1, m);
        free_ivector(l2, 1, m);
        free_ivector(l1, 1, n + 1);
        return;
      }
    one:
      simp3(a, m + 1, n, ip, kp);
      if (iposv[ip] >= (n + m1 + m2 + 1)) {
        for (k = 1; k <= nl1; k++)
          if (l1[k] == kp)
            break;
        --nl1;
        for (is = k; is <= nl1; is++)
          l1[is] = l1[is + 1];
        ++a[m + 2][kp + 1];
        for (i = 1; i <= m + 2; i++)
          a[i][kp + 1] = -a[i][kp + 1];
      } else {
        if (iposv[ip] >= (n + m1 + 1)) {
          kh = iposv[ip] - m1 - n;
          if (l3[kh]) {
            l3[kh] = 0;
            ++a[m + 2][kp + 1];
            for (i = 1; i <= m + 2; i++)
              a[i][kp + 1] = -a[i][kp + 1];
          }
        }
      }
      is = izrov[kp];
      izrov[kp] = iposv[ip];
      iposv[ip] = is;
    } while (ir);
  }
  for (;;) {
    simp1(a, 0, l1, nl1, 0, &kp, &bmax);
    if (bmax <= 0.0) {
      *icase = 0;
      free_ivector(l3, 1, m);
      free_ivector(l2, 1, m);
      free_ivector(l1, 1, n + 1);
      return;
    }
    simp2(a, n, l2, nl2, &ip, kp, &q1);
    if (ip == 0) {
      *icase = 1;
      free_ivector(l3, 1, m);
      free_ivector(l2, 1, m);
      free_ivector(l1, 1, n + 1);
      return;
    }
    simp3(a, m, n, ip, kp);
    is = izrov[kp];
    izrov[kp] = iposv[ip];
    iposv[ip] = is;
  }
}


x86 assembly (clang, -O0):
<simplx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
je     11a9 <simplx+0x49>
lea    0xe70(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1070 <ivector@plt>
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1070 <ivector@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1070 <ivector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     121f <simplx+0xbf>
mov    -0x30(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ec <simplx+0x8c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1298 <simplx+0x138>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    126b <simplx+0x10b>
lea    0xdd4(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x20(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%edx
add    -0x20(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122c <simplx+0xcc>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12c8 <simplx+0x168>
mov    -0x60(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129f <simplx+0x13f>
movl   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
cmp    $0x0,%eax
je     18fa <simplx+0x79a>
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1386 <simplx+0x226>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     134c <simplx+0x1ec>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    130e <simplx+0x1ae>
movss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ec <simplx+0x18c>
jmp    138b <simplx+0x22b>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0x50(%rbp),%rdx
mov    -0x40(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x38(%rbp),%r9
lea    -0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <simp1@plt>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc3f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     143c <simplx+0x2dc>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc1b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    143c <simplx+0x2dc>
mov    0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
jmp    1a3b <simplx+0x8db>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbb3(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     15f7 <simplx+0x497>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb87(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     15f7 <simplx+0x497>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1523 <simplx+0x3c3>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     151e <simplx+0x3be>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x24(%rbp),%ecx
add    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jne    150b <simplx+0x3ab>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x40(%rbp),%ecx
mov    $0x1,%r8d
lea    -0x38(%rbp),%r9
lea    -0x68(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <simp1@plt>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1506 <simplx+0x3a6>
jmp    1673 <simplx+0x513>
jmp    150b <simplx+0x3ab>
jmp    1510 <simplx+0x3b0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14a1 <simplx+0x341>
jmp    1523 <simplx+0x3c3>
movl   $0x0,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0x3c(%rbp),%eax
jg     15f2 <simplx+0x492>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     15ed <simplx+0x48d>
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    15da <simplx+0x47a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     15d5 <simplx+0x475>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1575 <simplx+0x415>
jmp    15da <simplx+0x47a>
jmp    15df <simplx+0x47f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    154b <simplx+0x3eb>
jmp    15f2 <simplx+0x492>
jmp    18f5 <simplx+0x795>
jmp    15fc <simplx+0x49c>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    -0x44(%rbp),%ecx
mov    -0x38(%rbp),%r9d
lea    -0x24(%rbp),%r8
lea    -0x64(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <simp2@plt>
cmpl   $0x0,-0x24(%rbp)
jne    166e <simplx+0x50e>
mov    0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
jmp    1a3b <simplx+0x8db>
jmp    1673 <simplx+0x513>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0x10(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x38(%rbp),%r8d
call   1040 <simp3@plt>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     17c6 <simplx+0x666>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     16ea <simplx+0x58a>
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    16d7 <simplx+0x577>
jmp    16ea <simplx+0x58a>
jmp    16dc <simplx+0x57c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16b2 <simplx+0x552>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     172e <simplx+0x5ce>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16f9 <simplx+0x599>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  0x8c0(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jg     17c1 <simplx+0x661>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1761 <simplx+0x601>
jmp    18b9 <simplx+0x759>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     18b4 <simplx+0x754>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     18af <simplx+0x74f>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  0x7d7(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jg     18aa <simplx+0x74a>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    184a <simplx+0x6ea>
jmp    18af <simplx+0x74f>
jmp    18b4 <simplx+0x754>
jmp    18b9 <simplx+0x759>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x28(%rbp)
jne    138b <simplx+0x22b>
jmp    18fa <simplx+0x79a>
jmp    18ff <simplx+0x79f>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rdx
mov    -0x40(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x38(%rbp),%r9
lea    -0x68(%rbp),%rax
mov    %r8d,%esi
mov    %rax,(%rsp)
call   1050 <simp1@plt>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     197c <simplx+0x81c>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
jmp    1a3b <simplx+0x8db>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    -0x44(%rbp),%ecx
mov    -0x38(%rbp),%r9d
lea    -0x24(%rbp),%r8
lea    -0x64(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <simp2@plt>
cmpl   $0x0,-0x24(%rbp)
jne    19ee <simplx+0x88e>
mov    0x10(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
jmp    1a3b <simplx+0x8db>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x38(%rbp),%r8d
call   1040 <simp3@plt>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    18ff <simplx+0x79f>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r8d,%ebp
mov    %edx,%r15d
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %rcx,0x70(%rsp)
lea    0x0(%rbp,%rcx,1),%eax
mov    %rax,0x58(%rsp)
mov    %r9,0x40(%rsp)
add    %r9d,%eax
cmp    %esi,%eax
je     11a3 <simplx+0x43>
lea    0xeea(%rip),%rdi
call   1030 <nrerror@plt>
mov    %rbp,0x68(%rsp)
mov    0xe8(%rsp),%rbp
lea    0x1(%r15),%r12d
mov    $0x1,%edi
mov    %r12d,%esi
call   1070 <ivector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1070 <ivector@plt>
mov    %rax,0x50(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1070 <ivector@plt>
mov    %rax,0x48(%rsp)
mov    %r12d,0x34(%rsp)
mov    %r12d,%r12d
mov    %r15,%rax
mov    %r15,0x20(%rsp)
test   %r15d,%r15d
jle    13b1 <simplx+0x251>
lea    -0x1(%r12),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     1339 <simplx+0x1d9>
lea    0x4(%rbp),%rdx
mov    0x28(%rsp),%rsi
lea    (%rsi,%r12,4),%rsi
cmp    %rsi,%rdx
jae    1246 <simplx+0xe6>
lea    0x0(,%r12,4),%rdx
add    %rbp,%rdx
mov    0x28(%rsp),%rsi
add    $0x4,%rsi
cmp    %rdx,%rsi
jb     1339 <simplx+0x1d9>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1e5d <simplx+0xcfd>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xd8c(%rip),%xmm0
xor    %edx,%edx
movdqa 0xd92(%rip),%xmm1
movdqa 0xd9a(%rip),%xmm2
movdqa 0xda2(%rip),%xmm3
movdqa 0xdaa(%rip),%xmm4
mov    0x28(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
movdqu %xmm0,0x4(%rbp,%rdx,4)
movdqu %xmm5,0x14(%rbp,%rdx,4)
movdqu %xmm0,0x4(%rsi,%rdx,4)
movdqu %xmm5,0x14(%rsi,%rdx,4)
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqu %xmm5,0x24(%rbp,%rdx,4)
movdqu %xmm6,0x34(%rbp,%rdx,4)
movdqu %xmm5,0x24(%rsi,%rdx,4)
movdqu %xmm6,0x34(%rsi,%rdx,4)
add    $0x10,%rdx
paddd  %xmm4,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    12a0 <simplx+0x140>
test   $0x1,%r8b
je     132c <simplx+0x1cc>
shl    $0x2,%rdx
movdqa 0xd08(%rip),%xmm1
paddd  %xmm0,%xmm1
or     $0x4,%rdx
movdqu %xmm0,0x0(%rbp,%rdx,1)
movdqu %xmm1,0x10(%rbp,%rdx,1)
mov    0x28(%rsp),%rsi
movdqu %xmm0,(%rsi,%rdx,1)
movdqu %xmm1,0x10(%rsi,%rdx,1)
cmp    %rax,%rcx
je     13b1 <simplx+0x251>
or     $0x1,%rax
mov    %r12d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
and    $0x3,%rdx
je     1466 <simplx+0x306>
mov    0x28(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %eax,0x0(%rbp,%rax,4)
mov    %eax,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1360 <simplx+0x200>
cmp    $0x3,%rcx
jb     13b1 <simplx+0x251>
nopw   0x0(%rax,%rax,1)
mov    %eax,0x0(%rbp,%rax,4)
mov    %eax,(%rsi,%rax,4)
lea    0x1(%rax),%ecx
mov    %ecx,0x4(%rbp,%rax,4)
mov    %ecx,0x4(%rsi,%rax,4)
lea    0x2(%rax),%ecx
mov    %ecx,0x8(%rbp,%rax,4)
mov    %ecx,0x8(%rsi,%rax,4)
lea    0x3(%rax),%ecx
mov    %ecx,0xc(%rbp,%rax,4)
mov    %ecx,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %r12,%rax
jne    1380 <simplx+0x220>
mov    %r14,0x60(%rsp)
test   %r14d,%r14d
jle    140f <simplx+0x2af>
mov    0x60(%rsp),%r13d
xor    %r14d,%r14d
pxor   %xmm0,%xmm0
lea    0xce0(%rip),%r15
jmp    13f7 <simplx+0x297>
lea    0x1(%r14),%rax
mov    0x50(%rsp),%rcx
mov    %eax,0x4(%rcx,%r14,4)
lea    (%r12,%r14,1),%ecx
mov    0xf0(%rsp),%rdx
mov    %ecx,0x4(%rdx,%r14,4)
mov    %rax,%r14
cmp    %rax,%r13
je     140f <simplx+0x2af>
mov    0x10(%rbx,%r14,8),%rax
ucomiss 0x4(%rax),%xmm0
jbe    13d0 <simplx+0x270>
mov    %r15,%rdi
call   1030 <nrerror@plt>
xorps  %xmm0,%xmm0
jmp    13d0 <simplx+0x270>
mov    0x68(%rsp),%r9
test   %r9d,%r9d
mov    0x60(%rsp),%r14
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%r12
mov    0x48(%rsp),%rbp
jle    1531 <simplx+0x3d1>
mov    %r9d,%eax
mov    $0x1,%ecx
cmp    $0x8,%r9d
jb     151b <simplx+0x3bb>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    147a <simplx+0x31a>
xor    %esi,%esi
jmp    14da <simplx+0x37a>
mov    0x28(%rsp),%rsi
cmp    $0x3,%rcx
jae    1380 <simplx+0x220>
jmp    13b1 <simplx+0x251>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdi
xor    %esi,%esi
movdqa 0xbbb(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,0x4(%rbp,%rsi,4)
movdqu %xmm0,0x14(%rbp,%rsi,4)
movdqu %xmm0,0x24(%rbp,%rsi,4)
movdqu %xmm0,0x34(%rbp,%rsi,4)
movdqu %xmm0,0x44(%rbp,%rsi,4)
movdqu %xmm0,0x54(%rbp,%rsi,4)
movdqu %xmm0,0x64(%rbp,%rsi,4)
movdqu %xmm0,0x74(%rbp,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    14a0 <simplx+0x340>
test   %rdx,%rdx
je     1512 <simplx+0x3b2>
movdqa 0xb69(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movdqu %xmm0,0x0(%rbp,%rdi,1)
movdqu %xmm0,0x10(%rbp,%rdi,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
jne    14f0 <simplx+0x390>
cmp    %rcx,%rax
je     1531 <simplx+0x3d1>
or     $0x1,%rcx
add    $0x1,%rax
nop
movl   $0x1,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1520 <simplx+0x3c0>
mov    %r8d,%r15d
mov    0x40(%rsp),%rax
add    %r9d,%eax
je     1d37 <simplx+0xbd7>
mov    0x70(%rsp),%rdi
movslq %edi,%rcx
test   %r8d,%r8d
mov    %rcx,0x40(%rsp)
js     1675 <simplx+0x515>
lea    0x2(%r14),%r15d
movslq %r15d,%rax
mov    %rax,0x38(%rsp)
mov    (%rbx,%rax,8),%r10
lea    0x1(%rcx),%r8
mov    0x34(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
lea    0x1(%r14),%r13d
add    $0x1,%edx
mov    %r14d,%r11d
sub    %ecx,%r11d
mov    %ecx,%r9d
not    %r9d
add    %r14d,%r9d
and    $0x3,%r11d
mov    $0x1,%ebp
movdqa 0xabe(%rip),%xmm0
jmp    15c7 <simplx+0x467>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
pxor   %xmm0,%xmm1
movd   %xmm1,(%r10,%rbp,4)
add    $0x1,%rbp
cmp    %rdx,%rbp
je     166e <simplx+0x50e>
movl   $0x0,0x1c(%rsp)
pxor   %xmm1,%xmm1
cmp    %edi,%r14d
jle    15b0 <simplx+0x450>
pxor   %xmm1,%xmm1
test   %r11d,%r11d
je     1611 <simplx+0x4b1>
mov    %r11d,%esi
mov    %r8,%rcx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rax
add    $0x1,%rcx
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0x1c(%rsp)
add    $0xffffffff,%esi
jne    15f0 <simplx+0x490>
cmp    $0x3,%r9d
jae    1620 <simplx+0x4c0>
jmp    15b0 <simplx+0x450>
mov    %r8,%rcx
cmp    $0x3,%r9d
jb     15b0 <simplx+0x450>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rax
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0x1c(%rsp)
mov    0x10(%rbx,%rcx,8),%rax
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0x1c(%rsp)
mov    0x18(%rbx,%rcx,8),%rax
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0x1c(%rsp)
mov    0x20(%rbx,%rcx,8),%rax
add    $0x4,%rcx
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0x1c(%rsp)
cmp    %ecx,%r13d
jne    1620 <simplx+0x4c0>
jmp    15b0 <simplx+0x450>
mov    0x20(%rsp),%r8
jmp    1685 <simplx+0x525>
lea    0x1(%r14),%r13d
lea    0x2(%r14),%r15d
movslq %r15d,%rax
mov    %rax,0x38(%rsp)
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x78(%rsp)
add    %r8d,%edi
mov    0x68(%rsp),%rax
mov    %rdi,0x70(%rsp)
add    %edi,%eax
mov    %eax,0x7c(%rsp)
cmp    $0x2,%r15d
mov    $0x1,%eax
cmovl  %eax,%r15d
lea    -0x1(%r15),%rax
mov    %rax,0x90(%rsp)
mov    %r15,%rcx
mov    %r8,%r15
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x88(%rsp)
mov    %rcx,%rax
mov    %rcx,0xa0(%rsp)
and    $0x7ffffffc,%ecx
mov    %rcx,0x80(%rsp)
mov    %r12,%rax
add    $0x34,%rax
mov    %rax,0x98(%rsp)
lea    0x18(%rsp),%rbp
jmp    172d <simplx+0x5cd>
nop
movslq 0x10(%rsp),%rax
mov    0xe8(%rsp),%rdi
mov    (%rdi,%rax,4),%ecx
movslq 0x14(%rsp),%rdx
mov    0xf0(%rsp),%rbp
mov    0x0(%rbp,%rdx,4),%esi
mov    %esi,(%rdi,%rax,4)
mov    %ecx,0x0(%rbp,%rdx,4)
lea    0x18(%rsp),%rbp
mov    %rbp,(%rsp)
mov    %rbx,%rdi
mov    %r13d,%esi
mov    %r12,%rdx
mov    %r15d,%ecx
xor    %r8d,%r8d
lea    0x10(%rsp),%r9
call   1050 <simp1@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x914(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     1798 <simplx+0x638>
mov    0x38(%rsp),%rax
mov    (%rbx,%rax,8),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8fc(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1e07 <simplx+0xca7>
movsd  0x8e2(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    1960 <simplx+0x800>
mov    0x10(%rsp),%r9d
lea    0x1c(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    0x20(%rsp),%rsi
mov    0x50(%rsp),%rdx
mov    %r14d,%ecx
lea    0x14(%rsp),%r8
call   1080 <simp2@plt>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
je     1e07 <simplx+0xca7>
mov    0x10(%rsp),%r8d
mov    %rbx,%rdi
mov    %r13d,%esi
mov    0x20(%rsp),%rdx
call   1040 <simp3@plt>
movslq 0x14(%rsp),%rax
mov    0xf0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
cmp    0x7c(%rsp),%eax
jle    1840 <simplx+0x6e0>
test   %r15d,%r15d
movaps 0x85f(%rip),%xmm4
jle    19e7 <simplx+0x887>
mov    0x10(%rsp),%ecx
lea    0x1(%r15),%eax
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ecx,(%r12,%rdx,4)
je     19f6 <simplx+0x896>
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1820 <simplx+0x6c0>
jmp    19ec <simplx+0x88c>
nopl   0x0(%rax,%rax,1)
sub    0x70(%rsp),%eax
movaps 0x815(%rip),%xmm1
jle    1700 <simplx+0x5a0>
cltq
mov    0x48(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     1700 <simplx+0x5a0>
movl   $0x0,(%rcx,%rax,4)
mov    0x38(%rsp),%rax
mov    (%rbx,%rax,8),%rcx
movslq 0x10(%rsp),%rax
movss  0x4(%rcx,%rax,4),%xmm0
addss  0x7fb(%rip),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
cmp    $0xffffffff,%r14d
jl     1700 <simplx+0x5a0>
mov    $0x1,%ecx
cmpq   $0x3,0x90(%rsp)
mov    0x88(%rsp),%rdi
mov    0x80(%rsp),%rsi
jb     191d <simplx+0x7bd>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x10(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x18(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x20(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    18c0 <simplx+0x760>
add    $0x1,%rcx
test   %rdi,%rdi
je     1700 <simplx+0x5a0>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rcx,%rdx,8),%rsi
movss  0x4(%rsi,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1930 <simplx+0x7d0>
jmp    1700 <simplx+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r14d,0x58(%rsp)
movaps 0x6f4(%rip),%xmm4
jge    1be2 <simplx+0xa82>
mov    0x78(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    %eax,%ecx
jmp    1992 <simplx+0x832>
xchg   %ax,%ax
lea    0x1(%rcx),%eax
mov    %eax,0x14(%rsp)
cmp    %r14d,%ecx
mov    %eax,%ecx
jge    1be2 <simplx+0xa82>
movslq %ecx,%rax
mov    0x20(%rsp),%rdx
add    %ecx,%edx
mov    0xf0(%rsp),%rsi
cmp    %edx,(%rsi,%rax,4)
jne    1980 <simplx+0x820>
mov    %rbp,(%rsp)
mov    %rbx,%rdi
mov    %ecx,%esi
mov    %r12,%rdx
mov    %r15d,%ecx
mov    $0x1,%r8d
lea    0x10(%rsp),%r9
call   1050 <simp1@plt>
movaps 0x691(%rip),%xmm4
movss  0x18(%rsp),%xmm0
ucomiss 0x6a8(%rip),%xmm0
mov    0x14(%rsp),%ecx
jbe    1980 <simplx+0x820>
jmp    17cc <simplx+0x66c>
mov    $0x1,%eax
cmp    %r15d,%eax
jl     1a01 <simplx+0x8a1>
jmp    1ad5 <simplx+0x975>
mov    %edx,%eax
cmp    %r15d,%eax
jge    1ad5 <simplx+0x975>
mov    %eax,%ecx
not    %eax
add    %r15d,%eax
cmp    $0x7,%eax
jb     1ac0 <simplx+0x960>
add    $0x1,%rax
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1bd1 <simplx+0xa71>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x98(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x30(%rdx,%rdi,4),%xmm0
movupd -0x20(%rdx,%rdi,4),%xmm1
movdqu -0x10(%rdx,%rdi,4),%xmm2
movdqu (%rdx,%rdi,4),%xmm3
movups %xmm0,-0x34(%rdx,%rdi,4)
movupd %xmm1,-0x24(%rdx,%rdi,4)
movdqu %xmm2,-0x14(%rdx,%rdi,4)
movdqu %xmm3,-0x4(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1a50 <simplx+0x8f0>
test   $0x1,%r9b
je     1aa9 <simplx+0x949>
add    %rcx,%rdi
movups 0x4(%r12,%rdi,4),%xmm0
movupd 0x14(%r12,%rdi,4),%xmm1
movups %xmm0,(%r12,%rdi,4)
movupd %xmm1,0x10(%r12,%rdi,4)
cmp    %r8,%rax
je     1ad5 <simplx+0x975>
add    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x4(%r12,%rcx,4),%eax
mov    %eax,(%r12,%rcx,4)
lea    0x1(%rcx),%rax
mov    %rax,%rcx
cmp    %eax,%r15d
jg     1ac0 <simplx+0x960>
add    $0xffffffff,%r15d
mov    0x38(%rsp),%rax
mov    (%rbx,%rax,8),%rcx
movslq 0x10(%rsp),%rax
movss  0x4(%rcx,%rax,4),%xmm0
addss  0x58b(%rip),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
cmp    $0xffffffff,%r14d
jl     1700 <simplx+0x5a0>
mov    $0x1,%ecx
cmpq   $0x3,0x90(%rsp)
mov    0x88(%rsp),%rdi
mov    0x80(%rsp),%rsi
jb     1b8d <simplx+0xa2d>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x10(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x18(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
mov    0x20(%rbx,%rcx,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1b30 <simplx+0x9d0>
add    $0x1,%rcx
testb  $0x3,0xa0(%rsp)
03
je     1700 <simplx+0x5a0>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
movss  0x4(%rsi,%rax,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1bb0 <simplx+0xa50>
jmp    1700 <simplx+0x5a0>
xor    %edi,%edi
test   $0x1,%r9b
jne    1a8d <simplx+0x92d>
jmp    1aa9 <simplx+0x949>
cmpl   $0x0,0x68(%rsp)
jle    1d32 <simplx+0xbd2>
mov    0x34(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r14d
cmovge %eax,%r14d
lea    0x1(%r14),%rcx
movslq 0x58(%rsp),%rdx
lea    -0x8(%r14),%r10
mov    %r10,%r13
shr    $0x3,%r13
add    $0x1,%r13
mov    %r14d,%r11d
and    $0x7ffffff8,%r11d
lea    0x1(%r11),%r8
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x38(%rsp)
mov    0x40(%rsp),%rax
jmp    1c49 <simplx+0xae9>
nopw   0x0(%rax,%rax,1)
cmp    %rdx,%rax
jge    1d2d <simplx+0xbcd>
mov    %rax,%rdi
add    $0x1,%rax
mov    %rax,%rsi
sub    0x40(%rsp),%rsi
mov    0x48(%rsp),%rbp
cmpl   $0x1,0x0(%rbp,%rsi,4)
jne    1c40 <simplx+0xae0>
cmpl   $0x0,0x20(%rsp)
js     1c40 <simplx+0xae0>
mov    0x10(%rbx,%rdi,8),%rbp
mov    $0x1,%edi
cmp    $0x8,%r14d
jb     1d10 <simplx+0xbb0>
cmp    $0x8,%r10
jae    1c89 <simplx+0xb29>
xor    %edi,%edi
jmp    1cce <simplx+0xb6e>
mov    0x38(%rsp),%r9
xor    %edi,%edi
movups 0x4(%rbp,%rdi,4),%xmm0
movups 0x14(%rbp,%rdi,4),%xmm1
movups 0x24(%rbp,%rdi,4),%xmm2
movups 0x34(%rbp,%rdi,4),%xmm3
xorps  %xmm4,%xmm0
xorps  %xmm4,%xmm1
movups %xmm0,0x4(%rbp,%rdi,4)
movups %xmm1,0x14(%rbp,%rdi,4)
xorps  %xmm4,%xmm2
xorps  %xmm4,%xmm3
movups %xmm2,0x24(%rbp,%rdi,4)
movups %xmm3,0x34(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%r9
jne    1c90 <simplx+0xb30>
test   $0x1,%r13b
je     1cf6 <simplx+0xb96>
shl    $0x2,%rdi
or     $0x4,%rdi
movups 0x0(%rbp,%rdi,1),%xmm0
movups 0x10(%rbp,%rdi,1),%xmm1
xorps  %xmm4,%xmm0
xorps  %xmm4,%xmm1
movups %xmm0,0x0(%rbp,%rdi,1)
movups %xmm1,0x10(%rbp,%rdi,1)
mov    %r8,%rdi
cmp    %r11,%r14
je     1c40 <simplx+0xae0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%rdi,4),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1d10 <simplx+0xbb0>
jmp    1c40 <simplx+0xae0>
mov    0x60(%rsp),%r14
mov    0x20(%rsp),%r8
lea    0x18(%rsp),%rax
mov    %rax,(%rsp)
mov    %r8,%r13
xor    %ebp,%ebp
lea    0x10(%rsp),%r9
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
mov    %r15d,%ecx
xor    %r8d,%r8d
nopl   0x0(%rax,%rax,1)
call   1050 <simp1@plt>
pxor   %xmm0,%xmm0
ucomiss 0x18(%rsp),%xmm0
jae    1e0c <simplx+0xcac>
mov    0x10(%rsp),%r9d
lea    0x1c(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    %r13d,%esi
mov    0x50(%rsp),%rdx
mov    %r14d,%ecx
lea    0x14(%rsp),%r8
call   1080 <simp2@plt>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
je     1e00 <simplx+0xca0>
mov    0x10(%rsp),%r8d
mov    %rbx,%rdi
mov    %r14d,%esi
mov    %r13d,%edx
call   1040 <simp3@plt>
movslq 0x10(%rsp),%rax
mov    0xe8(%rsp),%rdi
mov    (%rdi,%rax,4),%ecx
movslq 0x14(%rsp),%rdx
mov    0xf0(%rsp),%rbp
mov    0x0(%rbp,%rdx,4),%esi
mov    %esi,(%rdi,%rax,4)
mov    %ecx,0x0(%rbp,%rdx,4)
lea    0x18(%rsp),%rax
mov    %rax,(%rsp)
xor    %ebp,%ebp
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12,%rdx
mov    %r15d,%ecx
xor    %r8d,%r8d
lea    0x10(%rsp),%r9
jmp    1d60 <simplx+0xc00>
mov    $0x1,%ebp
jmp    1e0c <simplx+0xcac>
mov    $0xffffffff,%ebp
mov    0xe0(%rsp),%rax
mov    %ebp,(%rax)
mov    0x48(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1060 <free_ivector@plt>
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1060 <free_ivector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    0x34(%rsp),%edx
call   1060 <free_ivector@plt>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0x19b(%rip),%xmm0
xor    %edx,%edx
test   $0x1,%r8b
jne    12fc <simplx+0x19c>
jmp    132c <simplx+0x1cc>

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

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