#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
scalar_t__ calloc(int, int);
double fabs(float);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ nrerror(char *);
float solve_model(float *, char *, int /*<<< orphan*/ *);
void amoeba(float **p, float *y, int ndim, float ftol, int *iter, char *runstr,
            FILE *fopti) {
  int mpts, j, inhi, ilo, ihi, i;
  float yprr, ypr, rtol;
  float *pr, *prr, *pbar;
  int jk;
  pr = (float *)calloc(ndim, sizeof(float));
  prr = (float *)calloc(ndim, sizeof(float));
  pbar = (float *)calloc(ndim, sizeof(float));
  mpts = ndim + 1;
  *iter = 0;
  for (;;) {
    ilo = 0;
    ihi = y[0] > y[1] ? (inhi = 1, 0) : (inhi = 0, 1);
    for (i = 0; i < mpts; i++) {
      if (y[i] < y[ilo])
        ilo = i;
      if (y[i] > y[ihi]) {
        inhi = ihi;
        ihi = i;
      } else if (y[i] > y[inhi])
        if (i != ihi)
          inhi = i;
    }
    if (fabs(y[ihi]) + fabs(y[ilo]) > 0.)
      rtol = 2.0 * fabs(y[ihi] - y[ilo]) / (fabs(y[ihi]) + fabs(y[ilo]));
    else
      rtol = 0.;
    if (rtol < ftol)
      break;
    if ((*iter)++ == 1000)
      nrerror("Too many iterations in AMOEBA");
    for (j = 0; j < ndim; j++)
      pbar[j] = 0.0;
    for (i = 0; i < mpts; i++)
      if (i != ihi)
        for (j = 0; j < ndim; j++)
          pbar[j] += p[i][j];
    for (j = 0; j < ndim; j++) {
      pbar[j] /= ndim;
      pr[j] = (1.0 + 1.0) * pbar[j] - 1.0 * p[ihi][j];
    }
    ypr = solve_model(pr, runstr, fopti);
    if (ypr <= y[ilo]) {
      for (j = 0; j < ndim; j++)
        prr[j] = 2.0 * pr[j] + (1.0 - 2.0) * pbar[j];
      yprr = solve_model(prr, runstr, fopti);
      if (yprr < y[ilo]) {
        for (j = 0; j < ndim; j++)
          p[ihi][j] = prr[j];
        y[ihi] = yprr;
      } else {
        for (j = 0; j < ndim; j++)
          p[ihi][j] = pr[j];
        y[ihi] = ypr;
      }
    } else if (ypr >= y[inhi]) {
      if (ypr < y[ihi]) {
        for (j = 0; j < ndim; j++)
          p[ihi][j] = pr[j];
        y[ihi] = ypr;
      }
      for (j = 0; j < ndim; j++)
        prr[j] = 0.5 * p[ihi][j] + (1.0 - 0.5) * pbar[j];
      yprr = solve_model(prr, runstr, fopti);
      if (yprr < y[ihi]) {
        for (j = 0; j < ndim; j++)
          p[ihi][j] = prr[j];
        y[ihi] = yprr;
      } else {
        for (i = 0; i < mpts; i++) {
          if (i != ilo) {
            for (j = 0; j < ndim; j++) {
              pr[j] = 0.5 * (p[i][j] + p[ilo][j]);
              p[i][j] = pr[j];
            }
            y[i] = solve_model(pr, runstr, fopti);
          }
        }
      }
    } else {
      for (j = 0; j < ndim; j++)
        p[ihi][j] = pr[j];
      y[ihi] = ypr;
    }
  }
  free((char *)pbar);
  free((char *)prr);
  free((char *)pr);
}


x86 assembly (clang, -O0):
<amoeba>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
jbe    11eb <amoeba+0x9b>
movl   $0x1,-0x3c(%rbp)
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    11fa <amoeba+0xaa>
movl   $0x0,-0x3c(%rbp)
mov    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12ba <amoeba+0x16a>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    123c <amoeba+0xec>
mov    -0x48(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    126c <amoeba+0x11c>
mov    -0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12a7 <amoeba+0x157>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    12a2 <amoeba+0x152>
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     129d <amoeba+0x14d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    12a2 <amoeba+0x152>
jmp    12a7 <amoeba+0x157>
jmp    12ac <amoeba+0x15c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1207 <amoeba+0xb7>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1387 <amoeba+0x237>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xcda(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movsd  -0x90(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x88(%rbp),%xmm0
ff
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    138f <amoeba+0x23f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13a7 <amoeba+0x257>
jmp    196c <amoeba+0x81c>
mov    -0x20(%rbp),%rcx
mov    (%rcx),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,(%rcx)
cmp    $0x3e8,%eax
jne    13cb <amoeba+0x27b>
lea    0xc5a(%rip),%rdi
call   1040 <nrerror@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13fc <amoeba+0x2ac>
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13d2 <amoeba+0x282>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    147b <amoeba+0x32b>
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     1468 <amoeba+0x318>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1463 <amoeba+0x313>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1422 <amoeba+0x2d2>
jmp    1468 <amoeba+0x318>
jmp    146d <amoeba+0x31d>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1403 <amoeba+0x2b3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    151d <amoeba+0x3cd>
cvtsi2ssl -0x14(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xb3d(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1482 <amoeba+0x332>
mov    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1070 <solve_model@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     169b <amoeba+0x54b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15b6 <amoeba+0x466>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa85(%rip),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1555 <amoeba+0x405>
mov    -0x68(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1070 <solve_model@plt>
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1641 <amoeba+0x4f1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    162a <amoeba+0x4da>
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15ee <amoeba+0x49e>
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1696 <amoeba+0x546>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1684 <amoeba+0x534>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1648 <amoeba+0x4f8>
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1967 <amoeba+0x817>
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     190d <amoeba+0x7bd>
movss  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1722 <amoeba+0x5d2>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1710 <amoeba+0x5c0>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16d4 <amoeba+0x584>
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    179a <amoeba+0x64a>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x8a1(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x895(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1729 <amoeba+0x5d9>
mov    -0x68(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1070 <solve_model@plt>
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1825 <amoeba+0x6d5>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    180e <amoeba+0x6be>
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17d2 <amoeba+0x682>
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1908 <amoeba+0x7b8>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1903 <amoeba+0x7b3>
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     18f0 <amoeba+0x7a0>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18d2 <amoeba+0x782>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x77b(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    184b <amoeba+0x6fb>
mov    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1070 <solve_model@plt>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    18f5 <amoeba+0x7a5>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    182c <amoeba+0x6dc>
jmp    1908 <amoeba+0x7b8>
jmp    1962 <amoeba+0x812>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1950 <amoeba+0x800>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1914 <amoeba+0x7c4>
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1967 <amoeba+0x817>
jmp    11bd <amoeba+0x6d>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<amoeba>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x80(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,%r14
movss  %xmm0,0xbc(%rsp)
mov    %edx,%ebp
mov    %rsi,%r15
mov    %rdi,0x30(%rsp)
mov    %edx,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %r15,%rdi
mov    %rbp,%r8
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
movaps %xmm0,0x130(%rsp)
mov    %rax,%r12
mov    %r14,0x118(%rsp)
movl   $0x0,(%r14)
mov    %r8d,%r15d
lea    (%rbx,%r15,4),%rsi
lea    0x0(,%r15,4),%r9
add    %r13,%r9
lea    (%rax,%r15,4),%r11
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xa0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xd8(%rsp)
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
or     $0x2,%rcx
and    %rax,%rcx
mov    %rcx,0xe0(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x10(%rsp)
cmp    %rsi,%r12
setb   %r10b
cmp    %r11,%rbx
setb   %cl
and    %r10b,%cl
mov    %cl,0xf(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x120(%rsp)
mov    %rsi,0x70(%rsp)
cmp    %rsi,%r13
setb   %r10b
cmp    %r9,%rbx
setb   %cl
and    %r10b,%cl
mov    %r11,0xe8(%rsp)
cmp    %r11,%r13
setb   %sil
mov    %r9,0x98(%rsp)
cmp    %r9,%r12
setb   %dl
and    %sil,%dl
mov    %dl,0xd(%rsp)
or     %dl,%cl
mov    %cl,0xe(%rsp)
mov    %rbp,%rcx
mov    %rbp,0xd0(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xc8(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0xa8(%rsp)
mov    %eax,%edx
and    $0x3,%edx
mov    %rax,%rcx
mov    %rax,0x50(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
lea    0x0(,%r15,4),%rax
mov    %rax,0x100(%rsp)
and    $0xfffffffffffffff0,%rax
mov    %rax,0xf8(%rsp)
mov    %rdx,0xf0(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x20(%rsp)
lea    0x1(%r8),%eax
mov    %rax,0xb0(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0x108(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x90(%rsp)
mov    %r13,0x28(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0xc0(%rsp)
mov    %r8,0x18(%rsp)
mov    %rbx,0x88(%rsp)
mov    %rdi,0x58(%rsp)
jmp    1380 <amoeba+0x220>
mov    0x18(%rsp),%r8
mov    (%rsp),%r10
movss  %xmm2,(%rdi,%r10,4)
movss  (%rdi),%xmm1
xor    %eax,%eax
xor    %r14d,%r14d
ucomiss 0x4(%rdi),%xmm1
setbe  %al
seta   %r14b
test   %r8d,%r8d
js     1430 <amoeba+0x2d0>
xor    %ecx,%ecx
movaps %xmm1,%xmm0
xor    %edx,%edx
mov    0x108(%rsp),%rbx
jmp    13d4 <amoeba+0x274>
xchg   %ax,%ax
mov    %eax,%ebp
mov    %r14d,%eax
cmp    %rcx,%rbx
je     1420 <amoeba+0x2c0>
movss  0x4(%rdi,%rcx,4),%xmm0
movslq %r13d,%rdx
movss  (%rdi,%rdx,4),%xmm1
add    $0x1,%rcx
mov    %eax,%r14d
mov    %r13d,%edx
mov    %ebp,%eax
ucomiss %xmm0,%xmm1
mov    %ecx,%r13d
ja     13df <amoeba+0x27f>
mov    %edx,%r13d
movslq %eax,%rdx
ucomiss (%rdi,%rdx,4),%xmm0
jbe    1400 <amoeba+0x2a0>
mov    %ecx,%ebp
cmp    %rcx,%rbx
jne    13ba <amoeba+0x25a>
jmp    1420 <amoeba+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r14d,%rsi
mov    %eax,%edx
cmp    %rdx,%rcx
mov    %esi,%edx
cmovne %ecx,%edx
ucomiss (%rdi,%rsi,4),%xmm0
jbe    13b0 <amoeba+0x250>
mov    %edx,%r14d
jmp    13b0 <amoeba+0x250>
nopl   0x0(%rax,%rax,1)
mov    %eax,%r14d
jmp    1435 <amoeba+0x2d5>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%ebp
xor    %r13d,%r13d
movslq %ebp,%rax
mov    %rax,(%rsp)
movss  (%rdi,%rax,4),%xmm0
mov    %rdi,%rbx
call   1070 <fabs@plt>
movsd  %xmm0,0x48(%rsp)
movslq %r13d,%rax
mov    %rax,0x60(%rsp)
movss  (%rbx,%rax,4),%xmm0
call   1070 <fabs@plt>
addsd  0x48(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomisd 0x1bb6(%rip),%xmm0
jbe    14d8 <amoeba+0x378>
mov    0x58(%rsp),%rbx
mov    (%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
mov    0x60(%rsp),%rax
subss  (%rbx,%rax,4),%xmm0
call   1070 <fabs@plt>
addsd  %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
mov    (%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
call   1070 <fabs@plt>
movsd  %xmm0,0x110(%rsp)
mov    0x60(%rsp),%rax
movss  (%rbx,%rax,4),%xmm0
call   1070 <fabs@plt>
addsd  0x110(%rsp),%xmm0
movsd  0x48(%rsp),%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  0xbc(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x18(%rsp),%rbx
ja     2821 <amoeba+0x16c1>
mov    0x118(%rsp),%rdx
mov    (%rdx),%eax
lea    0x1(%rax),%ecx
mov    %ecx,(%rdx)
cmp    $0x3e8,%eax
jne    1516 <amoeba+0x3b6>
lea    0x1b28(%rip),%rdi
call   1040 <nrerror@plt>
mov    0x18(%rsp),%rbx
test   %ebx,%ebx
jle    1531 <amoeba+0x3d1>
mov    %r12,%rdi
xor    %esi,%esi
mov    0x100(%rsp),%rdx
call   1050 <memset@plt>
mov    0x18(%rsp),%rbx
test   %ebx,%ebx
mov    0x30(%rsp),%r8
movaps 0x130(%rsp),%xmm4
mov    0x10(%rsp),%r9
mov    0xb0(%rsp),%rax
js     1710 <amoeba+0x5b0>
mov    %ebp,%r10d
xor    %ecx,%ecx
jmp    156d <amoeba+0x40d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rax,%rcx
je     1710 <amoeba+0x5b0>
cmp    %r10,%rcx
je     1560 <amoeba+0x400>
test   %ebx,%ebx
jle    1560 <amoeba+0x400>
mov    (%r8,%rcx,8),%rdx
cmp    $0x8,%ebx
jb     159a <amoeba+0x43a>
lea    (%rdx,%r15,4),%rsi
cmp    %rsi,%r12
jae    163b <amoeba+0x4db>
cmp    0xe8(%rsp),%rdx
jae    163b <amoeba+0x4db>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r15,%rdi
test   %r9,%r9
je     15cb <amoeba+0x46b>
mov    %r9,%rbp
nopl   (%rax)
movss  (%rdx,%rsi,4),%xmm0
addss  (%r12,%rsi,4),%xmm0
movss  %xmm0,(%r12,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    15b0 <amoeba+0x450>
cmp    $0x3,%rdi
jb     1560 <amoeba+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm0
addss  (%r12,%rsi,4),%xmm0
movss  %xmm0,(%r12,%rsi,4)
movss  0x4(%rdx,%rsi,4),%xmm0
addss  0x4(%r12,%rsi,4),%xmm0
movss  %xmm0,0x4(%r12,%rsi,4)
movss  0x8(%rdx,%rsi,4),%xmm0
addss  0x8(%r12,%rsi,4),%xmm0
movss  %xmm0,0x8(%r12,%rsi,4)
movss  0xc(%rdx,%rsi,4),%xmm0
addss  0xc(%r12,%rsi,4),%xmm0
movss  %xmm0,0xc(%r12,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r15
jne    15e0 <amoeba+0x480>
jmp    1560 <amoeba+0x400>
cmpq   $0x0,0x38(%rsp)
je     16f9 <amoeba+0x599>
mov    0xe0(%rsp),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movups (%r12,%rsi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r12,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%r12,%rsi,4),%xmm1
movups 0x30(%r12,%rsi,4),%xmm3
movups %xmm2,(%r12,%rsi,4)
movups %xmm0,0x10(%r12,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%r12,%rsi,4)
movups %xmm1,0x30(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1660 <amoeba+0x500>
testb  $0x1,0x50(%rsp)
je     16e3 <amoeba+0x583>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movups (%r12,%rsi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r12,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%r12,%rsi,4)
movups %xmm0,0x10(%r12,%rsi,4)
mov    0x40(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r15,%rdi
je     1560 <amoeba+0x400>
jmp    159c <amoeba+0x43c>
xor    %esi,%esi
testb  $0x1,0x50(%rsp)
jne    16be <amoeba+0x55e>
jmp    16e3 <amoeba+0x583>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %ebx,%ebx
jle    1740 <amoeba+0x5e0>
mov    (%rsp),%rax
mov    (%r8,%rax,8),%rax
cmp    $0x4,%ebx
jae    17c0 <amoeba+0x660>
xor    %ecx,%ecx
mov    0x88(%rsp),%rbx
jmp    1890 <amoeba+0x730>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x88(%rsp),%rbx
mov    %rbx,%rdi
mov    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdx
call   1080 <solve_model@plt>
movaps %xmm0,%xmm2
mov    0x58(%rsp),%rdi
mov    0x60(%rsp),%rax
movss  (%rdi,%rax,4),%xmm0
ucomiss %xmm2,%xmm0
jae    187b <amoeba+0x71b>
movslq %r14d,%rax
ucomiss (%rdi,%rax,4),%xmm2
jb     1371 <amoeba+0x211>
mov    (%rsp),%rdx
movss  (%rdi,%rdx,4),%xmm0
ucomiss %xmm2,%xmm0
mov    0x18(%rsp),%r9
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
movsd  0x1873(%rip),%xmm4
movapd 0x184b(%rip),%xmm5
ja     2202 <amoeba+0x10a2>
jmp    2400 <amoeba+0x12a0>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%r12
setb   %sil
cmp    0xe8(%rsp),%rax
setb   %dl
and    %sil,%dl
or     0xf(%rsp),%dl
mov    0x88(%rsp),%rbx
cmp    %rcx,%rbx
setb   %dil
cmp    0x70(%rsp),%rax
setb   %sil
test   %dl,%dl
jne    1886 <amoeba+0x726>
mov    $0x0,%ecx
and    %sil,%dil
jne    1890 <amoeba+0x730>
xor    %ecx,%ecx
movaps 0x120(%rsp),%xmm5
mov    0xf8(%rsp),%rdx
nopl   (%rax)
movups (%r12,%rcx,1),%xmm0
divps  %xmm5,%xmm0
cvtps2pd %xmm0,%xmm1
movups %xmm0,(%r12,%rcx,1)
movhlps %xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
cvtps2pd (%rax,%rcx,1),%xmm2
cvtps2pd 0x8(%rax,%rcx,1),%xmm3
addpd  %xmm0,%xmm0
subpd  %xmm3,%xmm0
addpd  %xmm1,%xmm1
subpd  %xmm2,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rbx,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%rdx
jne    1820 <amoeba+0x6c0>
mov    0xa0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
jne    1890 <amoeba+0x730>
jmp    18c7 <amoeba+0x767>
movss  %xmm2,0x48(%rsp)
jmp    19f0 <amoeba+0x890>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,(%r12,%rcx,4)
cvtss2sd %xmm0,%xmm0
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1890 <amoeba+0x730>
mov    %rbx,%rdi
mov    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdx
call   1080 <solve_model@plt>
movapd %xmm0,%xmm2
mov    0x58(%rsp),%rdi
mov    0x60(%rsp),%rax
movss  (%rdi,%rax,4),%xmm0
ucomiss %xmm2,%xmm0
jae    19c0 <amoeba+0x860>
movslq %r14d,%rax
ucomiss (%rdi,%rax,4),%xmm2
jae    1a97 <amoeba+0x937>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
jle    1376 <amoeba+0x216>
mov    0x30(%rsp),%rax
mov    (%rsp),%r10
mov    (%rax,%r10,8),%rax
cmp    $0x8,%r8d
jb     193e <amoeba+0x7de>
cmp    0x70(%rsp),%rax
jae    1d6e <amoeba+0xc0e>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbx
jae    1d6e <amoeba+0xc0e>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
test   $0x3,%r15b
je     1974 <amoeba+0x814>
mov    %r9,%rsi
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1960 <amoeba+0x800>
cmp    $0x3,%rdx
jb     137a <amoeba+0x21a>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1980 <amoeba+0x820>
jmp    137a <amoeba+0x21a>
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
test   %eax,%eax
movss  %xmm2,0x48(%rsp)
jle    19f0 <amoeba+0x890>
cmp    $0x4,%eax
setb   %al
or     0xe(%rsp),%al
je     1b43 <amoeba+0x9e3>
xor    %ecx,%ecx
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
jmp    1c3c <amoeba+0xadc>
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
mov    %rbp,%rdi
mov    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdx
call   1080 <solve_model@plt>
mov    0x58(%rsp),%rdi
mov    0x60(%rsp),%rax
movss  (%rdi,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    1a60 <amoeba+0x900>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
jle    1cea <amoeba+0xb8a>
mov    0x30(%rsp),%rax
mov    (%rsp),%r10
mov    (%rax,%r10,8),%rax
cmp    $0x8,%r8d
jae    1cf2 <amoeba+0xb92>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
jmp    1e56 <amoeba+0xcf6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%r8
test   %r8d,%r8d
movss  0x48(%rsp),%xmm2
jle    1376 <amoeba+0x216>
mov    0x30(%rsp),%rax
mov    (%rsp),%r10
mov    (%rax,%r10,8),%rax
cmp    $0x8,%r8d
jae    1d11 <amoeba+0xbb1>
xor    %ecx,%ecx
mov    0x10(%rsp),%rbp
jmp    1f9c <amoeba+0xe3c>
mov    (%rsp),%rdx
movss  (%rdi,%rdx,4),%xmm0
ucomiss %xmm2,%xmm0
mov    0x18(%rsp),%r9
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
movsd  0x1561(%rip),%xmm4
movapd 0x1539(%rip),%xmm5
jbe    2207 <amoeba+0x10a7>
test   %r9d,%r9d
jle    2202 <amoeba+0x10a2>
mov    (%r8,%rdx,8),%rax
cmp    $0x8,%r9d
jb     1af8 <amoeba+0x998>
cmp    0x70(%rsp),%rax
jae    205c <amoeba+0xefc>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbx
jae    205c <amoeba+0xefc>
xor    %ecx,%ecx
mov    0x10(%rsp),%r10
mov    %rcx,%r11
not    %r11
add    %r15,%r11
test   $0x3,%r15b
je     200c <amoeba+0xeac>
mov    %r10,%rsi
mov    (%rsp),%rdx
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1b20 <amoeba+0x9c0>
cmp    $0x3,%r11
jae    2020 <amoeba+0xec0>
jmp    2202 <amoeba+0x10a2>
cmpq   $0x0,0xd8(%rsp)
je     1d4f <amoeba+0xbef>
mov    0xc8(%rsp),%rcx
xor    %eax,%eax
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
cvtps2pd 0x8(%rbx,%rax,4),%xmm0
cvtps2pd (%rbx,%rax,4),%xmm1
cvtps2pd 0x8(%r12,%rax,4),%xmm2
cvtps2pd (%r12,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rax,4)
cvtps2pd 0x18(%rbx,%rax,4),%xmm0
cvtps2pd 0x10(%rbx,%rax,4),%xmm1
cvtps2pd 0x18(%r12,%rax,4),%xmm2
cvtps2pd 0x10(%r12,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rbp,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b70 <amoeba+0xa10>
testb  $0x1,0xd0(%rsp)
01
je     1c28 <amoeba+0xac8>
cvtps2pd 0x8(%rbx,%rax,4),%xmm0
cvtps2pd (%rbx,%rax,4),%xmm1
cvtps2pd 0x8(%r12,%rax,4),%xmm2
cvtps2pd (%r12,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rax,4)
mov    0xa0(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
je     19fa <amoeba+0x89a>
mov    %rcx,%rax
test   $0x1,%r15b
je     1c71 <amoeba+0xb11>
movss  (%rbx,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r12,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xa8(%rsp),%rcx
je     19fa <amoeba+0x89a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r12,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%r12,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1c90 <amoeba+0xb30>
jmp    19fa <amoeba+0x89a>
movaps %xmm0,%xmm2
jmp    1376 <amoeba+0x216>
cmp    0x98(%rsp),%rax
mov    0x10(%rsp),%r9
jae    1d2d <amoeba+0xbcd>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbp
jae    1d2d <amoeba+0xbcd>
xor    %ecx,%ecx
jmp    1e56 <amoeba+0xcf6>
cmp    0x70(%rsp),%rax
mov    0x10(%rsp),%rbp
jae    1d3c <amoeba+0xbdc>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbx
jae    1d3c <amoeba+0xbdc>
xor    %ecx,%ecx
jmp    1f9c <amoeba+0xe3c>
cmpq   $0x18,0x38(%rsp)
jae    1d8b <amoeba+0xc2b>
xor    %ecx,%ecx
jmp    1df9 <amoeba+0xc99>
cmpq   $0x18,0x38(%rsp)
jae    1ee6 <amoeba+0xd86>
xor    %ecx,%ecx
jmp    1f48 <amoeba+0xde8>
xor    %eax,%eax
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r14
testb  $0x1,0xd0(%rsp)
01
jne    1bf2 <amoeba+0xa92>
jmp    1c28 <amoeba+0xac8>
cmpq   $0x18,0x38(%rsp)
jae    2074 <amoeba+0xf14>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    0x20(%rsp),%rbp
jmp    20ea <amoeba+0xf8a>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%rbp,%rcx,4),%xmm1
movups 0x10(%rbp,%rcx,4),%xmm2
movups %xmm1,(%rax,%rcx,4)
movups %xmm2,0x10(%rax,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm1
movups 0x30(%rbp,%rcx,4),%xmm2
movups %xmm1,0x20(%rax,%rcx,4)
movups %xmm2,0x30(%rax,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm1
movups 0x50(%rbp,%rcx,4),%xmm2
movups %xmm1,0x40(%rax,%rcx,4)
movups %xmm2,0x50(%rax,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm1
movups 0x70(%rbp,%rcx,4),%xmm2
movups %xmm1,0x60(%rax,%rcx,4)
movups %xmm2,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1da0 <amoeba+0xc40>
testb  $0x3,0x50(%rsp)
je     1e3b <amoeba+0xcdb>
lea    (%rax,%rcx,4),%rdx
add    $0x10,%rdx
mov    0xc0(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm1
movups (%rcx,%rsi,1),%xmm2
movups %xmm1,-0x10(%rdx,%rsi,1)
movups %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    1e20 <amoeba+0xcc0>
mov    0x40(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
jne    1e56 <amoeba+0xcf6>
movaps %xmm0,%xmm2
movss  %xmm0,(%rdi,%r10,4)
jmp    1380 <amoeba+0x220>
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
test   $0x3,%r15b
je     1e85 <amoeba+0xd25>
mov    %r9,%rsi
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1e70 <amoeba+0xd10>
cmp    $0x3,%rdx
jae    1ea0 <amoeba+0xd40>
movaps %xmm0,%xmm2
movss  %xmm0,(%rdi,%r10,4)
jmp    1380 <amoeba+0x220>
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x4(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x8(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm1
movss  %xmm1,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1ea0 <amoeba+0xd40>
movaps %xmm0,%xmm2
movss  %xmm0,(%rdi,%r10,4)
jmp    1380 <amoeba+0x220>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rax,%rcx,4)
movups %xmm1,0x10(%rax,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm1,0x30(%rax,%rcx,4)
movups 0x40(%rbx,%rcx,4),%xmm0
movups 0x50(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm1,0x50(%rax,%rcx,4)
movups 0x60(%rbx,%rcx,4),%xmm0
movups 0x70(%rbx,%rcx,4),%xmm1
movups %xmm0,0x60(%rax,%rcx,4)
movups %xmm1,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1ef0 <amoeba+0xd90>
cmpq   $0x0,0xf0(%rsp)
je     1f8b <amoeba+0xe2b>
lea    (%rax,%rcx,4),%rdx
add    $0x10,%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    1f70 <amoeba+0xe10>
mov    0x40(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
je     137a <amoeba+0x21a>
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
test   $0x3,%r15b
je     1fc4 <amoeba+0xe64>
mov    %rbp,%rsi
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1fb0 <amoeba+0xe50>
cmp    $0x3,%rdx
jb     137a <amoeba+0x21a>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1fd0 <amoeba+0xe70>
jmp    137a <amoeba+0x21a>
mov    (%rsp),%rdx
cmp    $0x3,%r11
jb     2202 <amoeba+0x10a2>
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    2020 <amoeba+0xec0>
jmp    2202 <amoeba+0x10a2>
cmpq   $0x18,0x38(%rsp)
jae    2143 <amoeba+0xfe3>
xor    %ecx,%ecx
mov    0x10(%rsp),%r10
jmp    21aa <amoeba+0x104a>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    0x20(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rax,%rcx,4)
movups %xmm1,0x10(%rax,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm1,0x30(%rax,%rcx,4)
movups 0x40(%rbx,%rcx,4),%xmm0
movups 0x50(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm1,0x50(%rax,%rcx,4)
movups 0x60(%rbx,%rcx,4),%xmm0
movupd 0x70(%rbx,%rcx,4),%xmm1
movups %xmm0,0x60(%rax,%rcx,4)
movupd %xmm1,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2090 <amoeba+0xf30>
testb  $0x3,0x50(%rsp)
je     212d <amoeba+0xfcd>
lea    (%rax,%rcx,4),%rdx
add    $0x10,%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    2110 <amoeba+0xfb0>
mov    0x40(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
je     137a <amoeba+0x21a>
jmp    1945 <amoeba+0x7e5>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%r10
nop
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rax,%rcx,4)
movups %xmm1,0x10(%rax,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm1,0x30(%rax,%rcx,4)
movups 0x40(%rbx,%rcx,4),%xmm0
movups 0x50(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm1,0x50(%rax,%rcx,4)
movups 0x60(%rbx,%rcx,4),%xmm0
movupd 0x70(%rbx,%rcx,4),%xmm1
movups %xmm0,0x60(%rax,%rcx,4)
movupd %xmm1,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2150 <amoeba+0xff0>
testb  $0x3,0x50(%rsp)
je     21ed <amoeba+0x108d>
lea    (%rax,%rcx,4),%rdx
add    $0x10,%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    21d0 <amoeba+0x1070>
mov    0x40(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
jne    1aff <amoeba+0x99f>
mov    (%rsp),%rdx
movss  %xmm2,(%rdi,%rdx,4)
test   %r9d,%r9d
jle    2400 <amoeba+0x12a0>
mov    (%r8,%rdx,8),%rax
cmp    $0x4,%r9d
jb     223b <amoeba+0x10db>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbp
setb   %cl
cmp    0x98(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0xd(%rsp),%dl
je     22f2 <amoeba+0x1192>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r15b
je     2276 <amoeba+0x1116>
movss  (%rax,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r12,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xa8(%rsp),%rdx
je     2400 <amoeba+0x12a0>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r12,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%r12,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    2290 <amoeba+0x1130>
jmp    2400 <amoeba+0x12a0>
cmpq   $0x0,0xd8(%rsp)
je     2752 <amoeba+0x15f2>
mov    0xc8(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
cvtps2pd 0x8(%rax,%rcx,4),%xmm0
cvtps2pd (%rax,%rcx,4),%xmm1
cvtps2pd (%r12,%rcx,4),%xmm2
cvtps2pd 0x8(%r12,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rcx,4)
cvtps2pd 0x18(%rax,%rcx,4),%xmm0
cvtps2pd 0x10(%rax,%rcx,4),%xmm1
cvtps2pd 0x10(%r12,%rcx,4),%xmm2
cvtps2pd 0x18(%r12,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rbp,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2310 <amoeba+0x11b0>
testb  $0x1,0xd0(%rsp)
01
je     23e4 <amoeba+0x1284>
cvtps2pd 0x8(%rax,%rcx,4),%xmm0
cvtps2pd (%rax,%rcx,4),%xmm1
cvtps2pd (%r12,%rcx,4),%xmm2
cvtps2pd 0x8(%r12,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rcx,4)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
jne    223d <amoeba+0x10dd>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdx
call   1080 <solve_model@plt>
mov    (%rsp),%r10
mov    0x58(%rsp),%rdi
movaps %xmm0,%xmm2
movss  (%rdi,%r10,4),%xmm0
ucomiss %xmm2,%xmm0
jbe    24ed <amoeba+0x138d>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
jle    137a <amoeba+0x21a>
mov    0x30(%rsp),%rax
mov    (%rax,%r10,8),%rax
cmp    $0x8,%r8d
mov    0x10(%rsp),%r9
jb     246d <amoeba+0x130d>
cmp    0x98(%rsp),%rax
jae    2746 <amoeba+0x15e6>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbp
jae    2746 <amoeba+0x15e6>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
test   $0x3,%r15b
je     24a5 <amoeba+0x1345>
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2490 <amoeba+0x1330>
cmp    $0x3,%rdx
jb     137a <amoeba+0x21a>
nop
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    24b0 <amoeba+0x1350>
jmp    137a <amoeba+0x21a>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
movss  0xb33(%rip),%xmm3
movaps 0xb0c(%rip),%xmm4
mov    0xb0(%rsp),%rax
js     1380 <amoeba+0x220>
mov    %r13d,%r14d
xor    %ebp,%ebp
jmp    2568 <amoeba+0x1408>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdx
call   1080 <solve_model@plt>
movaps 0xad4(%rip),%xmm4
movss  0xaec(%rip),%xmm3
mov    0x18(%rsp),%r8
mov    0x58(%rsp),%rdi
movss  %xmm0,(%rdi,%rbp,4)
mov    0xb0(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
je     1380 <amoeba+0x220>
cmp    %r14,%rbp
je     255b <amoeba+0x13fb>
test   %r8d,%r8d
jle    2520 <amoeba+0x13c0>
mov    0x30(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
mov    0x60(%rsp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    $0x8,%r8d
jae    2612 <amoeba+0x14b2>
xor    %esi,%esi
mov    %rsi,%rdx
test   $0x1,%r15b
je     25b8 <amoeba+0x1458>
movss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rbx,%rsi,4)
movss  %xmm0,(%rax,%rsi,4)
mov    %rsi,%rdx
or     $0x1,%rdx
not    %rsi
cmp    0xa8(%rsp),%rsi
je     2520 <amoeba+0x13c0>
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rbx,%rdx,4)
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
addss  0x4(%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x4(%rbx,%rdx,4)
movss  %xmm0,0x4(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    25d0 <amoeba+0x1470>
jmp    2520 <amoeba+0x13c0>
lea    (%rax,%r15,4),%rsi
lea    (%rcx,%r15,4),%rdi
cmp    %rsi,%rbx
setb   %r10b
mov    0x70(%rsp),%rdx
cmp    %rdx,%rax
setb   %r11b
cmp    %rdi,%rbx
setb   %r13b
cmp    %rdx,%rcx
setb   %r9b
cmp    %rdi,%rax
setb   %dil
cmp    %rsi,%rcx
setb   %r8b
test   %r11b,%r10b
jne    258e <amoeba+0x142e>
and    %r9b,%r13b
jne    258e <amoeba+0x142e>
mov    $0x0,%esi
and    %r8b,%dil
jne    2590 <amoeba+0x1430>
cmpq   $0x0,0x38(%rsp)
je     273b <amoeba+0x15db>
mov    0xe0(%rsp),%rsi
xor    %edx,%edx
nop
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,(%rbx,%rdx,4)
movups %xmm0,0x10(%rbx,%rdx,4)
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups 0x20(%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x30(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,0x20(%rbx,%rdx,4)
movups %xmm0,0x30(%rbx,%rdx,4)
movups %xmm2,0x20(%rax,%rdx,4)
movups %xmm0,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    2680 <amoeba+0x1520>
testb  $0x1,0x50(%rsp)
je     2725 <amoeba+0x15c5>
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,(%rbx,%rdx,4)
movups %xmm0,0x10(%rbx,%rdx,4)
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
mov    0x40(%rsp),%rdx
mov    %rdx,%rsi
cmp    %r15,%rdx
je     2520 <amoeba+0x13c0>
jmp    2590 <amoeba+0x1430>
xor    %edx,%edx
testb  $0x1,0x50(%rsp)
jne    26f5 <amoeba+0x1595>
jmp    2725 <amoeba+0x15c5>
cmpq   $0x18,0x38(%rsp)
jae    2767 <amoeba+0x1607>
xor    %ecx,%ecx
jmp    27c9 <amoeba+0x1669>
xor    %ecx,%ecx
testb  $0x1,0xd0(%rsp)
01
jne    23a6 <amoeba+0x1246>
jmp    23e4 <amoeba+0x1284>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
xchg   %ax,%ax
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
movups %xmm0,(%rax,%rcx,4)
movups %xmm1,0x10(%rax,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm0
movups 0x30(%rbp,%rcx,4),%xmm1
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm1,0x30(%rax,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm0
movups 0x50(%rbp,%rcx,4),%xmm1
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm1,0x50(%rax,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm0
movups 0x70(%rbp,%rcx,4),%xmm1
movups %xmm0,0x60(%rax,%rcx,4)
movups %xmm1,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2770 <amoeba+0x1610>
testb  $0x3,0x50(%rsp)
je     280b <amoeba+0x16ab>
lea    (%rax,%rcx,4),%rdx
add    $0x10,%rdx
mov    0xc0(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    27f0 <amoeba+0x1690>
mov    0x40(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
je     137a <amoeba+0x21a>
jmp    246f <amoeba+0x130f>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
@.str = [30 x i8] c"Too many iterations in AMOEBA\00"
define void @amoeba(float** nocapture %0, float* nocapture %1, i32 %2, float %3, i32* nocapture %4, i8* %5, i32* %6) {
%8 = tail call i64 @calloc(i32 %2, i32 4)
%9 = inttoptr i64 %8 to float*
%10 = inttoptr i64 %8 to i8*
%11 = tail call i64 @calloc(i32 %2, i32 4)
%12 = inttoptr i64 %11 to float*
%13 = inttoptr i64 %11 to i8*
%14 = tail call i64 @calloc(i32 %2, i32 4)
%15 = inttoptr i64 %14 to float*
%16 = inttoptr i64 %14 to i8*
%17 = inttoptr i64 %14 to i8*
store i32 0, i32* %4
%18 = getelementptr inbounds float, float* %1, i64 1
%19 = icmp slt i32 %2, 0
%20 = icmp sgt i32 %2, 0
%21 = icmp slt i32 %2, 1
%22 = sitofp i32 %2 to float
%23 = add i32 %2, 1
%24 = zext i32 %2 to i64
%25 = shl nuw nsw i64 %24, 2
%26 = zext i32 %23 to i64
%27 = zext i32 %23 to i64
%28 = zext i32 %23 to i64
%29 = getelementptr float, float* %9, i64 %24
%30 = getelementptr float, float* %12, i64 %24
%31 = getelementptr float, float* %9, i64 %24
%32 = getelementptr float, float* %12, i64 %24
%33 = bitcast float* %32 to i8*
%34 = getelementptr float, float* %15, i64 %24
%35 = bitcast float* %34 to i8*
%36 = getelementptr float, float* %9, i64 %24
%37 = getelementptr float, float* %12, i64 %24
%38 = getelementptr float, float* %9, i64 %24
%39 = getelementptr float, float* %12, i64 %24
%40 = bitcast float* %39 to i8*
%41 = getelementptr float, float* %9, i64 %24
%42 = bitcast float* %41 to i8*
%43 = getelementptr float, float* %15, i64 %24
%44 = bitcast float* %43 to i8*
%45 = getelementptr float, float* %15, i64 %24
%46 = bitcast float* %45 to i8*
%47 = getelementptr float, float* %9, i64 %24
%48 = bitcast float* %47 to i8*
%49 = getelementptr float, float* %15, i64 %24
%50 = and i64 %24, 4294967288
%51 = add nsw i64 %50, -8
%52 = lshr exact i64 %51, 3
%53 = add nuw nsw i64 %52, 1
%54 = and i64 %24, 4294967292
%55 = add nsw i64 %54, -4
%56 = lshr exact i64 %55, 2
%57 = add nuw nsw i64 %56, 1
%58 = icmp ult i32 %2, 8
%59 = and i64 %24, 4294967288
%60 = and i64 %53, 1
%61 = icmp eq i64 %51, 0
%62 = and i64 %53, 4611686018427387902
%63 = icmp eq i64 %60, 0
%64 = icmp eq i64 %59, %24
%65 = and i64 %24, 3
%66 = icmp eq i64 %65, 0
%67 = icmp ult i32 %2, 4
%68 = icmp ult i8* %16, %48
%69 = icmp ult i8* %10, %46
%70 = and i1 %68, %69
%71 = and i64 %24, 4294967292
%72 = insertelement <4 x float> poison, float %22, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = icmp eq i64 %71, %24
%75 = icmp ult i32 %2, 4
%76 = icmp ult i8* %13, %42
%77 = icmp ult i8* %10, %40
%78 = and i1 %76, %77
%79 = icmp ult i8* %13, %44
%80 = icmp ult i8* %16, %40
%81 = and i1 %79, %80
%82 = or i1 %78, %81
%83 = and i64 %24, 4294967292
%84 = and i64 %57, 1
%85 = icmp eq i64 %55, 0
%86 = and i64 %57, 9223372036854775806
%87 = icmp eq i64 %84, 0
%88 = icmp eq i64 %83, %24
%89 = and i64 %24, 1
%90 = icmp eq i64 %89, 0
%91 = sub nsw i64 0, %24
%92 = icmp ult i32 %2, 8
%93 = and i64 %24, 4294967288
%94 = and i64 %53, 3
%95 = icmp ult i64 %51, 24
%96 = and i64 %53, 4611686018427387900
%97 = icmp eq i64 %94, 0
%98 = icmp eq i64 %93, %24
%99 = and i64 %24, 3
%100 = icmp eq i64 %99, 0
%101 = icmp ult i32 %2, 8
%102 = and i64 %24, 4294967288
%103 = and i64 %53, 3
%104 = icmp ult i64 %51, 24
%105 = and i64 %53, 4611686018427387900
%106 = icmp eq i64 %103, 0
%107 = icmp eq i64 %102, %24
%108 = and i64 %24, 3
%109 = icmp eq i64 %108, 0
%110 = icmp ult i32 %2, 8
%111 = and i64 %24, 4294967288
%112 = and i64 %53, 3
%113 = icmp ult i64 %51, 24
%114 = and i64 %53, 4611686018427387900
%115 = icmp eq i64 %112, 0
%116 = icmp eq i64 %111, %24
%117 = and i64 %24, 3
%118 = icmp eq i64 %117, 0
%119 = icmp ult i32 %2, 4
%120 = icmp ult i8* %13, %35
%121 = icmp ult i8* %16, %33
%122 = and i1 %120, %121
%123 = and i64 %24, 4294967292
%124 = and i64 %57, 1
%125 = icmp eq i64 %55, 0
%126 = and i64 %57, 9223372036854775806
%127 = icmp eq i64 %124, 0
%128 = icmp eq i64 %123, %24
%129 = and i64 %24, 1
%130 = icmp eq i64 %129, 0
%131 = sub nsw i64 0, %24
%132 = icmp ult i32 %2, 8
%133 = and i64 %24, 4294967288
%134 = and i64 %53, 1
%135 = icmp eq i64 %51, 0
%136 = and i64 %53, 4611686018427387902
%137 = icmp eq i64 %134, 0
%138 = icmp eq i64 %133, %24
%139 = and i64 %24, 1
%140 = icmp eq i64 %139, 0
%141 = sub nsw i64 0, %24
%142 = icmp ult i32 %2, 8
%143 = and i64 %24, 4294967288
%144 = and i64 %53, 3
%145 = icmp ult i64 %51, 24
%146 = and i64 %53, 4611686018427387900
%147 = icmp eq i64 %144, 0
%148 = icmp eq i64 %143, %24
%149 = and i64 %24, 3
%150 = icmp eq i64 %149, 0
%151 = icmp ult i32 %2, 8
%152 = and i64 %24, 4294967288
%153 = and i64 %53, 3
%154 = icmp ult i64 %51, 24
%155 = and i64 %53, 4611686018427387900
%156 = icmp eq i64 %153, 0
%157 = icmp eq i64 %152, %24
%158 = and i64 %24, 3
%159 = icmp eq i64 %158, 0
br label %160
160: ; preds = %1370, %7
%161 = load float, float* %1
%162 = load float, float* %18
%163 = fcmp ogt float %161, %162
%164 = zext i1 %163 to i32
%165 = xor i1 %163, true
%166 = zext i1 %165 to i32
br i1 %19, label %201, label %167
167: ; preds = %160, %195
%168 = phi float [ %200, %195 ], [ %161, %160 ]
%169 = phi float [ %197, %195 ], [ %161, %160 ]
%170 = phi i64 [ %193, %195 ], [ 0, %160 ]
%171 = phi i32 [ %192, %195 ], [ %164, %160 ]
%172 = phi i32 [ %176, %195 ], [ 0, %160 ]
%173 = phi i32 [ %191, %195 ], [ %166, %160 ]
%174 = fcmp olt float %169, %168
%175 = trunc i64 %170 to i32
%176 = select i1 %174, i32 %175, i32 %172
%177 = sext i32 %173 to i64
%178 = getelementptr inbounds float, float* %1, i64 %177
%179 = load float, float* %178
%180 = fcmp ogt float %169, %179
br i1 %180, label %190, label %181
181: ; preds = %167
%182 = sext i32 %171 to i64
%183 = getelementptr inbounds float, float* %1, i64 %182
%184 = load float, float* %183
%185 = fcmp ule float %169, %184
%186 = zext i32 %173 to i64
%187 = icmp eq i64 %170, %186
%188 = select i1 %185, i1 true, i1 %187
%189 = select i1 %188, i32 %171, i32 %175
br label %190
190: ; preds = %181, %167
%191 = phi i32 [ %175, %167 ], [ %173, %181 ]
%192 = phi i32 [ %173, %167 ], [ %189, %181 ]
%193 = add nuw nsw i64 %170, 1
%194 = icmp eq i64 %193, %26
br i1 %194, label %201, label %195
195: ; preds = %190
%196 = getelementptr inbounds float, float* %1, i64 %193
%197 = load float, float* %196
%198 = sext i32 %176 to i64
%199 = getelementptr inbounds float, float* %1, i64 %198
%200 = load float, float* %199
br label %167
201: ; preds = %190, %160
%202 = phi i32 [ %166, %160 ], [ %191, %190 ]
%203 = phi i32 [ 0, %160 ], [ %176, %190 ]
%204 = phi i32 [ %164, %160 ], [ %192, %190 ]
%205 = sext i32 %202 to i64
%206 = getelementptr inbounds float, float* %1, i64 %205
%207 = load float, float* %206
%208 = tail call double @fabs(float %207)
%209 = sext i32 %203 to i64
%210 = getelementptr inbounds float, float* %1, i64 %209
%211 = load float, float* %210
%212 = tail call double @fabs(float %211)
%213 = fadd double %208, %212
%214 = fcmp ogt double %213, 0.000000e+00
br i1 %214, label %215, label %228
215: ; preds = %201
%216 = load float, float* %206
%217 = load float, float* %210
%218 = fsub float %216, %217
%219 = tail call double @fabs(float %218)
%220 = fmul double %219, 2.000000e+00
%221 = load float, float* %206
%222 = tail call double @fabs(float %221)
%223 = load float, float* %210
%224 = tail call double @fabs(float %223)
%225 = fadd double %222, %224
%226 = fdiv double %220, %225
%227 = fptrunc double %226 to float
br label %228
228: ; preds = %201, %215
%229 = phi float [ %227, %215 ], [ 0.000000e+00, %201 ]
%230 = fcmp olt float %229, %3
br i1 %230, label %1371, label %231
231: ; preds = %228
%232 = load i32, i32* %4
%233 = add nsw i32 %232, 1
store i32 %233, i32* %4
%234 = icmp eq i32 %232, 1000
br i1 %234, label %235, label %237
235: ; preds = %231
%236 = tail call i32 @nrerror(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0))
br label %237
237: ; preds = %235, %231
br i1 %20, label %238, label %239
238: ; preds = %237
br label %239
239: ; preds = %238, %237
br i1 %19, label %242, label %240
240: ; preds = %239
%241 = zext i32 %202 to i64
br label %279
242: ; preds = %397, %239
br i1 %20, label %243, label %419
243: ; preds = %242
%244 = getelementptr inbounds float*, float** %0, i64 %205
%245 = load float*, float** %244
br i1 %67, label %277, label %246
246: ; preds = %243
%247 = getelementptr float, float* %245, i64 %24
%248 = bitcast float* %247 to i8*
%249 = icmp ult i8* %16, %248
%250 = icmp ult float* %245, %45
%251 = and i1 %249, %250
%252 = or i1 %70, %251
%253 = icmp ult i8* %10, %248
%254 = icmp ult float* %245, %47
%255 = and i1 %253, %254
%256 = or i1 %252, %255
br i1 %256, label %277, label %257
257: ; preds = %246, %257
%258 = phi i64 [ %274, %257 ], [ 0, %246 ]
%259 = getelementptr inbounds float, float* %15, i64 %258
%260 = bitcast float* %259 to <4 x float>*
%261 = load <4 x float>, <4 x float>* %260
%262 = fdiv <4 x float> %261, %73
%263 = bitcast float* %259 to <4 x float>*
store <4 x float> %262, <4 x float>* %263
%264 = fpext <4 x float> %262 to <4 x double>
%265 = getelementptr inbounds float, float* %245, i64 %258
%266 = bitcast float* %265 to <4 x float>*
%267 = load <4 x float>, <4 x float>* %266
%268 = fpext <4 x float> %267 to <4 x double>
%269 = fneg <4 x double> %268
%270 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %264, <4 x double> <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>, <4 x double> %269)
%271 = fptrunc <4 x double> %270 to <4 x float>
%272 = getelementptr inbounds float, float* %9, i64 %258
%273 = bitcast float* %272 to <4 x float>*
store <4 x float> %271, <4 x float>* %273
%274 = add nuw i64 %258, 4
%275 = icmp eq i64 %274, %71
br i1 %275, label %276, label %257
276: ; preds = %257
br i1 %74, label %415, label %277
277: ; preds = %246, %243, %276
%278 = phi i64 [ 0, %246 ], [ 0, %243 ], [ %71, %276 ]
br label %400
279: ; preds = %240, %397
%280 = phi i64 [ 0, %240 ], [ %398, %397 ]
%281 = icmp eq i64 %280, %241
%282 = or i1 %281, %21
br i1 %282, label %397, label %283
283: ; preds = %279
%284 = getelementptr inbounds float*, float** %0, i64 %280
%285 = load float*, float** %284
br i1 %58, label %352, label %286
286: ; preds = %283
%287 = getelementptr float, float* %285, i64 %24
%288 = bitcast float* %287 to i8*
%289 = icmp ult i8* %16, %288
%290 = icmp ult float* %285, %49
%291 = and i1 %289, %290
br i1 %291, label %352, label %292
292: ; preds = %286
br i1 %61, label %332, label %293
293: ; preds = %292, %293
%294 = phi i64 [ %329, %293 ], [ 0, %292 ]
%295 = phi i64 [ %330, %293 ], [ 0, %292 ]
%296 = getelementptr inbounds float, float* %285, i64 %294
%297 = bitcast float* %296 to <4 x float>*
%298 = load <4 x float>, <4 x float>* %297
%299 = getelementptr inbounds float, float* %296, i64 4
%300 = bitcast float* %299 to <4 x float>*
%301 = load <4 x float>, <4 x float>* %300
%302 = getelementptr inbounds float, float* %15, i64 %294
%303 = bitcast float* %302 to <4 x float>*
%304 = load <4 x float>, <4 x float>* %303
%305 = getelementptr inbounds float, float* %302, i64 4
%306 = bitcast float* %305 to <4 x float>*
%307 = load <4 x float>, <4 x float>* %306
%308 = fadd <4 x float> %298, %304
%309 = fadd <4 x float> %301, %307
%310 = bitcast float* %302 to <4 x float>*
store <4 x float> %308, <4 x float>* %310
%311 = bitcast float* %305 to <4 x float>*
store <4 x float> %309, <4 x float>* %311
%312 = or i64 %294, 8
%313 = getelementptr inbounds float, float* %285, i64 %312
%314 = bitcast float* %313 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = getelementptr inbounds float, float* %313, i64 4
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = getelementptr inbounds float, float* %15, i64 %312
%320 = bitcast float* %319 to <4 x float>*
%321 = load <4 x float>, <4 x float>* %320
%322 = getelementptr inbounds float, float* %319, i64 4
%323 = bitcast float* %322 to <4 x float>*
%324 = load <4 x float>, <4 x float>* %323
%325 = fadd <4 x float> %315, %321
%326 = fadd <4 x float> %318, %324
%327 = bitcast float* %319 to <4 x float>*
store <4 x float> %325, <4 x float>* %327
%328 = bitcast float* %322 to <4 x float>*
store <4 x float> %326, <4 x float>* %328
%329 = add nuw i64 %294, 16
%330 = add i64 %295, 2
%331 = icmp eq i64 %330, %62
br i1 %331, label %332, label %293
332: ; preds = %293, %292
%333 = phi i64 [ 0, %292 ], [ %329, %293 ]
br i1 %63, label %351, label %334
334: ; preds = %332
%335 = getelementptr inbounds float, float* %285, i64 %333
%336 = bitcast float* %335 to <4 x float>*
%337 = load <4 x float>, <4 x float>* %336
%338 = getelementptr inbounds float, float* %335, i64 4
%339 = bitcast float* %338 to <4 x float>*
%340 = load <4 x float>, <4 x float>* %339
%341 = getelementptr inbounds float, float* %15, i64 %333
%342 = bitcast float* %341 to <4 x float>*
%343 = load <4 x float>, <4 x float>* %342
%344 = getelementptr inbounds float, float* %341, i64 4
%345 = bitcast float* %344 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = fadd <4 x float> %337, %343
%348 = fadd <4 x float> %340, %346
%349 = bitcast float* %341 to <4 x float>*
store <4 x float> %347, <4 x float>* %349
%350 = bitcast float* %344 to <4 x float>*
store <4 x float> %348, <4 x float>* %350
br label %351
351: ; preds = %332, %334
br i1 %64, label %397, label %352
352: ; preds = %286, %283, %351
%353 = phi i64 [ 0, %286 ], [ 0, %283 ], [ %59, %351 ]
%354 = xor i64 %353, -1
%355 = add nsw i64 %354, %24
br i1 %66, label %367, label %356
356: ; preds = %352, %356
%357 = phi i64 [ %364, %356 ], [ %353, %352 ]
%358 = phi i64 [ %365, %356 ], [ 0, %352 ]
%359 = getelementptr inbounds float, float* %285, i64 %357
%360 = load float, float* %359
%361 = getelementptr inbounds float, float* %15, i64 %357
%362 = load float, float* %361
%363 = fadd float %360, %362
store float %363, float* %361
%364 = add nuw nsw i64 %357, 1
%365 = add i64 %358, 1
%366 = icmp eq i64 %365, %65
br i1 %366, label %367, label %356
367: ; preds = %356, %352
%368 = phi i64 [ %353, %352 ], [ %364, %356 ]
%369 = icmp ult i64 %355, 3
br i1 %369, label %397, label %370
370: ; preds = %367, %370
%371 = phi i64 [ %395, %370 ], [ %368, %367 ]
%372 = getelementptr inbounds float, float* %285, i64 %371
%373 = load float, float* %372
%374 = getelementptr inbounds float, float* %15, i64 %371
%375 = load float, float* %374
%376 = fadd float %373, %375
store float %376, float* %374
%377 = add nuw nsw i64 %371, 1
%378 = getelementptr inbounds float, float* %285, i64 %377
%379 = load float, float* %378
%380 = getelementptr inbounds float, float* %15, i64 %377
%381 = load float, float* %380
%382 = fadd float %379, %381
store float %382, float* %380
%383 = add nuw nsw i64 %371, 2
%384 = getelementptr inbounds float, float* %285, i64 %383
%385 = load float, float* %384
%386 = getelementptr inbounds float, float* %15, i64 %383
%387 = load float, float* %386
%388 = fadd float %385, %387
store float %388, float* %386
%389 = add nuw nsw i64 %371, 3
%390 = getelementptr inbounds float, float* %285, i64 %389
%391 = load float, float* %390
%392 = getelementptr inbounds float, float* %15, i64 %389
%393 = load float, float* %392
%394 = fadd float %391, %393
store float %394, float* %392
%395 = add nuw nsw i64 %371, 4
%396 = icmp eq i64 %395, %24
br i1 %396, label %397, label %370
397: ; preds = %367, %370, %351, %279
%398 = add nuw nsw i64 %280, 1
%399 = icmp eq i64 %398, %27
br i1 %399, label %242, label %279
400: ; preds = %277, %400
%401 = phi i64 [ %413, %400 ], [ %278, %277 ]
%402 = getelementptr inbounds float, float* %15, i64 %401
%403 = load float, float* %402
%404 = fdiv float %403, %22
store float %404, float* %402
%405 = fpext float %404 to double
%406 = getelementptr inbounds float, float* %245, i64 %401
%407 = load float, float* %406
%408 = fpext float %407 to double
%409 = fneg double %408
%410 = tail call double @llvm.fmuladd.f64(double %405, double 2.000000e+00, double %409)
%411 = fptrunc double %410 to float
%412 = getelementptr inbounds float, float* %9, i64 %401
store float %411, float* %412
%413 = add nuw nsw i64 %401, 1
%414 = icmp eq i64 %413, %24
br i1 %414, label %415, label %400
415: ; preds = %400, %276
%416 = tail call float @solve_model(float* %9, i8* %5, i32* %6)
%417 = load float, float* %210
%418 = fcmp ugt float %416, %417
br i1 %418, label %753, label %423
419: ; preds = %242
%420 = tail call float @solve_model(float* %9, i8* %5, i32* %6)
%421 = load float, float* %210
%422 = fcmp ugt float %420, %421
br i1 %422, label %758, label %520
423: ; preds = %415
br i1 %20, label %424, label %520
424: ; preds = %423
%425 = select i1 %75, i1 true, i1 %82
br i1 %425, label %477, label %426
426: ; preds = %424
br i1 %85, label %460, label %427
427: ; preds = %426, %427
%428 = phi i64 [ %457, %427 ], [ 0, %426 ]
%429 = phi i64 [ %458, %427 ], [ 0, %426 ]
%430 = getelementptr inbounds float, float* %9, i64 %428
%431 = bitcast float* %430 to <4 x float>*
%432 = load <4 x float>, <4 x float>* %431
%433 = fpext <4 x float> %432 to <4 x double>
%434 = getelementptr inbounds float, float* %15, i64 %428
%435 = bitcast float* %434 to <4 x float>*
%436 = load <4 x float>, <4 x float>* %435
%437 = fpext <4 x float> %436 to <4 x double>
%438 = fneg <4 x double> %437
%439 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %433, <4 x double> <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>, <4 x double> %438)
%440 = fptrunc <4 x double> %439 to <4 x float>
%441 = getelementptr inbounds float, float* %12, i64 %428
%442 = bitcast float* %441 to <4 x float>*
store <4 x float> %440, <4 x float>* %442
%443 = or i64 %428, 4
%444 = getelementptr inbounds float, float* %9, i64 %443
%445 = bitcast float* %444 to <4 x float>*
%446 = load <4 x float>, <4 x float>* %445
%447 = fpext <4 x float> %446 to <4 x double>
%448 = getelementptr inbounds float, float* %15, i64 %443
%449 = bitcast float* %448 to <4 x float>*
%450 = load <4 x float>, <4 x float>* %449
%451 = fpext <4 x float> %450 to <4 x double>
%452 = fneg <4 x double> %451
%453 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %447, <4 x double> <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>, <4 x double> %452)
%454 = fptrunc <4 x double> %453 to <4 x float>
%455 = getelementptr inbounds float, float* %12, i64 %443
%456 = bitcast float* %455 to <4 x float>*
store <4 x float> %454, <4 x float>* %456
%457 = add nuw i64 %428, 8
%458 = add i64 %429, 2
%459 = icmp eq i64 %458, %86
br i1 %459, label %460, label %427
460: ; preds = %427, %426
%461 = phi i64 [ 0, %426 ], [ %457, %427 ]
br i1 %87, label %476, label %462
462: ; preds = %460
%463 = getelementptr inbounds float, float* %9, i64 %461
%464 = bitcast float* %463 to <4 x float>*
%465 = load <4 x float>, <4 x float>* %464
%466 = fpext <4 x float> %465 to <4 x double>
%467 = getelementptr inbounds float, float* %15, i64 %461
%468 = bitcast float* %467 to <4 x float>*
%469 = load <4 x float>, <4 x float>* %468
%470 = fpext <4 x float> %469 to <4 x double>
%471 = fneg <4 x double> %470
%472 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %466, <4 x double> <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>, <4 x double> %471)
%473 = fptrunc <4 x double> %472 to <4 x float>
%474 = getelementptr inbounds float, float* %12, i64 %461
%475 = bitcast float* %474 to <4 x float>*
store <4 x float> %473, <4 x float>* %475
br label %476
476: ; preds = %460, %462
br i1 %88, label %520, label %477
477: ; preds = %424, %476
%478 = phi i64 [ 0, %424 ], [ %83, %476 ]
%479 = xor i64 %478, -1
br i1 %90, label %492, label %480
480: ; preds = %477
%481 = getelementptr inbounds float, float* %9, i64 %478
%482 = load float, float* %481
%483 = fpext float %482 to double
%484 = getelementptr inbounds float, float* %15, i64 %478
%485 = load float, float* %484
%486 = fpext float %485 to double
%487 = fneg double %486
%488 = tail call double @llvm.fmuladd.f64(double %483, double 2.000000e+00, double %487)
%489 = fptrunc double %488 to float
%490 = getelementptr inbounds float, float* %12, i64 %478
store float %489, float* %490
%491 = or i64 %478, 1
br label %492
492: ; preds = %480, %477
%493 = phi i64 [ %478, %477 ], [ %491, %480 ]
%494 = icmp eq i64 %479, %91
br i1 %494, label %520, label %495
495: ; preds = %492, %495
%496 = phi i64 [ %518, %495 ], [ %493, %492 ]
%497 = getelementptr inbounds float, float* %9, i64 %496
%498 = load float, float* %497
%499 = fpext float %498 to double
%500 = getelementptr inbounds float, float* %15, i64 %496
%501 = load float, float* %500
%502 = fpext float %501 to double
%503 = fneg double %502
%504 = tail call double @llvm.fmuladd.f64(double %499, double 2.000000e+00, double %503)
%505 = fptrunc double %504 to float
%506 = getelementptr inbounds float, float* %12, i64 %496
store float %505, float* %506
%507 = add nuw nsw i64 %496, 1
%508 = getelementptr inbounds float, float* %9, i64 %507
%509 = load float, float* %508
%510 = fpext float %509 to double
%511 = getelementptr inbounds float, float* %15, i64 %507
%512 = load float, float* %511
%513 = fpext float %512 to double
%514 = fneg double %513
%515 = tail call double @llvm.fmuladd.f64(double %510, double 2.000000e+00, double %514)
%516 = fptrunc double %515 to float
%517 = getelementptr inbounds float, float* %12, i64 %507
store float %516, float* %517
%518 = add nuw nsw i64 %496, 2
%519 = icmp eq i64 %518, %24
br i1 %519, label %520, label %495
520: ; preds = %492, %495, %476, %419, %423
%521 = phi float [ %416, %423 ], [ %420, %419 ], [ %416, %476 ], [ %416, %495 ], [ %416, %492 ]
%522 = tail call float @solve_model(float* %12, i8* %5, i32* %6)
%523 = load float, float* %210
%524 = fcmp olt float %522, %523
br i1 %524, label %620, label %525
525: ; preds = %520
br i1 %20, label %526, label %1368
526: ; preds = %525
%527 = getelementptr inbounds float*, float** %0, i64 %205
%528 = load float*, float** %527
br i1 %92, label %604, label %529
529: ; preds = %526
%530 = getelementptr float, float* %528, i64 %24
%531 = bitcast float* %530 to i8*
%532 = icmp ult float* %528, %38
%533 = icmp ult i8* %10, %531
%534 = and i1 %532, %533
br i1 %534, label %604, label %535
535: ; preds = %529
br i1 %95, label %585, label %536
536: ; preds = %535, %536
%537 = phi i64 [ %582, %536 ], [ 0, %535 ]
%538 = phi i64 [ %583, %536 ], [ 0, %535 ]
%539 = getelementptr inbounds float, float* %9, i64 %537
%540 = bitcast float* %539 to <4 x float>*
%541 = load <4 x float>, <4 x float>* %540
%542 = getelementptr inbounds float, float* %539, i64 4
%543 = bitcast float* %542 to <4 x float>*
%544 = load <4 x float>, <4 x float>* %543
%545 = getelementptr inbounds float, float* %528, i64 %537
%546 = bitcast float* %545 to <4 x float>*
store <4 x float> %541, <4 x float>* %546
%547 = getelementptr inbounds float, float* %545, i64 4
%548 = bitcast float* %547 to <4 x float>*
store <4 x float> %544, <4 x float>* %548
%549 = or i64 %537, 8
%550 = getelementptr inbounds float, float* %9, i64 %549
%551 = bitcast float* %550 to <4 x float>*
%552 = load <4 x float>, <4 x float>* %551
%553 = getelementptr inbounds float, float* %550, i64 4
%554 = bitcast float* %553 to <4 x float>*
%555 = load <4 x float>, <4 x float>* %554
%556 = getelementptr inbounds float, float* %528, i64 %549
%557 = bitcast float* %556 to <4 x float>*
store <4 x float> %552, <4 x float>* %557
%558 = getelementptr inbounds float, float* %556, i64 4
%559 = bitcast float* %558 to <4 x float>*
store <4 x float> %555, <4 x float>* %559
%560 = or i64 %537, 16
%561 = getelementptr inbounds float, float* %9, i64 %560
%562 = bitcast float* %561 to <4 x float>*
%563 = load <4 x float>, <4 x float>* %562
%564 = getelementptr inbounds float, float* %561, i64 4
%565 = bitcast float* %564 to <4 x float>*
%566 = load <4 x float>, <4 x float>* %565
%567 = getelementptr inbounds float, float* %528, i64 %560
%568 = bitcast float* %567 to <4 x float>*
store <4 x float> %563, <4 x float>* %568
%569 = getelementptr inbounds float, float* %567, i64 4
%570 = bitcast float* %569 to <4 x float>*
store <4 x float> %566, <4 x float>* %570
%571 = or i64 %537, 24
%572 = getelementptr inbounds float, float* %9, i64 %571
%573 = bitcast float* %572 to <4 x float>*
%574 = load <4 x float>, <4 x float>* %573
%575 = getelementptr inbounds float, float* %572, i64 4
%576 = bitcast float* %575 to <4 x float>*
%577 = load <4 x float>, <4 x float>* %576
%578 = getelementptr inbounds float, float* %528, i64 %571
%579 = bitcast float* %578 to <4 x float>*
store <4 x float> %574, <4 x float>* %579
%580 = getelementptr inbounds float, float* %578, i64 4
%581 = bitcast float* %580 to <4 x float>*
store <4 x float> %577, <4 x float>* %581
%582 = add nuw i64 %537, 32
%583 = add i64 %538, 4
%584 = icmp eq i64 %583, %96
br i1 %584, label %585, label %536
585: ; preds = %536, %535
%586 = phi i64 [ 0, %535 ], [ %582, %536 ]
br i1 %97, label %603, label %587
587: ; preds = %585, %587
%588 = phi i64 [ %600, %587 ], [ %586, %585 ]
%589 = phi i64 [ %601, %587 ], [ 0, %585 ]
%590 = getelementptr inbounds float, float* %9, i64 %588
%591 = bitcast float* %590 to <4 x float>*
%592 = load <4 x float>, <4 x float>* %591
%593 = getelementptr inbounds float, float* %590, i64 4
%594 = bitcast float* %593 to <4 x float>*
%595 = load <4 x float>, <4 x float>* %594
%596 = getelementptr inbounds float, float* %528, i64 %588
%597 = bitcast float* %596 to <4 x float>*
store <4 x float> %592, <4 x float>* %597
%598 = getelementptr inbounds float, float* %596, i64 4
%599 = bitcast float* %598 to <4 x float>*
store <4 x float> %595, <4 x float>* %599
%600 = add nuw i64 %588, 8
%601 = add i64 %589, 1
%602 = icmp eq i64 %601, %94
br i1 %602, label %603, label %587
603: ; preds = %587, %585
br i1 %98, label %1368, label %604
604: ; preds = %529, %526, %603
%605 = phi i64 [ 0, %529 ], [ 0, %526 ], [ %93, %603 ]
%606 = xor i64 %605, -1
%607 = add nsw i64 %606, %24
br i1 %100, label %617, label %608
608: ; preds = %604, %608
%609 = phi i64 [ %614, %608 ], [ %605, %604 ]
%610 = phi i64 [ %615, %608 ], [ 0, %604 ]
%611 = getelementptr inbounds float, float* %9, i64 %609
%612 = load float, float* %611
%613 = getelementptr inbounds float, float* %528, i64 %609
store float %612, float* %613
%614 = add nuw nsw i64 %609, 1
%615 = add i64 %610, 1
%616 = icmp eq i64 %615, %99
br i1 %616, label %617, label %608
617: ; preds = %608, %604
%618 = phi i64 [ %605, %604 ], [ %614, %608 ]
%619 = icmp ult i64 %607, 3
br i1 %619, label %1368, label %734
620: ; preds = %520
br i1 %20, label %621, label %1368
621: ; preds = %620
%622 = getelementptr inbounds float*, float** %0, i64 %205
%623 = load float*, float** %622
br i1 %101, label %699, label %624
624: ; preds = %621
%625 = getelementptr float, float* %623, i64 %24
%626 = bitcast float* %625 to i8*
%627 = icmp ult float* %623, %37
%628 = icmp ult i8* %13, %626
%629 = and i1 %627, %628
br i1 %629, label %699, label %630
630: ; preds = %624
br i1 %104, label %680, label %631
631: ; preds = %630, %631
%632 = phi i64 [ %677, %631 ], [ 0, %630 ]
%633 = phi i64 [ %678, %631 ], [ 0, %630 ]
%634 = getelementptr inbounds float, float* %12, i64 %632
%635 = bitcast float* %634 to <4 x float>*
%636 = load <4 x float>, <4 x float>* %635
%637 = getelementptr inbounds float, float* %634, i64 4
%638 = bitcast float* %637 to <4 x float>*
%639 = load <4 x float>, <4 x float>* %638
%640 = getelementptr inbounds float, float* %623, i64 %632
%641 = bitcast float* %640 to <4 x float>*
store <4 x float> %636, <4 x float>* %641
%642 = getelementptr inbounds float, float* %640, i64 4
%643 = bitcast float* %642 to <4 x float>*
store <4 x float> %639, <4 x float>* %643
%644 = or i64 %632, 8
%645 = getelementptr inbounds float, float* %12, i64 %644
%646 = bitcast float* %645 to <4 x float>*
%647 = load <4 x float>, <4 x float>* %646
%648 = getelementptr inbounds float, float* %645, i64 4
%649 = bitcast float* %648 to <4 x float>*
%650 = load <4 x float>, <4 x float>* %649
%651 = getelementptr inbounds float, float* %623, i64 %644
%652 = bitcast float* %651 to <4 x float>*
store <4 x float> %647, <4 x float>* %652
%653 = getelementptr inbounds float, float* %651, i64 4
%654 = bitcast float* %653 to <4 x float>*
store <4 x float> %650, <4 x float>* %654
%655 = or i64 %632, 16
%656 = getelementptr inbounds float, float* %12, i64 %655
%657 = bitcast float* %656 to <4 x float>*
%658 = load <4 x float>, <4 x float>* %657
%659 = getelementptr inbounds float, float* %656, i64 4
%660 = bitcast float* %659 to <4 x float>*
%661 = load <4 x float>, <4 x float>* %660
%662 = getelementptr inbounds float, float* %623, i64 %655
%663 = bitcast float* %662 to <4 x float>*
store <4 x float> %658, <4 x float>* %663
%664 = getelementptr inbounds float, float* %662, i64 4
%665 = bitcast float* %664 to <4 x float>*
store <4 x float> %661, <4 x float>* %665
%666 = or i64 %632, 24
%667 = getelementptr inbounds float, float* %12, i64 %666
%668 = bitcast float* %667 to <4 x float>*
%669 = load <4 x float>, <4 x float>* %668
%670 = getelementptr inbounds float, float* %667, i64 4
%671 = bitcast float* %670 to <4 x float>*
%672 = load <4 x float>, <4 x float>* %671
%673 = getelementptr inbounds float, float* %623, i64 %666
%674 = bitcast float* %673 to <4 x float>*
store <4 x float> %669, <4 x float>* %674
%675 = getelementptr inbounds float, float* %673, i64 4
%676 = bitcast float* %675 to <4 x float>*
store <4 x float> %672, <4 x float>* %676
%677 = add nuw i64 %632, 32
%678 = add i64 %633, 4
%679 = icmp eq i64 %678, %105
br i1 %679, label %680, label %631
680: ; preds = %631, %630
%681 = phi i64 [ 0, %630 ], [ %677, %631 ]
br i1 %106, label %698, label %682
682: ; preds = %680, %682
%683 = phi i64 [ %695, %682 ], [ %681, %680 ]
%684 = phi i64 [ %696, %682 ], [ 0, %680 ]
%685 = getelementptr inbounds float, float* %12, i64 %683
%686 = bitcast float* %685 to <4 x float>*
%687 = load <4 x float>, <4 x float>* %686
%688 = getelementptr inbounds float, float* %685, i64 4
%689 = bitcast float* %688 to <4 x float>*
%690 = load <4 x float>, <4 x float>* %689
%691 = getelementptr inbounds float, float* %623, i64 %683
%692 = bitcast float* %691 to <4 x float>*
store <4 x float> %687, <4 x float>* %692
%693 = getelementptr inbounds float, float* %691, i64 4
%694 = bitcast float* %693 to <4 x float>*
store <4 x float> %690, <4 x float>* %694
%695 = add nuw i64 %683, 8
%696 = add i64 %684, 1
%697 = icmp eq i64 %696, %103
br i1 %697, label %698, label %682
698: ; preds = %682, %680
br i1 %107, label %1368, label %699
699: ; preds = %624, %621, %698
%700 = phi i64 [ 0, %624 ], [ 0, %621 ], [ %102, %698 ]
%701 = xor i64 %700, -1
%702 = add nsw i64 %701, %24
br i1 %109, label %712, label %703
703: ; preds = %699, %703
%704 = phi i64 [ %709, %703 ], [ %700, %699 ]
%705 = phi i64 [ %710, %703 ], [ 0, %699 ]
%706 = getelementptr inbounds float, float* %12, i64 %704
%707 = load float, float* %706
%708 = getelementptr inbounds float, float* %623, i64 %704
store float %707, float* %708
%709 = add nuw nsw i64 %704, 1
%710 = add i64 %705, 1
%711 = icmp eq i64 %710, %108
br i1 %711, label %712, label %703
712: ; preds = %703, %699
%713 = phi i64 [ %700, %699 ], [ %709, %703 ]
%714 = icmp ult i64 %702, 3
br i1 %714, label %1368, label %715
715: ; preds = %712, %715
%716 = phi i64 [ %732, %715 ], [ %713, %712 ]
%717 = getelementptr inbounds float, float* %12, i64 %716
%718 = load float, float* %717
%719 = getelementptr inbounds float, float* %623, i64 %716
store float %718, float* %719
%720 = add nuw nsw i64 %716, 1
%721 = getelementptr inbounds float, float* %12, i64 %720
%722 = load float, float* %721
%723 = getelementptr inbounds float, float* %623, i64 %720
store float %722, float* %723
%724 = add nuw nsw i64 %716, 2
%725 = getelementptr inbounds float, float* %12, i64 %724
%726 = load float, float* %725
%727 = getelementptr inbounds float, float* %623, i64 %724
store float %726, float* %727
%728 = add nuw nsw i64 %716, 3
%729 = getelementptr inbounds float, float* %12, i64 %728
%730 = load float, float* %729
%731 = getelementptr inbounds float, float* %623, i64 %728
store float %730, float* %731
%732 = add nuw nsw i64 %716, 4
%733 = icmp eq i64 %732, %24
br i1 %733, label %1368, label %715
734: ; preds = %617, %734
%735 = phi i64 [ %751, %734 ], [ %618, %617 ]
%736 = getelementptr inbounds float, float* %9, i64 %735
%737 = load float, float* %736
%738 = getelementptr inbounds float, float* %528, i64 %735
store float %737, float* %738
%739 = add nuw nsw i64 %735, 1
%740 = getelementptr inbounds float, float* %9, i64 %739
%741 = load float, float* %740
%742 = getelementptr inbounds float, float* %528, i64 %739
store float %741, float* %742
%743 = add nuw nsw i64 %735, 2
%744 = getelementptr inbounds float, float* %9, i64 %743
%745 = load float, float* %744
%746 = getelementptr inbounds float, float* %528, i64 %743
store float %745, float* %746
%747 = add nuw nsw i64 %735, 3
%748 = getelementptr inbounds float, float* %9, i64 %747
%749 = load float, float* %748
%750 = getelementptr inbounds float, float* %528, i64 %747
store float %749, float* %750
%751 = add nuw nsw i64 %735, 4
%752 = icmp eq i64 %751, %24
br i1 %752, label %1368, label %734
753: ; preds = %415
%754 = sext i32 %204 to i64
%755 = getelementptr inbounds float, float* %1, i64 %754
%756 = load float, float* %755
%757 = fcmp ult float %416, %756
br i1 %757, label %763, label %858
758: ; preds = %419
%759 = sext i32 %204 to i64
%760 = getelementptr inbounds float, float* %1, i64 %759
%761 = load float, float* %760
%762 = fcmp ult float %420, %761
br i1 %762, label %1368, label %861
763: ; preds = %753
br i1 %20, label %764, label %1368
764: ; preds = %763
%765 = getelementptr inbounds float*, float** %0, i64 %205
%766 = load float*, float** %765
br i1 %151, label %842, label %767
767: ; preds = %764
%768 = getelementptr float, float* %766, i64 %24
%769 = bitcast float* %768 to i8*
%770 = icmp ult float* %766, %29
%771 = icmp ult i8* %10, %769
%772 = and i1 %770, %771
br i1 %772, label %842, label %773
773: ; preds = %767
br i1 %154, label %823, label %774
774: ; preds = %773, %774
%775 = phi i64 [ %820, %774 ], [ 0, %773 ]
%776 = phi i64 [ %821, %774 ], [ 0, %773 ]
%777 = getelementptr inbounds float, float* %9, i64 %775
%778 = bitcast float* %777 to <4 x float>*
%779 = load <4 x float>, <4 x float>* %778
%780 = getelementptr inbounds float, float* %777, i64 4
%781 = bitcast float* %780 to <4 x float>*
%782 = load <4 x float>, <4 x float>* %781
%783 = getelementptr inbounds float, float* %766, i64 %775
%784 = bitcast float* %783 to <4 x float>*
store <4 x float> %779, <4 x float>* %784
%785 = getelementptr inbounds float, float* %783, i64 4
%786 = bitcast float* %785 to <4 x float>*
store <4 x float> %782, <4 x float>* %786
%787 = or i64 %775, 8
%788 = getelementptr inbounds float, float* %9, i64 %787
%789 = bitcast float* %788 to <4 x float>*
%790 = load <4 x float>, <4 x float>* %789
%791 = getelementptr inbounds float, float* %788, i64 4
%792 = bitcast float* %791 to <4 x float>*
%793 = load <4 x float>, <4 x float>* %792
%794 = getelementptr inbounds float, float* %766, i64 %787
%795 = bitcast float* %794 to <4 x float>*
store <4 x float> %790, <4 x float>* %795
%796 = getelementptr inbounds float, float* %794, i64 4
%797 = bitcast float* %796 to <4 x float>*
store <4 x float> %793, <4 x float>* %797
%798 = or i64 %775, 16
%799 = getelementptr inbounds float, float* %9, i64 %798
%800 = bitcast float* %799 to <4 x float>*
%801 = load <4 x float>, <4 x float>* %800
%802 = getelementptr inbounds float, float* %799, i64 4
%803 = bitcast float* %802 to <4 x float>*
%804 = load <4 x float>, <4 x float>* %803
%805 = getelementptr inbounds float, float* %766, i64 %798
%806 = bitcast float* %805 to <4 x float>*
store <4 x float> %801, <4 x float>* %806
%807 = getelementptr inbounds float, float* %805, i64 4
%808 = bitcast float* %807 to <4 x float>*
store <4 x float> %804, <4 x float>* %808
%809 = or i64 %775, 24
%810 = getelementptr inbounds float, float* %9, i64 %809
%811 = bitcast float* %810 to <4 x float>*
%812 = load <4 x float>, <4 x float>* %811
%813 = getelementptr inbounds float, float* %810, i64 4
%814 = bitcast float* %813 to <4 x float>*
%815 = load <4 x float>, <4 x float>* %814
%816 = getelementptr inbounds float, float* %766, i64 %809
%817 = bitcast float* %816 to <4 x float>*
store <4 x float> %812, <4 x float>* %817
%818 = getelementptr inbounds float, float* %816, i64 4
%819 = bitcast float* %818 to <4 x float>*
store <4 x float> %815, <4 x float>* %819
%820 = add nuw i64 %775, 32
%821 = add i64 %776, 4
%822 = icmp eq i64 %821, %155
br i1 %822, label %823, label %774
823: ; preds = %774, %773
%824 = phi i64 [ 0, %773 ], [ %820, %774 ]
br i1 %156, label %841, label %825
825: ; preds = %823, %825
%826 = phi i64 [ %838, %825 ], [ %824, %823 ]
%827 = phi i64 [ %839, %825 ], [ 0, %823 ]
%828 = getelementptr inbounds float, float* %9, i64 %826
%829 = bitcast float* %828 to <4 x float>*
%830 = load <4 x float>, <4 x float>* %829
%831 = getelementptr inbounds float, float* %828, i64 4
%832 = bitcast float* %831 to <4 x float>*
%833 = load <4 x float>, <4 x float>* %832
%834 = getelementptr inbounds float, float* %766, i64 %826
%835 = bitcast float* %834 to <4 x float>*
store <4 x float> %830, <4 x float>* %835
%836 = getelementptr inbounds float, float* %834, i64 4
%837 = bitcast float* %836 to <4 x float>*
store <4 x float> %833, <4 x float>* %837
%838 = add nuw i64 %826, 8
%839 = add i64 %827, 1
%840 = icmp eq i64 %839, %153
br i1 %840, label %841, label %825
841: ; preds = %825, %823
br i1 %157, label %1368, label %842
842: ; preds = %767, %764, %841
%843 = phi i64 [ 0, %767 ], [ 0, %764 ], [ %152, %841 ]
%844 = xor i64 %843, -1
%845 = add nsw i64 %844, %24
br i1 %159, label %855, label %846
846: ; preds = %842, %846
%847 = phi i64 [ %852, %846 ], [ %843, %842 ]
%848 = phi i64 [ %853, %846 ], [ 0, %842 ]
%849 = getelementptr inbounds float, float* %9, i64 %847
%850 = load float, float* %849
%851 = getelementptr inbounds float, float* %766, i64 %847
store float %850, float* %851
%852 = add nuw nsw i64 %847, 1
%853 = add i64 %848, 1
%854 = icmp eq i64 %853, %158
br i1 %854, label %855, label %846
855: ; preds = %846, %842
%856 = phi i64 [ %843, %842 ], [ %852, %846 ]
%857 = icmp ult i64 %845, 3
br i1 %857, label %1368, label %1349
858: ; preds = %753
%859 = load float, float* %206
%860 = fcmp olt float %416, %859
br i1 %860, label %864, label %980
861: ; preds = %758
%862 = load float, float* %206
%863 = fcmp olt float %420, %862
br i1 %863, label %978, label %1085
864: ; preds = %858
br i1 %20, label %865, label %978
865: ; preds = %864
%866 = getelementptr inbounds float*, float** %0, i64 %205
%867 = load float*, float** %866
br i1 %110, label %943, label %868
868: ; preds = %865
%869 = getelementptr float, float* %867, i64 %24
%870 = bitcast float* %869 to i8*
%871 = icmp ult float* %867, %36
%872 = icmp ult i8* %10, %870
%873 = and i1 %871, %872
br i1 %873, label %943, label %874
874: ; preds = %868
br i1 %113, label %924, label %875
875: ; preds = %874, %875
%876 = phi i64 [ %921, %875 ], [ 0, %874 ]
%877 = phi i64 [ %922, %875 ], [ 0, %874 ]
%878 = getelementptr inbounds float, float* %9, i64 %876
%879 = bitcast float* %878 to <4 x float>*
%880 = load <4 x float>, <4 x float>* %879
%881 = getelementptr inbounds float, float* %878, i64 4
%882 = bitcast float* %881 to <4 x float>*
%883 = load <4 x float>, <4 x float>* %882
%884 = getelementptr inbounds float, float* %867, i64 %876
%885 = bitcast float* %884 to <4 x float>*
store <4 x float> %880, <4 x float>* %885
%886 = getelementptr inbounds float, float* %884, i64 4
%887 = bitcast float* %886 to <4 x float>*
store <4 x float> %883, <4 x float>* %887
%888 = or i64 %876, 8
%889 = getelementptr inbounds float, float* %9, i64 %888
%890 = bitcast float* %889 to <4 x float>*
%891 = load <4 x float>, <4 x float>* %890
%892 = getelementptr inbounds float, float* %889, i64 4
%893 = bitcast float* %892 to <4 x float>*
%894 = load <4 x float>, <4 x float>* %893
%895 = getelementptr inbounds float, float* %867, i64 %888
%896 = bitcast float* %895 to <4 x float>*
store <4 x float> %891, <4 x float>* %896
%897 = getelementptr inbounds float, float* %895, i64 4
%898 = bitcast float* %897 to <4 x float>*
store <4 x float> %894, <4 x float>* %898
%899 = or i64 %876, 16
%900 = getelementptr inbounds float, float* %9, i64 %899
%901 = bitcast float* %900 to <4 x float>*
%902 = load <4 x float>, <4 x float>* %901
%903 = getelementptr inbounds float, float* %900, i64 4
%904 = bitcast float* %903 to <4 x float>*
%905 = load <4 x float>, <4 x float>* %904
%906 = getelementptr inbounds float, float* %867, i64 %899
%907 = bitcast float* %906 to <4 x float>*
store <4 x float> %902, <4 x float>* %907
%908 = getelementptr inbounds float, float* %906, i64 4
%909 = bitcast float* %908 to <4 x float>*
store <4 x float> %905, <4 x float>* %909
%910 = or i64 %876, 24
%911 = getelementptr inbounds float, float* %9, i64 %910
%912 = bitcast float* %911 to <4 x float>*
%913 = load <4 x float>, <4 x float>* %912
%914 = getelementptr inbounds float, float* %911, i64 4
%915 = bitcast float* %914 to <4 x float>*
%916 = load <4 x float>, <4 x float>* %915
%917 = getelementptr inbounds float, float* %867, i64 %910
%918 = bitcast float* %917 to <4 x float>*
store <4 x float> %913, <4 x float>* %918
%919 = getelementptr inbounds float, float* %917, i64 4
%920 = bitcast float* %919 to <4 x float>*
store <4 x float> %916, <4 x float>* %920
%921 = add nuw i64 %876, 32
%922 = add i64 %877, 4
%923 = icmp eq i64 %922, %114
br i1 %923, label %924, label %875
924: ; preds = %875, %874
%925 = phi i64 [ 0, %874 ], [ %921, %875 ]
br i1 %115, label %942, label %926
926: ; preds = %924, %926
%927 = phi i64 [ %939, %926 ], [ %925, %924 ]
%928 = phi i64 [ %940, %926 ], [ 0, %924 ]
%929 = getelementptr inbounds float, float* %9, i64 %927
%930 = bitcast float* %929 to <4 x float>*
%931 = load <4 x float>, <4 x float>* %930
%932 = getelementptr inbounds float, float* %929, i64 4
%933 = bitcast float* %932 to <4 x float>*
%934 = load <4 x float>, <4 x float>* %933
%935 = getelementptr inbounds float, float* %867, i64 %927
%936 = bitcast float* %935 to <4 x float>*
store <4 x float> %931, <4 x float>* %936
%937 = getelementptr inbounds float, float* %935, i64 4
%938 = bitcast float* %937 to <4 x float>*
store <4 x float> %934, <4 x float>* %938
%939 = add nuw i64 %927, 8
%940 = add i64 %928, 1
%941 = icmp eq i64 %940, %112
br i1 %941, label %942, label %926
942: ; preds = %926, %924
br i1 %116, label %978, label %943
943: ; preds = %868, %865, %942
%944 = phi i64 [ 0, %868 ], [ 0, %865 ], [ %111, %942 ]
%945 = xor i64 %944, -1
%946 = add nsw i64 %945, %24
br i1 %118, label %956, label %947
947: ; preds = %943, %947
%948 = phi i64 [ %953, %947 ], [ %944, %943 ]
%949 = phi i64 [ %954, %947 ], [ 0, %943 ]
%950 = getelementptr inbounds float, float* %9, i64 %948
%951 = load float, float* %950
%952 = getelementptr inbounds float, float* %867, i64 %948
store float %951, float* %952
%953 = add nuw nsw i64 %948, 1
%954 = add i64 %949, 1
%955 = icmp eq i64 %954, %117
br i1 %955, label %956, label %947
956: ; preds = %947, %943
%957 = phi i64 [ %944, %943 ], [ %953, %947 ]
%958 = icmp ult i64 %946, 3
br i1 %958, label %978, label %959
959: ; preds = %956, %959
%960 = phi i64 [ %976, %959 ], [ %957, %956 ]
%961 = getelementptr inbounds float, float* %9, i64 %960
%962 = load float, float* %961
%963 = getelementptr inbounds float, float* %867, i64 %960
store float %962, float* %963
%964 = add nuw nsw i64 %960, 1
%965 = getelementptr inbounds float, float* %9, i64 %964
%966 = load float, float* %965
%967 = getelementptr inbounds float, float* %867, i64 %964
store float %966, float* %967
%968 = add nuw nsw i64 %960, 2
%969 = getelementptr inbounds float, float* %9, i64 %968
%970 = load float, float* %969
%971 = getelementptr inbounds float, float* %867, i64 %968
store float %970, float* %971
%972 = add nuw nsw i64 %960, 3
%973 = getelementptr inbounds float, float* %9, i64 %972
%974 = load float, float* %973
%975 = getelementptr inbounds float, float* %867, i64 %972
store float %974, float* %975
%976 = add nuw nsw i64 %960, 4
%977 = icmp eq i64 %976, %24
br i1 %977, label %978, label %959
978: ; preds = %956, %959, %942, %861, %864
%979 = phi float [ %416, %864 ], [ %420, %861 ], [ %416, %942 ], [ %416, %959 ], [ %416, %956 ]
store float %979, float* %206
br label %980
980: ; preds = %978, %858
br i1 %20, label %981, label %1085
981: ; preds = %980
%982 = getelementptr inbounds float*, float** %0, i64 %205
%983 = load float*, float** %982
br i1 %119, label %1042, label %984
984: ; preds = %981
%985 = getelementptr float, float* %983, i64 %24
%986 = bitcast float* %985 to i8*
%987 = icmp ult i8* %13, %986
%988 = icmp ult float* %983, %32
%989 = and i1 %987, %988
%990 = or i1 %989, %122
br i1 %990, label %1042, label %991
991: ; preds = %984
br i1 %125, label %1025, label %992
992: ; preds = %991, %992
%993 = phi i64 [ %1022, %992 ], [ 0, %991 ]
%994 = phi i64 [ %1023, %992 ], [ 0, %991 ]
%995 = getelementptr inbounds float, float* %983, i64 %993
%996 = bitcast float* %995 to <4 x float>*
%997 = load <4 x float>, <4 x float>* %996
%998 = fpext <4 x float> %997 to <4 x double>
%999 = getelementptr inbounds float, float* %15, i64 %993
%1000 = bitcast float* %999 to <4 x float>*
%1001 = load <4 x float>, <4 x float>* %1000
%1002 = fpext <4 x float> %1001 to <4 x double>
%1003 = fmul <4 x double> %1002, <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>
%1004 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %998, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> %1003)
%1005 = fptrunc <4 x double> %1004 to <4 x float>
%1006 = getelementptr inbounds float, float* %12, i64 %993
%1007 = bitcast float* %1006 to <4 x float>*
store <4 x float> %1005, <4 x float>* %1007
%1008 = or i64 %993, 4
%1009 = getelementptr inbounds float, float* %983, i64 %1008
%1010 = bitcast float* %1009 to <4 x float>*
%1011 = load <4 x float>, <4 x float>* %1010
%1012 = fpext <4 x float> %1011 to <4 x double>
%1013 = getelementptr inbounds float, float* %15, i64 %1008
%1014 = bitcast float* %1013 to <4 x float>*
%1015 = load <4 x float>, <4 x float>* %1014
%1016 = fpext <4 x float> %1015 to <4 x double>
%1017 = fmul <4 x double> %1016, <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>
%1018 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %1012, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> %1017)
%1019 = fptrunc <4 x double> %1018 to <4 x float>
%1020 = getelementptr inbounds float, float* %12, i64 %1008
%1021 = bitcast float* %1020 to <4 x float>*
store <4 x float> %1019, <4 x float>* %1021
%1022 = add nuw i64 %993, 8
%1023 = add i64 %994, 2
%1024 = icmp eq i64 %1023, %126
br i1 %1024, label %1025, label %992
1025: ; preds = %992, %991
%1026 = phi i64 [ 0, %991 ], [ %1022, %992 ]
br i1 %127, label %1041, label %1027
1027: ; preds = %1025
%1028 = getelementptr inbounds float, float* %983, i64 %1026
%1029 = bitcast float* %1028 to <4 x float>*
%1030 = load <4 x float>, <4 x float>* %1029
%1031 = fpext <4 x float> %1030 to <4 x double>
%1032 = getelementptr inbounds float, float* %15, i64 %1026
%1033 = bitcast float* %1032 to <4 x float>*
%1034 = load <4 x float>, <4 x float>* %1033
%1035 = fpext <4 x float> %1034 to <4 x double>
%1036 = fmul <4 x double> %1035, <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>
%1037 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %1031, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> %1036)
%1038 = fptrunc <4 x double> %1037 to <4 x float>
%1039 = getelementptr inbounds float, float* %12, i64 %1026
%1040 = bitcast float* %1039 to <4 x float>*
store <4 x float> %1038, <4 x float>* %1040
br label %1041
1041: ; preds = %1025, %1027
br i1 %128, label %1085, label %1042
1042: ; preds = %984, %981, %1041
%1043 = phi i64 [ 0, %984 ], [ 0, %981 ], [ %123, %1041 ]
%1044 = xor i64 %1043, -1
br i1 %130, label %1057, label %1045
1045: ; preds = %1042
%1046 = getelementptr inbounds float, float* %983, i64 %1043
%1047 = load float, float* %1046
%1048 = fpext float %1047 to double
%1049 = getelementptr inbounds float, float* %15, i64 %1043
%1050 = load float, float* %1049
%1051 = fpext float %1050 to double
%1052 = fmul double %1051, 5.000000e-01
%1053 = tail call double @llvm.fmuladd.f64(double %1048, double 5.000000e-01, double %1052)
%1054 = fptrunc double %1053 to float
%1055 = getelementptr inbounds float, float* %12, i64 %1043
store float %1054, float* %1055
%1056 = or i64 %1043, 1
br label %1057
1057: ; preds = %1045, %1042
%1058 = phi i64 [ %1043, %1042 ], [ %1056, %1045 ]
%1059 = icmp eq i64 %1044, %131
br i1 %1059, label %1085, label %1060
1060: ; preds = %1057, %1060
%1061 = phi i64 [ %1083, %1060 ], [ %1058, %1057 ]
%1062 = getelementptr inbounds float, float* %983, i64 %1061
%1063 = load float, float* %1062
%1064 = fpext float %1063 to double
%1065 = getelementptr inbounds float, float* %15, i64 %1061
%1066 = load float, float* %1065
%1067 = fpext float %1066 to double
%1068 = fmul double %1067, 5.000000e-01
%1069 = tail call double @llvm.fmuladd.f64(double %1064, double 5.000000e-01, double %1068)
%1070 = fptrunc double %1069 to float
%1071 = getelementptr inbounds float, float* %12, i64 %1061
store float %1070, float* %1071
%1072 = add nuw nsw i64 %1061, 1
%1073 = getelementptr inbounds float, float* %983, i64 %1072
%1074 = load float, float* %1073
%1075 = fpext float %1074 to double
%1076 = getelementptr inbounds float, float* %15, i64 %1072
%1077 = load float, float* %1076
%1078 = fpext float %1077 to double
%1079 = fmul double %1078, 5.000000e-01
%1080 = tail call double @llvm.fmuladd.f64(double %1075, double 5.000000e-01, double %1079)
%1081 = fptrunc double %1080 to float
%1082 = getelementptr inbounds float, float* %12, i64 %1072
store float %1081, float* %1082
%1083 = add nuw nsw i64 %1061, 2
%1084 = icmp eq i64 %1083, %24
br i1 %1084, label %1085, label %1060
1085: ; preds = %1057, %1060, %1041, %861, %980
%1086 = tail call float @solve_model(float* %12, i8* %5, i32* %6)
%1087 = load float, float* %206
%1088 = fcmp olt float %1086, %1087
br i1 %1088, label %1093, label %1089
1089: ; preds = %1085
br i1 %19, label %1370, label %1090
1090: ; preds = %1089
%1091 = getelementptr inbounds float*, float** %0, i64 %209
%1092 = zext i32 %203 to i64
br label %1207
1093: ; preds = %1085
br i1 %20, label %1094, label %1368
1094: ; preds = %1093
%1095 = getelementptr inbounds float*, float** %0, i64 %205
%1096 = load float*, float** %1095
br i1 %142, label %1172, label %1097
1097: ; preds = %1094
%1098 = getelementptr float, float* %1096, i64 %24
%1099 = bitcast float* %1098 to i8*
%1100 = icmp ult float* %1096, %30
%1101 = icmp ult i8* %13, %1099
%1102 = and i1 %1100, %1101
br i1 %1102, label %1172, label %1103
1103: ; preds = %1097
br i1 %145, label %1153, label %1104
1104: ; preds = %1103, %1104
%1105 = phi i64 [ %1150, %1104 ], [ 0, %1103 ]
%1106 = phi i64 [ %1151, %1104 ], [ 0, %1103 ]
%1107 = getelementptr inbounds float, float* %12, i64 %1105
%1108 = bitcast float* %1107 to <4 x float>*
%1109 = load <4 x float>, <4 x float>* %1108
%1110 = getelementptr inbounds float, float* %1107, i64 4
%1111 = bitcast float* %1110 to <4 x float>*
%1112 = load <4 x float>, <4 x float>* %1111
%1113 = getelementptr inbounds float, float* %1096, i64 %1105
%1114 = bitcast float* %1113 to <4 x float>*
store <4 x float> %1109, <4 x float>* %1114
%1115 = getelementptr inbounds float, float* %1113, i64 4
%1116 = bitcast float* %1115 to <4 x float>*
store <4 x float> %1112, <4 x float>* %1116
%1117 = or i64 %1105, 8
%1118 = getelementptr inbounds float, float* %12, i64 %1117
%1119 = bitcast float* %1118 to <4 x float>*
%1120 = load <4 x float>, <4 x float>* %1119
%1121 = getelementptr inbounds float, float* %1118, i64 4
%1122 = bitcast float* %1121 to <4 x float>*
%1123 = load <4 x float>, <4 x float>* %1122
%1124 = getelementptr inbounds float, float* %1096, i64 %1117
%1125 = bitcast float* %1124 to <4 x float>*
store <4 x float> %1120, <4 x float>* %1125
%1126 = getelementptr inbounds float, float* %1124, i64 4
%1127 = bitcast float* %1126 to <4 x float>*
store <4 x float> %1123, <4 x float>* %1127
%1128 = or i64 %1105, 16
%1129 = getelementptr inbounds float, float* %12, i64 %1128
%1130 = bitcast float* %1129 to <4 x float>*
%1131 = load <4 x float>, <4 x float>* %1130
%1132 = getelementptr inbounds float, float* %1129, i64 4
%1133 = bitcast float* %1132 to <4 x float>*
%1134 = load <4 x float>, <4 x float>* %1133
%1135 = getelementptr inbounds float, float* %1096, i64 %1128
%1136 = bitcast float* %1135 to <4 x float>*
store <4 x float> %1131, <4 x float>* %1136
%1137 = getelementptr inbounds float, float* %1135, i64 4
%1138 = bitcast float* %1137 to <4 x float>*
store <4 x float> %1134, <4 x float>* %1138
%1139 = or i64 %1105, 24
%1140 = getelementptr inbounds float, float* %12, i64 %1139
%1141 = bitcast float* %1140 to <4 x float>*
%1142 = load <4 x float>, <4 x float>* %1141
%1143 = getelementptr inbounds float, float* %1140, i64 4
%1144 = bitcast float* %1143 to <4 x float>*
%1145 = load <4 x float>, <4 x float>* %1144
%1146 = getelementptr inbounds float, float* %1096, i64 %1139
%1147 = bitcast float* %1146 to <4 x float>*
store <4 x float> %1142, <4 x float>* %1147
%1148 = getelementptr inbounds float, float* %1146, i64 4
%1149 = bitcast float* %1148 to <4 x float>*
store <4 x float> %1145, <4 x float>* %1149
%1150 = add nuw i64 %1105, 32
%1151 = add i64 %1106, 4
%1152 = icmp eq i64 %1151, %146
br i1 %1152, label %1153, label %1104
1153: ; preds = %1104, %1103
%1154 = phi i64 [ 0, %1103 ], [ %1150, %1104 ]
br i1 %147, label %1171, label %1155
1155: ; preds = %1153, %1155
%1156 = phi i64 [ %1168, %1155 ], [ %1154, %1153 ]
%1157 = phi i64 [ %1169, %1155 ], [ 0, %1153 ]
%1158 = getelementptr inbounds float, float* %12, i64 %1156
%1159 = bitcast float* %1158 to <4 x float>*
%1160 = load <4 x float>, <4 x float>* %1159
%1161 = getelementptr inbounds float, float* %1158, i64 4
%1162 = bitcast float* %1161 to <4 x float>*
%1163 = load <4 x float>, <4 x float>* %1162
%1164 = getelementptr inbounds float, float* %1096, i64 %1156
%1165 = bitcast float* %1164 to <4 x float>*
store <4 x float> %1160, <4 x float>* %1165
%1166 = getelementptr inbounds float, float* %1164, i64 4
%1167 = bitcast float* %1166 to <4 x float>*
store <4 x float> %1163, <4 x float>* %1167
%1168 = add nuw i64 %1156, 8
%1169 = add i64 %1157, 1
%1170 = icmp eq i64 %1169, %144
br i1 %1170, label %1171, label %1155
1171: ; preds = %1155, %1153
br i1 %148, label %1368, label %1172
1172: ; preds = %1097, %1094, %1171
%1173 = phi i64 [ 0, %1097 ], [ 0, %1094 ], [ %143, %1171 ]
%1174 = xor i64 %1173, -1
%1175 = add nsw i64 %1174, %24
br i1 %150, label %1185, label %1176
1176: ; preds = %1172, %1176
%1177 = phi i64 [ %1182, %1176 ], [ %1173, %1172 ]
%1178 = phi i64 [ %1183, %1176 ], [ 0, %1172 ]
%1179 = getelementptr inbounds float, float* %12, i64 %1177
%1180 = load float, float* %1179
%1181 = getelementptr inbounds float, float* %1096, i64 %1177
store float %1180, float* %1181
%1182 = add nuw nsw i64 %1177, 1
%1183 = add i64 %1178, 1
%1184 = icmp eq i64 %1183, %149
br i1 %1184, label %1185, label %1176
1185: ; preds = %1176, %1172
%1186 = phi i64 [ %1173, %1172 ], [ %1182, %1176 ]
%1187 = icmp ult i64 %1175, 3
br i1 %1187, label %1368, label %1188
1188: ; preds = %1185, %1188
%1189 = phi i64 [ %1205, %1188 ], [ %1186, %1185 ]
%1190 = getelementptr inbounds float, float* %12, i64 %1189
%1191 = load float, float* %1190
%1192 = getelementptr inbounds float, float* %1096, i64 %1189
store float %1191, float* %1192
%1193 = add nuw nsw i64 %1189, 1
%1194 = getelementptr inbounds float, float* %12, i64 %1193
%1195 = load float, float* %1194
%1196 = getelementptr inbounds float, float* %1096, i64 %1193
store float %1195, float* %1196
%1197 = add nuw nsw i64 %1189, 2
%1198 = getelementptr inbounds float, float* %12, i64 %1197
%1199 = load float, float* %1198
%1200 = getelementptr inbounds float, float* %1096, i64 %1197
store float %1199, float* %1200
%1201 = add nuw nsw i64 %1189, 3
%1202 = getelementptr inbounds float, float* %12, i64 %1201
%1203 = load float, float* %1202
%1204 = getelementptr inbounds float, float* %1096, i64 %1201
store float %1203, float* %1204
%1205 = add nuw nsw i64 %1189, 4
%1206 = icmp eq i64 %1205, %24
br i1 %1206, label %1368, label %1188
1207: ; preds = %1090, %1346
%1208 = phi i64 [ 0, %1090 ], [ %1347, %1346 ]
%1209 = icmp eq i64 %1208, %1092
br i1 %1209, label %1346, label %1210
1210: ; preds = %1207
br i1 %20, label %1211, label %1343
1211: ; preds = %1210
%1212 = getelementptr inbounds float*, float** %0, i64 %1208
%1213 = load float*, float** %1212
%1214 = load float*, float** %1091
br i1 %132, label %1309, label %1215
1215: ; preds = %1211
%1216 = getelementptr float, float* %1213, i64 %24
%1217 = bitcast float* %1216 to i8*
%1218 = getelementptr float, float* %1214, i64 %24
%1219 = bitcast float* %1218 to i8*
%1220 = icmp ult i8* %10, %1217
%1221 = icmp ult float* %1213, %31
%1222 = and i1 %1220, %1221
%1223 = icmp ult i8* %10, %1219
%1224 = icmp ult float* %1214, %31
%1225 = and i1 %1223, %1224
%1226 = or i1 %1222, %1225
%1227 = icmp ult float* %1213, %1218
%1228 = icmp ult float* %1214, %1216
%1229 = and i1 %1227, %1228
%1230 = or i1 %1226, %1229
br i1 %1230, label %1309, label %1231
1231: ; preds = %1215
br i1 %135, label %1283, label %1232
1232: ; preds = %1231, %1232
%1233 = phi i64 [ %1280, %1232 ], [ 0, %1231 ]
%1234 = phi i64 [ %1281, %1232 ], [ 0, %1231 ]
%1235 = getelementptr inbounds float, float* %1213, i64 %1233
%1236 = bitcast float* %1235 to <4 x float>*
%1237 = load <4 x float>, <4 x float>* %1236
%1238 = getelementptr inbounds float, float* %1235, i64 4
%1239 = bitcast float* %1238 to <4 x float>*
%1240 = load <4 x float>, <4 x float>* %1239
%1241 = getelementptr inbounds float, float* %1214, i64 %1233
%1242 = bitcast float* %1241 to <4 x float>*
%1243 = load <4 x float>, <4 x float>* %1242
%1244 = getelementptr inbounds float, float* %1241, i64 4
%1245 = bitcast float* %1244 to <4 x float>*
%1246 = load <4 x float>, <4 x float>* %1245
%1247 = fadd <4 x float> %1237, %1243
%1248 = fadd <4 x float> %1240, %1246
%1249 = fmul <4 x float> %1247, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1250 = fmul <4 x float> %1248, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1251 = getelementptr inbounds float, float* %9, i64 %1233
%1252 = bitcast float* %1251 to <4 x float>*
store <4 x float> %1249, <4 x float>* %1252
%1253 = getelementptr inbounds float, float* %1251, i64 4
%1254 = bitcast float* %1253 to <4 x float>*
store <4 x float> %1250, <4 x float>* %1254
%1255 = bitcast float* %1235 to <4 x float>*
store <4 x float> %1249, <4 x float>* %1255
%1256 = bitcast float* %1238 to <4 x float>*
store <4 x float> %1250, <4 x float>* %1256
%1257 = or i64 %1233, 8
%1258 = getelementptr inbounds float, float* %1213, i64 %1257
%1259 = bitcast float* %1258 to <4 x float>*
%1260 = load <4 x float>, <4 x float>* %1259
%1261 = getelementptr inbounds float, float* %1258, i64 4
%1262 = bitcast float* %1261 to <4 x float>*
%1263 = load <4 x float>, <4 x float>* %1262
%1264 = getelementptr inbounds float, float* %1214, i64 %1257
%1265 = bitcast float* %1264 to <4 x float>*
%1266 = load <4 x float>, <4 x float>* %1265
%1267 = getelementptr inbounds float, float* %1264, i64 4
%1268 = bitcast float* %1267 to <4 x float>*
%1269 = load <4 x float>, <4 x float>* %1268
%1270 = fadd <4 x float> %1260, %1266
%1271 = fadd <4 x float> %1263, %1269
%1272 = fmul <4 x float> %1270, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1273 = fmul <4 x float> %1271, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1274 = getelementptr inbounds float, float* %9, i64 %1257
%1275 = bitcast float* %1274 to <4 x float>*
store <4 x float> %1272, <4 x float>* %1275
%1276 = getelementptr inbounds float, float* %1274, i64 4
%1277 = bitcast float* %1276 to <4 x float>*
store <4 x float> %1273, <4 x float>* %1277
%1278 = bitcast float* %1258 to <4 x float>*
store <4 x float> %1272, <4 x float>* %1278
%1279 = bitcast float* %1261 to <4 x float>*
store <4 x float> %1273, <4 x float>* %1279
%1280 = add nuw i64 %1233, 16
%1281 = add i64 %1234, 2
%1282 = icmp eq i64 %1281, %136
br i1 %1282, label %1283, label %1232
1283: ; preds = %1232, %1231
%1284 = phi i64 [ 0, %1231 ], [ %1280, %1232 ]
br i1 %137, label %1308, label %1285
1285: ; preds = %1283
%1286 = getelementptr inbounds float, float* %1213, i64 %1284
%1287 = bitcast float* %1286 to <4 x float>*
%1288 = load <4 x float>, <4 x float>* %1287
%1289 = getelementptr inbounds float, float* %1286, i64 4
%1290 = bitcast float* %1289 to <4 x float>*
%1291 = load <4 x float>, <4 x float>* %1290
%1292 = getelementptr inbounds float, float* %1214, i64 %1284
%1293 = bitcast float* %1292 to <4 x float>*
%1294 = load <4 x float>, <4 x float>* %1293
%1295 = getelementptr inbounds float, float* %1292, i64 4
%1296 = bitcast float* %1295 to <4 x float>*
%1297 = load <4 x float>, <4 x float>* %1296
%1298 = fadd <4 x float> %1288, %1294
%1299 = fadd <4 x float> %1291, %1297
%1300 = fmul <4 x float> %1298, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1301 = fmul <4 x float> %1299, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%1302 = getelementptr inbounds float, float* %9, i64 %1284
%1303 = bitcast float* %1302 to <4 x float>*
store <4 x float> %1300, <4 x float>* %1303
%1304 = getelementptr inbounds float, float* %1302, i64 4
%1305 = bitcast float* %1304 to <4 x float>*
store <4 x float> %1301, <4 x float>* %1305
%1306 = bitcast float* %1286 to <4 x float>*
store <4 x float> %1300, <4 x float>* %1306
%1307 = bitcast float* %1289 to <4 x float>*
store <4 x float> %1301, <4 x float>* %1307
br label %1308
1308: ; preds = %1283, %1285
br i1 %138, label %1343, label %1309
1309: ; preds = %1215, %1211, %1308
%1310 = phi i64 [ 0, %1215 ], [ 0, %1211 ], [ %133, %1308 ]
%1311 = xor i64 %1310, -1
br i1 %140, label %1321, label %1312
1312: ; preds = %1309
%1313 = getelementptr inbounds float, float* %1213, i64 %1310
%1314 = load float, float* %1313
%1315 = getelementptr inbounds float, float* %1214, i64 %1310
%1316 = load float, float* %1315
%1317 = fadd float %1314, %1316
%1318 = fmul float %1317, 5.000000e-01
%1319 = getelementptr inbounds float, float* %9, i64 %1310
store float %1318, float* %1319
store float %1318, float* %1313
%1320 = or i64 %1310, 1
br label %1321
1321: ; preds = %1312, %1309
%1322 = phi i64 [ %1310, %1309 ], [ %1320, %1312 ]
%1323 = icmp eq i64 %1311, %141
br i1 %1323, label %1343, label %1324
1324: ; preds = %1321, %1324
%1325 = phi i64 [ %1341, %1324 ], [ %1322, %1321 ]
%1326 = getelementptr inbounds float, float* %1213, i64 %1325
%1327 = load float, float* %1326
%1328 = getelementptr inbounds float, float* %1214, i64 %1325
%1329 = load float, float* %1328
%1330 = fadd float %1327, %1329
%1331 = fmul float %1330, 5.000000e-01
%1332 = getelementptr inbounds float, float* %9, i64 %1325
store float %1331, float* %1332
store float %1331, float* %1326
%1333 = add nuw nsw i64 %1325, 1
%1334 = getelementptr inbounds float, float* %1213, i64 %1333
%1335 = load float, float* %1334
%1336 = getelementptr inbounds float, float* %1214, i64 %1333
%1337 = load float, float* %1336
%1338 = fadd float %1335, %1337
%1339 = fmul float %1338, 5.000000e-01
%1340 = getelementptr inbounds float, float* %9, i64 %1333
store float %1339, float* %1340
store float %1339, float* %1334
%1341 = add nuw nsw i64 %1325, 2
%1342 = icmp eq i64 %1341, %24
br i1 %1342, label %1343, label %1324
1343: ; preds = %1321, %1324, %1308, %1210
%1344 = tail call float @solve_model(float* %9, i8* %5, i32* %6)
%1345 = getelementptr inbounds float, float* %1, i64 %1208
store float %1344, float* %1345
br label %1346
1346: ; preds = %1207, %1343
%1347 = add nuw nsw i64 %1208, 1
%1348 = icmp eq i64 %1347, %28
br i1 %1348, label %1370, label %1207
1349: ; preds = %855, %1349
%1350 = phi i64 [ %1366, %1349 ], [ %856, %855 ]
%1351 = getelementptr inbounds float, float* %9, i64 %1350
%1352 = load float, float* %1351
%1353 = getelementptr inbounds float, float* %766, i64 %1350
store float %1352, float* %1353
%1354 = add nuw nsw i64 %1350, 1
%1355 = getelementptr inbounds float, float* %9, i64 %1354
%1356 = load float, float* %1355
%1357 = getelementptr inbounds float, float* %766, i64 %1354
store float %1356, float* %1357
%1358 = add nuw nsw i64 %1350, 2
%1359 = getelementptr inbounds float, float* %9, i64 %1358
%1360 = load float, float* %1359
%1361 = getelementptr inbounds float, float* %766, i64 %1358
store float %1360, float* %1361
%1362 = add nuw nsw i64 %1350, 3
%1363 = getelementptr inbounds float, float* %9, i64 %1362
%1364 = load float, float* %1363
%1365 = getelementptr inbounds float, float* %766, i64 %1362
store float %1364, float* %1365
%1366 = add nuw nsw i64 %1350, 4
%1367 = icmp eq i64 %1366, %24
br i1 %1367, label %1368, label %1349
1368: ; preds = %617, %734, %712, %715, %1185, %1188, %855, %1349, %603, %698, %1171, %841, %763, %758, %1093, %525, %620
%1369 = phi float [ %522, %620 ], [ %521, %525 ], [ %1086, %1093 ], [ %416, %763 ], [ %420, %758 ], [ %416, %841 ], [ %1086, %1171 ], [ %522, %698 ], [ %521, %603 ], [ %416, %1349 ], [ %416, %855 ], [ %1086, %1188 ], [ %1086, %1185 ], [ %522, %715 ], [ %522, %712 ], [ %521, %734 ], [ %521, %617 ]
store float %1369, float* %206
br label %1370
1370: ; preds = %1346, %1368, %1089
br label %160
1371: ; preds = %228
%1372 = inttoptr i64 %14 to i8*
%1373 = tail call i32 @free(i8* %1372)
%1374 = inttoptr i64 %11 to i8*
%1375 = tail call i32 @free(i8* %1374)
%1376 = inttoptr i64 %8 to i8*
%1377 = tail call i32 @free(i8* %1376)
ret void
}