#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double *allocateDoubleVector(int);
short *allocateShortVector(int);
int /*<<< orphan*/ calcCentroid(double **, int, double *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ freeDoubleVector(double *);
int /*<<< orphan*/ freeShortVector(short *);
double merit_function(double *, double *, double *, int,
                      double (*)(double *, double));
int pow(double, double);
int /*<<< orphan*/ repositionSimplex(short *, double **, int);
int /*<<< orphan*/ sortSimplex(double *, int, short *);
double sqrt(double);
int /*<<< orphan*/ stdout;
double simplex_fit(double **x, int n, double *k, double *y, int num,
                   double (*f)(double *, double)) {
  double *xm, *xr, *xe, *xc, *fx, tol = 1e6, fr, fe, fc, fmin, m;
  double alpha = 1, beta = 2, gamma = 0.5, delta = 0.5;
  int i, j, iters = 0;
  short int *xpos;
  xpos = allocateShortVector(n + 1);
  fx = allocateDoubleVector(n + 1);
  xm = allocateDoubleVector(n);
  xr = allocateDoubleVector(n);
  xe = allocateDoubleVector(n);
  xc = allocateDoubleVector(n);
  while (iters < 200 && tol > 1e-4) {
    for (i = 0; i < n + 1; i++) {
      fx[i] = merit_function(x[i], k, y, num, f);
      xpos[i] = i;
    }
    sortSimplex(fx, n + 1, xpos);
    repositionSimplex(xpos, x, n);
    calcCentroid(x, n, xm);
    fprintf(stdout, "Iteration %d: \n", iters);
    for (i = 0; i < n + 1; i++) {
      for (j = 0; j < n; j++) {
        fprintf(stdout, "%f ", x[i][j]);
      }
      fprintf(stdout, "%f %f\n", fx[i], tol);
    }
    for (i = 0; i < n; i++)
      xr[i] = xm[i] + alpha * (xm[i] - x[n][i]);
    fr = merit_function(xr, k, y, num, f);
    if (fx[0] <= fr && fr < fx[n - 1]) {
      for (i = 0; i < n; i++)
        x[n][i] = xr[i];
    } else if (fr < fx[0]) {
      for (i = 0; i < n; i++)
        xe[i] = xm[i] + beta * (xr[i] - xm[i]);
      fe = merit_function(xe, k, y, num, f);
      if (fe < fx[n - 1]) {
        for (i = 0; i < n; i++)
          x[n][i] = xe[i];
      } else {
        for (i = 0; i < n; i++)
          x[n][i] = xr[i];
      }
    } else {
      for (i = 0; i < n; i++)
        xc[i] = xm[i] + gamma * (x[n][i] - xm[i]);
      fc = merit_function(xc, k, y, num, f);
      if (fc <= fr) {
        for (i = 0; i < n; i++)
          x[n][i] = xc[i];
      } else {
        for (j = 1; j < n + 1; j++)
          for (i = 0; i < n; i++)
            x[j][i] = x[0][i] + delta * (x[j][i] - x[0][i]);
      }
    }
    m = 0.0;
    for (i = 0; i < n + 1; i++)
      m += fx[i];
    m = m / (n + 1);
    tol = 0.0;
    for (i = 0; i < n + 1; i++)
      tol += pow((fx[i] - m), 2.0) / (n);
    tol = sqrt(tol);
    iters++;
  }
  fmin = fx[0];
  fprintf(stdout, "Minimum\n");
  for (i = 0; i < n; i++)
    fprintf(stdout, "%f ", x[0][i]);
  fprintf(stdout, "%f\n", fmin);
  fprintf(stdout, "Iterations: %d\n", iters);
  freeShortVector(xpos);
  freeDoubleVector(xe);
  freeDoubleVector(xc);
  freeDoubleVector(xr);
  freeDoubleVector(xm);
  freeDoubleVector(fx);
  return fmin;
}


x86 assembly (clang, -O0):
<simplex_fit>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movsd  0xe3e(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xe29(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe11(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xdf9(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xde9(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0xb4(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
call   1060 <allocateShortVector@plt>
mov    %rax,-0xc0(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,-0x50(%rbp)
xor    %eax,%eax
cmpl   $0xc8,-0xb4(%rbp)
mov    %al,-0xc1(%rbp)
jge    12ac <simplex_fit+0xfc>
movsd  -0x60(%rbp),%xmm0
movsd  0xd81(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
test   $0x1,%al
jne    12bf <simplex_fit+0x10f>
jmp    1a0f <simplex_fit+0x85f>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    133f <simplex_fit+0x18f>
mov    -0x8(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1030 <merit_function@plt>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
mov    %ax,%dx
mov    -0xc0(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    12c9 <simplex_fit+0x119>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0xc0(%rbp),%rdx
call   10b0 <sortSimplex@plt>
mov    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   10c0 <repositionSimplex@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x38(%rbp),%rdx
call   10d0 <calcCentroid@plt>
mov    0x2c61(%rip),%rax
mov    (%rax),%edi
mov    -0xb4(%rbp),%edx
lea    0xc9a(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1452 <simplex_fit+0x2a2>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1412 <simplex_fit+0x262>
mov    0x2c0d(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc41(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    13bd <simplex_fit+0x20d>
mov    0x2bc7(%rip),%rax
mov    (%rax),%edi
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm1
lea    0xc05(%rip),%rsi
mov    $0x2,%al
call   1050 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    139f <simplex_fit+0x1ef>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14d7 <simplex_fit+0x327>
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    145c <simplex_fit+0x2ac>
mov    -0x40(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1030 <merit_function@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1586 <simplex_fit+0x3d6>
movsd  -0x68(%rbp),%xmm1
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1586 <simplex_fit+0x3d6>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1581 <simplex_fit+0x3d1>
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1536 <simplex_fit+0x386>
jmp    1900 <simplex_fit+0x750>
movsd  -0x68(%rbp),%xmm1
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1711 <simplex_fit+0x561>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    161a <simplex_fit+0x46a>
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15a7 <simplex_fit+0x3f7>
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1030 <merit_function@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16b2 <simplex_fit+0x502>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16ad <simplex_fit+0x4fd>
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1662 <simplex_fit+0x4b2>
jmp    170c <simplex_fit+0x55c>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1707 <simplex_fit+0x557>
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    16bc <simplex_fit+0x50c>
jmp    170c <simplex_fit+0x55c>
jmp    18fb <simplex_fit+0x74b>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1796 <simplex_fit+0x5e6>
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    171b <simplex_fit+0x56b>
mov    -0x50(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1030 <merit_function@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1821 <simplex_fit+0x671>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    181c <simplex_fit+0x66c>
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    17d1 <simplex_fit+0x621>
jmp    18f6 <simplex_fit+0x746>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18f1 <simplex_fit+0x741>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18d8 <simplex_fit+0x728>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0xac(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1849 <simplex_fit+0x699>
jmp    18dd <simplex_fit+0x72d>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    182b <simplex_fit+0x67b>
jmp    18f6 <simplex_fit+0x746>
jmp    18fb <simplex_fit+0x74b>
jmp    1900 <simplex_fit+0x750>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    195d <simplex_fit+0x7ad>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1915 <simplex_fit+0x765>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    19ec <simplex_fit+0x83c>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  0x647(%rip),%xmm1
call   1080 <pow@plt>
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    198d <simplex_fit+0x7dd>
movsd  -0x60(%rbp),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    127a <simplex_fit+0xca>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x25bd(%rip),%rax
mov    (%rax),%edi
lea    0x617(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a8a <simplex_fit+0x8da>
mov    0x258d(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x5c9(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1a3d <simplex_fit+0x88d>
mov    0x254f(%rip),%rax
mov    (%rax),%edi
movsd  -0x80(%rbp),%xmm0
lea    0x5a0(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
mov    0x2533(%rip),%rax
mov    (%rax),%edi
mov    -0xb4(%rbp),%edx
lea    0x590(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0xc0(%rbp),%rdi
call   10a0 <freeShortVector@plt>
mov    -0x48(%rbp),%rdi
call   1070 <freeDoubleVector@plt>
mov    -0x50(%rbp),%rdi
call   1070 <freeDoubleVector@plt>
mov    -0x40(%rbp),%rdi
call   1070 <freeDoubleVector@plt>
mov    -0x38(%rbp),%rdi
call   1070 <freeDoubleVector@plt>
mov    -0x58(%rbp),%rdi
call   1070 <freeDoubleVector@plt>
movsd  -0x80(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplex_fit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x40(%rsp)
mov    %r8d,0x8c(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,0x68(%rsp)
mov    %esi,%ebp
mov    %rdi,%rbx
lea    0x1(%rbp),%r14d
mov    %r14,0x28(%rsp)
mov    %r14d,%edi
call   1060 <allocateShortVector@plt>
mov    %rax,0xc8(%rsp)
mov    %r14d,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1040 <allocateDoubleVector@plt>
mov    %rbp,%r8
mov    %r12,%rdx
mov    %rax,%r9
movslq %r8d,%rcx
mov    %rcx,0x50(%rsp)
mov    %ecx,%edi
mov    %rdi,0x10(%rsp)
mov    %r15,0xb8(%rsp)
lea    (%r15,%rdi,8),%r11
lea    (%r14,%rdi,8),%rsi
lea    (%rax,%rdi,8),%r10
mov    %edi,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x38(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x30(%rsp)
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
cmp    %rsi,%r15
setb   %r12b
cmp    %r11,%r14
mov    %r14,%rax
setb   %cl
and    %r12b,%cl
mov    %cl,0x1f(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
and    %rbp,%rcx
mov    %rcx,0xa0(%rsp)
mov    %rdi,%r14
neg    %r14
mov    %ebp,%r15d
and    $0x3,%r15d
mov    %rbp,%rcx
mov    %rbp,0x48(%rsp)
and    $0xfffffffffffffffc,%rbp
mov    %rbp,0x90(%rsp)
mov    %edi,%ecx
and    $0x3,%ecx
mov    %rcx,0x98(%rsp)
cmp    %rsi,%r9
setb   %bpl
mov    %r10,0xd8(%rsp)
cmp    %r10,%rax
setb   %cl
and    %bpl,%cl
mov    %cl,0x1d(%rsp)
cmp    %rsi,%rdx
lea    (%rdx,%rdi,8),%rdi
setb   %sil
cmp    %rdi,%rax
setb   %r10b
and    %sil,%r10b
mov    %r11,0xb0(%rsp)
cmp    %r11,%rdx
setb   %sil
mov    %rdi,0x110(%rsp)
mov    0xb8(%rsp),%rbp
cmp    %rdi,%rbp
setb   %cl
and    %sil,%cl
or     %r10b,%cl
mov    0x28(%rsp),%r10
mov    %cl,0x1e(%rsp)
cvtsi2sd %r10d,%xmm0
movsd  %xmm0,0x128(%rsp)
mov    0x50(%rsp),%rcx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
mov    %rcx,0xe8(%rsp)
mov    %r10d,%ecx
and    $0x7,%ecx
mov    %rcx,0xe0(%rsp)
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x130(%rsp)
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
mov    %r15,0x118(%rsp)
mov    %r15,%rsi
mov    %rax,%r15
shl    $0x5,%rsi
movsd  0x1c70(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
lea    -0x1(%r10),%rdi
mov    %rdi,0xf0(%rsp)
mov    %rbp,%rdi
lea    0x10(%rbp),%rdi
mov    %rdi,0xd0(%rsp)
mov    %r9,0x58(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x108(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0x100(%rsp)
xor    %eax,%eax
mov    %rax,0xa8(%rsp)
mov    %r15,0xc0(%rsp)
mov    %r8,0x8(%rsp)
mov    %rdx,0x60(%rsp)
mov    %r14,0x138(%rsp)
mov    %rcx,0x120(%rsp)
mov    %rsi,0x78(%rsp)
mov    %rbx,0xf8(%rsp)
mov    %r13,0x140(%rsp)
nop
test   %r8d,%r8d
js     1560 <simplex_fit+0x3b0>
xor    %ebp,%ebp
mov    0x40(%rsp),%r15
mov    0x8c(%rsp),%r12d
mov    %r10,%r14
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rbp,8),%rdi
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
mov    %r15,%r8
call   1030 <merit_function@plt>
mov    0xc8(%rsp),%rax
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    %bp,(%rax,%rbp,2)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1430 <simplex_fit+0x280>
mov    %r13,%rdi
mov    %r14d,%esi
mov    %rax,%rbp
mov    %rax,%rdx
call   10b0 <sortSimplex@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%rbp
mov    %ebp,%edx
call   10c0 <repositionSimplex@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    0xc0(%rsp),%rdx
call   10d0 <calcCentroid@plt>
mov    0x3b3f(%rip),%rax
mov    (%rax),%edi
lea    0x1b96(%rip),%rsi
mov    0xa8(%rsp),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    %rbp,%rcx
test   %ecx,%ecx
js     15ba <simplex_fit+0x40a>
xor    %ebp,%ebp
jmp    150a <simplex_fit+0x35a>
nopl   0x0(%rax,%rax,1)
mov    (%r14),%edi
mov    0x140(%rsp),%r13
movsd  0x0(%r13,%rbp,8),%xmm0
lea    0x1b6b(%rip),%rsi
movsd  0x20(%rsp),%xmm1
mov    $0x2,%al
call   1050 <fprintf@plt>
add    $0x1,%rbp
cmp    0x28(%rsp),%rbp
mov    0x8(%rsp),%rcx
je     15ba <simplex_fit+0x40a>
test   %ecx,%ecx
mov    0x10(%rsp),%r12
mov    0x3ac8(%rip),%r14
lea    0x1b31(%rip),%rbx
mov    0xf8(%rsp),%r15
jle    14d0 <simplex_fit+0x320>
xor    %r13d,%r13d
nopl   0x0(%rax)
mov    (%r14),%edi
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%r13,8),%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
add    $0x1,%r13
cmp    %r13,%r12
jne    1530 <simplex_fit+0x380>
jmp    14d0 <simplex_fit+0x320>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %r10d,%esi
mov    0xc8(%rsp),%rbp
mov    %rbp,%rdx
call   10b0 <sortSimplex@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%rdx
call   10c0 <repositionSimplex@plt>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    %r15,%rdx
call   10d0 <calcCentroid@plt>
mov    0x3a43(%rip),%rax
mov    (%rax),%edi
lea    0x1a9a(%rip),%rsi
mov    0xa8(%rsp),%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    0xc0(%rsp),%r15
mov    0xb8(%rsp),%rbp
mov    0x40(%rsp),%r8
mov    0x8c(%rsp),%r12d
mov    0x10(%rsp),%rsi
mov    0x138(%rsp),%r14
mov    0xf8(%rsp),%rbx
jle    17a0 <simplex_fit+0x5f0>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%ecx
jb     1623 <simplex_fit+0x473>
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%rbp
setb   %cl
cmp    0xb0(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x1f(%rsp),%dl
je     16a2 <simplex_fit+0x4f2>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%sil
je     164e <simplex_fit+0x49e>
movsd  (%r15,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r14,%rdx
je     17a0 <simplex_fit+0x5f0>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1660 <simplex_fit+0x4b0>
jmp    17a0 <simplex_fit+0x5f0>
cmpq   $0x0,0x30(%rsp)
je     1d1d <simplex_fit+0xb6d>
mov    0xa0(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
movupd 0x30(%r15,%rcx,8),%xmm1
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,0x20(%rbp,%rcx,8)
movupd %xmm2,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    16c0 <simplex_fit+0x510>
testb  $0x1,0x48(%rsp)
je     178b <simplex_fit+0x5db>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1625 <simplex_fit+0x475>
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
call   1030 <merit_function@plt>
movsd  0x0(%r13),%xmm2
ucomisd %xmm2,%xmm0
jb     18a0 <simplex_fit+0x6f0>
mov    0xe8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    18a0 <simplex_fit+0x6f0>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jle    2520 <simplex_fit+0x1370>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1820 <simplex_fit+0x670>
cmp    0xb0(%rsp),%rax
jae    21a3 <simplex_fit+0xff3>
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%rbp
jae    21a3 <simplex_fit+0xff3>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    0x98(%rsp),%rsi
test   %rsi,%rsi
je     1855 <simplex_fit+0x6a5>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1840 <simplex_fit+0x690>
cmp    $0x3,%rdx
jb     2520 <simplex_fit+0x1370>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1860 <simplex_fit+0x6b0>
jmp    2520 <simplex_fit+0x1370>
nopl   (%rax)
ucomisd %xmm0,%xmm2
mov    0x8(%rsp),%rcx
movapd 0x177f(%rip),%xmm5
jbe    18e0 <simplex_fit+0x730>
test   %ecx,%ecx
jle    191a <simplex_fit+0x76a>
cmp    $0x4,%ecx
setb   %al
or     0x1e(%rsp),%al
je     19a3 <simplex_fit+0x7f3>
xor    %ecx,%ecx
mov    0x60(%rsp),%rdi
mov    0x40(%rsp),%r8
mov    0x10(%rsp),%rdx
jmp    1aac <simplex_fit+0x8fc>
nopl   (%rax)
test   %ecx,%ecx
movsd  0x171e(%rip),%xmm4
movsd  %xmm0,0x20(%rsp)
jle    194a <simplex_fit+0x79a>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%ecx
jae    1c21 <simplex_fit+0xa71>
xor    %edx,%edx
mov    0x58(%rsp),%rdi
mov    0x40(%rsp),%r8
mov    0x10(%rsp),%rsi
jmp    1e30 <simplex_fit+0xc80>
mov    0x60(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
mov    0x40(%rsp),%r8
call   1030 <merit_function@plt>
mov    0x8(%rsp),%r8
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jmp    2520 <simplex_fit+0x1370>
mov    0x58(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
mov    0x40(%rsp),%r8
call   1030 <merit_function@plt>
movapd 0x16c2(%rip),%xmm7
movsd  0x1692(%rip),%xmm6
mov    0x8(%rsp),%r8
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jae    2520 <simplex_fit+0x1370>
test   %r8d,%r8d
jg     1efe <simplex_fit+0xd4e>
jmp    2520 <simplex_fit+0x1370>
cmpq   $0x0,0x30(%rsp)
mov    0x60(%rsp),%rdi
mov    0x40(%rsp),%r8
mov    0x10(%rsp),%rdx
je     2191 <simplex_fit+0xfe1>
mov    0xa0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
movupd 0x20(%rbp,%rax,8),%xmm2
movupd 0x30(%rbp,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    19d0 <simplex_fit+0x820>
testb  $0x1,0x48(%rsp)
je     1a9b <simplex_fit+0x8eb>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
mov    0x38(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
je     1b25 <simplex_fit+0x975>
mov    %rcx,%rax
test   $0x1,%dl
je     1ad8 <simplex_fit+0x928>
movsd  (%r15,%rcx,8),%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r14,%rcx
je     1b25 <simplex_fit+0x975>
movsd  (%r15,%rax,8),%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1ae0 <simplex_fit+0x930>
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
call   1030 <merit_function@plt>
mov    0xe8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1c58 <simplex_fit+0xaa8>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jle    2520 <simplex_fit+0x1370>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1b97 <simplex_fit+0x9e7>
cmp    0x110(%rsp),%rax
mov    0x60(%rsp),%rsi
jae    2295 <simplex_fit+0x10e5>
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%rsi
jae    2295 <simplex_fit+0x10e5>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
test   $0x3,%r9b
je     1bd4 <simplex_fit+0xa24>
mov    0x98(%rsp),%rsi
mov    0x60(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1bc0 <simplex_fit+0xa10>
cmp    $0x3,%rdx
jb     2520 <simplex_fit+0x1370>
xchg   %ax,%ax
mov    0x60(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1be0 <simplex_fit+0xa30>
jmp    2520 <simplex_fit+0x1370>
mov    0x10(%rsp),%rsi
lea    (%rax,%rsi,8),%rcx
mov    0x58(%rsp),%rdi
cmp    %rcx,%rdi
setb   %cl
cmp    0xd8(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x1d(%rsp),%dl
mov    0x40(%rsp),%r8
je     1d2f <simplex_fit+0xb7f>
xor    %edx,%edx
jmp    1e30 <simplex_fit+0xc80>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jle    2520 <simplex_fit+0x1370>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1c9a <simplex_fit+0xaea>
cmp    0xb0(%rsp),%rax
jae    22a9 <simplex_fit+0x10f9>
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%rbp
jae    22a9 <simplex_fit+0x10f9>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
test   $0x3,%r9b
je     1cd5 <simplex_fit+0xb25>
mov    0x98(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1cc0 <simplex_fit+0xb10>
cmp    $0x3,%rdx
jb     2520 <simplex_fit+0x1370>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1ce0 <simplex_fit+0xb30>
jmp    2520 <simplex_fit+0x1370>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    174f <simplex_fit+0x59f>
jmp    178b <simplex_fit+0x5db>
cmpq   $0x0,0x30(%rsp)
je     21b7 <simplex_fit+0x1007>
mov    0xa0(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm3,0x10(%rdi,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
movupd 0x30(%r15,%rcx,8),%xmm1
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdi,%rcx,8)
movupd %xmm3,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1d50 <simplex_fit+0xba0>
testb  $0x1,0x48(%rsp)
je     1e19 <simplex_fit+0xc69>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm3,0x10(%rdi,%rcx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
je     1eb4 <simplex_fit+0xd04>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%sil
je     1e5c <simplex_fit+0xcac>
movsd  (%r15,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r14,%rdx
je     1eb4 <simplex_fit+0xd04>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  0x8(%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1e70 <simplex_fit+0xcc0>
mov    0x68(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %r12d,%ecx
call   1030 <merit_function@plt>
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    20c0 <simplex_fit+0xf10>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
movsd  0x1118(%rip),%xmm6
movapd 0x1138(%rip),%xmm7
jle    2520 <simplex_fit+0x1370>
mov    $0x1,%eax
jmp    1f1d <simplex_fit+0xd6d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %r10,%rax
je     2520 <simplex_fit+0x1370>
test   %r8d,%r8d
jle    1f10 <simplex_fit+0xd60>
mov    (%rbx),%rcx
mov    (%rbx,%rax,8),%rdx
cmp    $0x4,%r8d
jb     1f49 <simplex_fit+0xd99>
lea    (%rcx,%r9,8),%rsi
cmp    %rsi,%rdx
jae    1fc7 <simplex_fit+0xe17>
lea    (%rdx,%r9,8),%rsi
cmp    %rsi,%rcx
jae    1fc7 <simplex_fit+0xe17>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%r9b
je     1f76 <simplex_fit+0xdc6>
movsd  (%rcx,%rdi,8),%xmm0
movsd  (%rdx,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    %r14,%rdi
je     1f10 <simplex_fit+0xd60>
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm0
movsd  (%rdx,%rsi,8),%xmm1
movsd  0x8(%rdx,%rsi,8),%xmm2
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  0x8(%rcx,%rsi,8),%xmm0
subsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r9
jne    1f80 <simplex_fit+0xdd0>
jmp    1f10 <simplex_fit+0xd60>
cmpq   $0x0,0x30(%rsp)
je     20b5 <simplex_fit+0xf05>
mov    0xa0(%rsp),%rdi
xor    %esi,%esi
nopl   (%rax)
movupd (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm1
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
movupd 0x20(%rdx,%rsi,8),%xmm4
movupd 0x30(%rdx,%rsi,8),%xmm5
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rsi,8)
movupd %xmm3,0x10(%rdx,%rsi,8)
movupd 0x20(%rcx,%rsi,8),%xmm0
movupd 0x30(%rcx,%rsi,8),%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm1,%xmm5
mulpd  %xmm7,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm7,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,0x20(%rdx,%rsi,8)
movupd %xmm5,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1fe0 <simplex_fit+0xe30>
testb  $0x1,0x48(%rsp)
je     209f <simplex_fit+0xeef>
movupd (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm1
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rsi,8)
movupd %xmm3,0x10(%rdx,%rsi,8)
mov    0x38(%rsp),%rsi
mov    %rsi,%rdi
cmp    %r9,%rsi
je     1f10 <simplex_fit+0xd60>
jmp    1f4b <simplex_fit+0xd9b>
xor    %esi,%esi
testb  $0x1,0x48(%rsp)
jne    2066 <simplex_fit+0xeb6>
jmp    209f <simplex_fit+0xeef>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x10(%rsp),%r9
jle    2520 <simplex_fit+0x1370>
mov    0x50(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     2107 <simplex_fit+0xf57>
cmp    0xd8(%rsp),%rax
mov    0x58(%rsp),%rsi
jae    22c1 <simplex_fit+0x1111>
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%rsi
jae    22c1 <simplex_fit+0x1111>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
test   $0x3,%r9b
je     2144 <simplex_fit+0xf94>
mov    0x98(%rsp),%rsi
mov    0x58(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2130 <simplex_fit+0xf80>
cmp    $0x3,%rdx
jb     2520 <simplex_fit+0x1370>
xchg   %ax,%ax
mov    0x58(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    2150 <simplex_fit+0xfa0>
jmp    2520 <simplex_fit+0x1370>
xor    %eax,%eax
testb  $0x1,0x48(%rsp)
jne    1a5f <simplex_fit+0x8af>
jmp    1a9b <simplex_fit+0x8eb>
cmpq   $0xc,0x30(%rsp)
jae    21c9 <simplex_fit+0x1019>
xor    %ecx,%ecx
mov    0x78(%rsp),%rdi
jmp    223d <simplex_fit+0x108d>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    1dde <simplex_fit+0xc2e>
jmp    1e19 <simplex_fit+0xc69>
mov    0x90(%rsp),%rdx
xor    %ecx,%ecx
mov    0x78(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,8),%xmm0
movups 0x10(%rbp,%rcx,8),%xmm1
movups %xmm0,(%rax,%rcx,8)
movups %xmm1,0x10(%rax,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm0
movups 0x30(%rbp,%rcx,8),%xmm1
movups %xmm0,0x20(%rax,%rcx,8)
movups %xmm1,0x30(%rax,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm0
movups 0x50(%rbp,%rcx,8),%xmm1
movups %xmm0,0x40(%rax,%rcx,8)
movups %xmm1,0x50(%rax,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm0
movupd 0x70(%rbp,%rcx,8),%xmm1
movupd %xmm0,0x60(%rax,%rcx,8)
movupd %xmm1,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    21e0 <simplex_fit+0x1030>
cmpq   $0x0,0x118(%rsp)
je     227f <simplex_fit+0x10cf>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xd0(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    2260 <simplex_fit+0x10b0>
mov    0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r9,%rdx
je     2520 <simplex_fit+0x1370>
jmp    1822 <simplex_fit+0x672>
cmpq   $0xc,0x30(%rsp)
mov    0x78(%rsp),%rdi
jae    22d9 <simplex_fit+0x1129>
xor    %ecx,%ecx
jmp    234c <simplex_fit+0x119c>
cmpq   $0xc,0x30(%rsp)
mov    0x78(%rsp),%rdi
jae    23a5 <simplex_fit+0x11f5>
xor    %ecx,%ecx
jmp    240d <simplex_fit+0x125d>
cmpq   $0xc,0x30(%rsp)
mov    0x78(%rsp),%rdi
jae    2465 <simplex_fit+0x12b5>
xor    %ecx,%ecx
jmp    24cc <simplex_fit+0x131c>
mov    0x90(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rcx,8),%xmm0
movups 0x10(%rsi,%rcx,8),%xmm1
movups %xmm0,(%rax,%rcx,8)
movups %xmm1,0x10(%rax,%rcx,8)
movups 0x20(%rsi,%rcx,8),%xmm0
movups 0x30(%rsi,%rcx,8),%xmm1
movups %xmm0,0x20(%rax,%rcx,8)
movups %xmm1,0x30(%rax,%rcx,8)
movups 0x40(%rsi,%rcx,8),%xmm0
movups 0x50(%rsi,%rcx,8),%xmm1
movups %xmm0,0x40(%rax,%rcx,8)
movups %xmm1,0x50(%rax,%rcx,8)
movupd 0x60(%rsi,%rcx,8),%xmm0
movupd 0x70(%rsi,%rcx,8),%xmm1
movupd %xmm0,0x60(%rax,%rcx,8)
movupd %xmm1,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    22f0 <simplex_fit+0x1140>
testb  $0x3,0x48(%rsp)
je     238f <simplex_fit+0x11df>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0x100(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    2370 <simplex_fit+0x11c0>
mov    0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r9,%rdx
je     2520 <simplex_fit+0x1370>
jmp    1b99 <simplex_fit+0x9e9>
mov    0x90(%rsp),%rdx
xor    %ecx,%ecx
nop
movups 0x0(%rbp,%rcx,8),%xmm0
movups 0x10(%rbp,%rcx,8),%xmm1
movups %xmm0,(%rax,%rcx,8)
movups %xmm1,0x10(%rax,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm0
movups 0x30(%rbp,%rcx,8),%xmm1
movups %xmm0,0x20(%rax,%rcx,8)
movups %xmm1,0x30(%rax,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm0
movups 0x50(%rbp,%rcx,8),%xmm1
movups %xmm0,0x40(%rax,%rcx,8)
movups %xmm1,0x50(%rax,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm0
movupd 0x70(%rbp,%rcx,8),%xmm1
movupd %xmm0,0x60(%rax,%rcx,8)
movupd %xmm1,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    23b0 <simplex_fit+0x1200>
testb  $0x3,0x48(%rsp)
je     244f <simplex_fit+0x129f>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xd0(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    2430 <simplex_fit+0x1280>
mov    0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r9,%rdx
je     2520 <simplex_fit+0x1370>
jmp    1c9c <simplex_fit+0xaec>
mov    0x90(%rsp),%rdx
xor    %ecx,%ecx
nop
movups (%rsi,%rcx,8),%xmm0
movups 0x10(%rsi,%rcx,8),%xmm1
movups %xmm0,(%rax,%rcx,8)
movups %xmm1,0x10(%rax,%rcx,8)
movups 0x20(%rsi,%rcx,8),%xmm0
movups 0x30(%rsi,%rcx,8),%xmm1
movups %xmm0,0x20(%rax,%rcx,8)
movups %xmm1,0x30(%rax,%rcx,8)
movups 0x40(%rsi,%rcx,8),%xmm0
movups 0x50(%rsi,%rcx,8),%xmm1
movups %xmm0,0x40(%rax,%rcx,8)
movups %xmm1,0x50(%rax,%rcx,8)
movupd 0x60(%rsi,%rcx,8),%xmm0
movupd 0x70(%rsi,%rcx,8),%xmm1
movupd %xmm0,0x60(%rax,%rcx,8)
movupd %xmm1,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2470 <simplex_fit+0x12c0>
testb  $0x3,0x48(%rsp)
je     250f <simplex_fit+0x135f>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0x108(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    24f0 <simplex_fit+0x1340>
mov    0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r9,%rdx
jne    2109 <simplex_fit+0xf59>
test   %r8d,%r8d
js     2690 <simplex_fit+0x14e0>
cmpq   $0x7,0xf0(%rsp)
mov    0x130(%rsp),%rcx
xorpd  %xmm0,%xmm0
jae    2550 <simplex_fit+0x13a0>
xor    %eax,%eax
mov    0xe0(%rsp),%rdx
jmp    25a1 <simplex_fit+0x13f1>
nopl   0x0(%rax)
xor    %eax,%eax
mov    0xe0(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
addsd  0x0(%r13,%rax,8),%xmm0
addsd  0x8(%r13,%rax,8),%xmm0
addsd  0x10(%r13,%rax,8),%xmm0
addsd  0x18(%r13,%rax,8),%xmm0
addsd  0x20(%r13,%rax,8),%xmm0
addsd  0x28(%r13,%rax,8),%xmm0
addsd  0x30(%r13,%rax,8),%xmm0
addsd  0x38(%r13,%rax,8),%xmm0
add    $0x8,%rax
cmp    %rax,%rcx
jne    2560 <simplex_fit+0x13b0>
test   %rdx,%rdx
je     25ce <simplex_fit+0x141e>
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    25c0 <simplex_fit+0x1410>
test   %r8d,%r8d
js     2690 <simplex_fit+0x14e0>
divsd  0x128(%rsp),%xmm0
cmpq   $0x0,0xf0(%rsp)
movsd  %xmm0,0x20(%rsp)
mov    %rbx,%rax
mov    %r10,%rbx
mov    %rax,%r14
xorpd  %xmm2,%xmm2
je     2696 <simplex_fit+0x14e6>
xor    %ebp,%ebp
mov    0x120(%rsp),%r12
nopl   0x0(%rax)
movsd  %xmm2,0x80(%rsp)
movsd  0x0(%r13,%rbp,8),%xmm0
subsd  0x20(%rsp),%xmm0
movsd  0x9e2(%rip),%xmm1
call   1080 <pow@plt>
cltd
idivl  0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x80(%rsp)
movsd  0x8(%r13,%rbp,8),%xmm0
subsd  0x20(%rsp),%xmm0
movsd  0x9aa(%rip),%xmm1
call   1080 <pow@plt>
mov    0x8(%rsp),%r8
cltd
idiv   %r8d
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  0x80(%rsp),%xmm2
add    $0x2,%rbp
cmp    %rbp,%r12
jne    2610 <simplex_fit+0x1460>
jmp    2698 <simplex_fit+0x14e8>
nop
xorpd  %xmm2,%xmm2
jmp    2700 <simplex_fit+0x1550>
xor    %ebp,%ebp
movsd  0x20(%rsp),%xmm1
mov    %rbx,%r10
test   $0x1,%r10b
mov    0x10(%rsp),%r9
mov    %r14,%rbx
je     2700 <simplex_fit+0x1550>
movsd  0x0(%r13,%rbp,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0x94e(%rip),%xmm1
mov    %rbx,%rbp
mov    %r10,%rbx
movsd  %xmm2,0x80(%rsp)
call   1080 <pow@plt>
movsd  0x80(%rsp),%xmm2
mov    %rbx,%r10
mov    %rbp,%rbx
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r8
cltd
idiv   %r8d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm2
xchg   %ax,%ax
ucomisd 0x918(%rip),%xmm2
jb     2720 <simplex_fit+0x1570>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    273f <simplex_fit+0x158f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm2,%xmm0
mov    %rbx,%rbp
mov    %r10,%rbx
call   1090 <sqrt@plt>
mov    %rbx,%r10
mov    %rbp,%rbx
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r8
movsd  %xmm0,0x20(%rsp)
mov    0xa8(%rsp),%rax
lea    0x1(%rax),%ebp
cmp    $0xc6,%eax
ja     2775 <simplex_fit+0x15c5>
movsd  0x20(%rsp),%xmm0
ucomisd 0x8b3(%rip),%xmm0
mov    %ebp,%eax
mov    %rax,0xa8(%rsp)
ja     1410 <simplex_fit+0x260>
movsd  0x0(%r13),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x2858(%rip),%r12
mov    (%r12),%edi
lea    0x8c8(%rip),%rsi
xor    %eax,%eax
mov    %r8,%r15
mov    %r9,%r14
call   1050 <fprintf@plt>
test   %r15d,%r15d
jle    27d4 <simplex_fit+0x1624>
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    (%r12),%edi
mov    (%rbx),%rax
movsd  (%rax,%r15,8),%xmm0
lea    0x88c(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%r14
jne    27b0 <simplex_fit+0x1600>
mov    (%r12),%edi
lea    0x878(%rip),%rsi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1050 <fprintf@plt>
mov    (%r12),%edi
lea    0x86d(%rip),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0xc8(%rsp),%rdi
call   10a0 <freeShortVector@plt>
mov    0x60(%rsp),%rdi
call   1070 <freeDoubleVector@plt>
mov    0x58(%rsp),%rdi
call   1070 <freeDoubleVector@plt>
mov    0xb8(%rsp),%rdi
call   1070 <freeDoubleVector@plt>
mov    0xc0(%rsp),%rdi
call   1070 <freeDoubleVector@plt>
mov    %r13,%rdi
call   1070 <freeDoubleVector@plt>
movsd  0x8(%rsp),%xmm0
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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