#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 *);
int pow(double, double);
int /*<<< orphan*/ repositionSimplex(short *, double **, int);
int /*<<< orphan*/ sortSimplex(double *, int, short *);
double sqrt(double);
int /*<<< orphan*/ stdout;
double simplex(double (*f)(double *), double **x, int n) {
  double *xm, *xr, *xe, *xc, *fx, tol = 1e9, 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-9) {
    for (i = 0; i < n + 1; i++) {
      fx[i] = f(x[i]);
      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 = f(xr);
    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 = f(xe);
      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 = f(xc);
      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>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  0xe5a(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xe45(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xe30(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe1b(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe0b(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
mov    -0x14(%rbp),%edi
add    $0x1,%edi
call   1050 <allocateShortVector@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x14(%rbp),%edi
add    $0x1,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0xc8,-0x9c(%rbp)
mov    %al,-0xa9(%rbp)
jge    128a <simplex+0xea>
movsd  -0x48(%rbp),%xmm0
movsd  0xda3(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    129d <simplex+0xfd>
jmp    199d <simplex+0x7fd>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    130f <simplex+0x16f>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x94(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
call   *%rax
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
mov    %ax,%dx
mov    -0xa8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    12a7 <simplex+0x107>
mov    -0x40(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0xa8(%rbp),%rdx
call   10a0 <sortSimplex@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   10b0 <repositionSimplex@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   10c0 <calcCentroid@plt>
mov    0x2c91(%rip),%rax
mov    (%rax),%edi
mov    -0x9c(%rbp),%edx
lea    0xcca(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1422 <simplex+0x282>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e2 <simplex+0x242>
mov    0x2c3d(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc71(%rip),%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    138d <simplex+0x1ed>
mov    0x2bf7(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm1
lea    0xc35(%rip),%rsi
mov    $0x2,%al
call   1040 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    136f <simplex+0x1cf>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14a4 <simplex+0x304>
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    142c <simplex+0x28c>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1545 <simplex+0x3a5>
movsd  -0x50(%rbp),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1545 <simplex+0x3a5>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1540 <simplex+0x3a0>
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    14f5 <simplex+0x355>
jmp    18a0 <simplex+0x700>
movsd  -0x50(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    16bf <simplex+0x51f>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15d6 <simplex+0x436>
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1566 <simplex+0x3c6>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1660 <simplex+0x4c0>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    165b <simplex+0x4bb>
mov    -0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1610 <simplex+0x470>
jmp    16ba <simplex+0x51a>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16b5 <simplex+0x515>
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    166a <simplex+0x4ca>
jmp    16ba <simplex+0x51a>
jmp    189b <simplex+0x6fb>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1744 <simplex+0x5a4>
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    16c9 <simplex+0x529>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     17c1 <simplex+0x621>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17bc <simplex+0x61c>
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1771 <simplex+0x5d1>
jmp    1896 <simplex+0x6f6>
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1891 <simplex+0x6f1>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1878 <simplex+0x6d8>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x94(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    17e9 <simplex+0x649>
jmp    187d <simplex+0x6dd>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    17cb <simplex+0x62b>
jmp    1896 <simplex+0x6f6>
jmp    189b <simplex+0x6fb>
jmp    18a0 <simplex+0x700>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18f4 <simplex+0x754>
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    18b2 <simplex+0x712>
movsd  -0x70(%rbp),%xmm0
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    197a <simplex+0x7da>
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  0x6b9(%rip),%xmm1
call   1070 <pow@plt>
cltd
idivl  -0x14(%rbp)
cvtsi2sd %eax,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    191e <simplex+0x77e>
movsd  -0x48(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1258 <simplex+0xb8>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x262f(%rip),%rax
mov    (%rax),%edi
lea    0x689(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a18 <simplex+0x878>
mov    0x25ff(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x63b(%rip),%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    19cb <simplex+0x82b>
mov    0x25c1(%rip),%rax
mov    (%rax),%edi
movsd  -0x68(%rbp),%xmm0
lea    0x612(%rip),%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
mov    0x25a5(%rip),%rax
mov    (%rax),%edi
mov    -0x9c(%rbp),%edx
lea    0x602(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0xa8(%rbp),%rdi
call   1090 <freeShortVector@plt>
mov    -0x30(%rbp),%rdi
call   1060 <freeDoubleVector@plt>
mov    -0x38(%rbp),%rdi
call   1060 <freeDoubleVector@plt>
mov    -0x28(%rbp),%rdi
call   1060 <freeDoubleVector@plt>
mov    -0x20(%rbp),%rdi
call   1060 <freeDoubleVector@plt>
mov    -0x40(%rbp),%rdi
call   1060 <freeDoubleVector@plt>
movsd  -0x68(%rbp),%xmm0
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edx,%ebp
mov    %rsi,0x10(%rsp)
mov    %rdi,0x58(%rsp)
lea    0x1(%rbp),%r15d
mov    %r15d,%edi
call   1050 <allocateShortVector@plt>
mov    %rax,0x98(%rsp)
mov    %r15d,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1030 <allocateDoubleVector@plt>
mov    %rbp,%r8
mov    %r14,%rdx
mov    %rax,%r9
movslq %r8d,%rcx
mov    %rcx,0x40(%rsp)
mov    %ecx,%ebp
mov    %rbp,0xd0(%rsp)
mov    %rbx,0x90(%rsp)
lea    (%rbx,%rbp,8),%r11
lea    (%r12,%rbp,8),%r14
lea    (%rax,%rbp,8),%r10
mov    %rax,0x30(%rsp)
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x20(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %r14,%rbx
setb   %cl
cmp    %r11,%r12
setb   %bl
and    %cl,%bl
mov    %bl,0xf(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
and    %rdi,%rcx
mov    %rcx,0x78(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %edi,%esi
and    $0x3,%esi
mov    %rdi,%rcx
mov    %rdi,0x38(%rsp)
and    $0xfffffffffffffffc,%rdi
mov    %rdi,0x68(%rsp)
mov    %ebp,%ecx
and    $0x3,%ecx
mov    %rcx,0x70(%rsp)
cmp    %r14,%r9
setb   %dil
mov    %r10,0xa8(%rsp)
cmp    %r10,%r12
setb   %cl
and    %dil,%cl
mov    %cl,0xd(%rsp)
cmp    %r14,%rdx
lea    (%rdx,%rbp,8),%rdi
setb   %bl
cmp    %rdi,%r12
setb   %cl
and    %bl,%cl
mov    %r11,0x88(%rsp)
cmp    %r11,%rdx
setb   %r10b
mov    %rdi,0xe8(%rsp)
mov    0x90(%rsp),%rbp
cmp    %rdi,%rbp
setb   %bl
and    %r10b,%bl
or     %cl,%bl
mov    %bl,0xe(%rsp)
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,0x100(%rsp)
mov    0x40(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rax,%r9
movslq %ecx,%rcx
mov    %rcx,0xb8(%rsp)
mov    %r15d,%ecx
and    $0x7,%ecx
mov    %rcx,0xb0(%rsp)
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x108(%rsp)
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
mov    %rsi,0xf0(%rsp)
shl    $0x5,%rsi
mov    %rsi,0x110(%rsp)
movsd  0x1ca1(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
lea    -0x1(%r15),%rsi
mov    %rsi,0xc0(%rsp)
mov    %rbp,%rax
lea    0x10(%rbp),%rsi
mov    %rsi,0xa0(%rsp)
mov    0x30(%rsp),%rax
add    $0x10,%rax
mov    %rax,0xe0(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0xd8(%rsp)
xor    %r14d,%r14d
mov    %r12,0x80(%rsp)
mov    %r8,(%rsp)
mov    %rdx,0x48(%rsp)
mov    %r9,0x50(%rsp)
mov    %rcx,0xf8(%rsp)
mov    %r15,0x120(%rsp)
mov    %r13,0x118(%rsp)
xchg   %ax,%ax
test   %r8d,%r8d
mov    %r14,0xc8(%rsp)
js     1520 <simplex+0x380>
xor    %ebp,%ebp
mov    %r15,%r12
mov    0x58(%rsp),%r15
mov    0x10(%rsp),%rbx
mov    (%rbx,%rbp,8),%rdi
call   *%r15
mov    0x98(%rsp),%rax
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    %bp,(%rax,%rbp,2)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    13f0 <simplex+0x250>
mov    %r13,%rdi
mov    %r12d,%esi
mov    %rax,%rbp
mov    %rax,%rdx
call   10a0 <sortSimplex@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    (%rsp),%rbp
mov    %ebp,%edx
call   10b0 <repositionSimplex@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    0x80(%rsp),%rdx
call   10c0 <calcCentroid@plt>
mov    0x3b92(%rip),%rax
mov    (%rax),%edi
lea    0x1be9(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbp,%rcx
test   %ecx,%ecx
mov    %r12,%r15
js     157c <simplex+0x3dc>
xor    %ebp,%ebp
jmp    14bf <simplex+0x31f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14),%edi
mov    0x118(%rsp),%r13
movsd  0x0(%r13,%rbp,8),%xmm0
lea    0x1bbb(%rip),%rsi
movsd  0x18(%rsp),%xmm1
mov    $0x2,%al
call   1040 <fprintf@plt>
add    $0x1,%rbp
mov    0x120(%rsp),%r15
cmp    %r15,%rbp
mov    (%rsp),%rcx
je     157c <simplex+0x3dc>
test   %ecx,%ecx
mov    0x3b18(%rip),%r14
mov    0xd0(%rsp),%r12
lea    0x1b79(%rip),%rbx
mov    0x10(%rsp),%r15
jle    1480 <simplex+0x2e0>
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14),%edi
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%r13,8),%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
add    $0x1,%r13
cmp    %r13,%r12
jne    14f0 <simplex+0x350>
jmp    1480 <simplex+0x2e0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %r15d,%esi
mov    0x98(%rsp),%rbp
mov    %rbp,%rdx
call   10a0 <sortSimplex@plt>
mov    %rbp,%rdi
mov    0x10(%rsp),%rbx
mov    %rbx,%rsi
mov    (%rsp),%rdx
call   10b0 <repositionSimplex@plt>
mov    %rbx,%rdi
mov    (%rsp),%rsi
mov    0x80(%rsp),%rdx
call   10c0 <calcCentroid@plt>
mov    0x3a7b(%rip),%rax
mov    (%rax),%edi
lea    0x1ad2(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    (%rsp),%rcx
test   %ecx,%ecx
mov    0x80(%rsp),%r14
mov    0x90(%rsp),%rbp
mov    0x50(%rsp),%rsi
mov    0xd0(%rsp),%rbx
mov    0x110(%rsp),%r12
mov    0x10(%rsp),%rdx
jle    1750 <simplex+0x5b0>
mov    0x40(%rsp),%rax
mov    (%rdx,%rax,8),%rax
cmp    $0x4,%ecx
jb     15d9 <simplex+0x439>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rbp
setb   %cl
cmp    0x88(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0xf(%rsp),%dl
je     1652 <simplex+0x4b2>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     1603 <simplex+0x463>
movsd  (%r14,%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    %rsi,%rdx
je     1750 <simplex+0x5b0>
nop
movsd  (%r14,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%r14,%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,%rbx
jne    1610 <simplex+0x470>
jmp    1750 <simplex+0x5b0>
cmpq   $0x0,0x20(%rsp)
je     1c5d <simplex+0xabd>
mov    0x78(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%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(%r14,%rcx,8),%xmm0
movupd 0x30(%r14,%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    1670 <simplex+0x4d0>
testb  $0x1,0x38(%rsp)
je     173b <simplex+0x59b>
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%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    0x28(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
jne    15db <simplex+0x43b>
nopl   0x0(%rax)
mov    %rbp,%rdi
call   *0x58(%rsp)
movsd  0x0(%r13),%xmm2
ucomisd %xmm2,%xmm0
jb     1840 <simplex+0x6a0>
mov    0xb8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1840 <simplex+0x6a0>
mov    (%rsp),%r8
test   %r8d,%r8d
mov    0x10(%rsp),%rcx
jle    2420 <simplex+0x1280>
mov    0x40(%rsp),%rax
mov    (%rcx,%rax,8),%rax
cmp    $0x4,%r8d
jb     17bc <simplex+0x61c>
cmp    0x88(%rsp),%rax
jae    20c3 <simplex+0xf23>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rbp
jae    20c3 <simplex+0xf23>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
mov    0x70(%rsp),%rsi
test   %rsi,%rsi
je     17f5 <simplex+0x655>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    17e0 <simplex+0x640>
cmp    $0x3,%rdx
jb     2420 <simplex+0x1280>
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,%rbx
jne    1800 <simplex+0x660>
jmp    2420 <simplex+0x1280>
nopl   (%rax)
ucomisd %xmm0,%xmm2
mov    (%rsp),%rcx
movapd 0x17e0(%rip),%xmm5
jbe    1880 <simplex+0x6e0>
test   %ecx,%ecx
jle    18ba <simplex+0x71a>
cmp    $0x4,%ecx
setb   %al
or     0xe(%rsp),%al
je     1911 <simplex+0x771>
xor    %ecx,%ecx
mov    0x48(%rsp),%rdi
mov    0x58(%rsp),%rdx
mov    0x50(%rsp),%rsi
jmp    1a1c <simplex+0x87c>
nopl   0x0(%rax)
test   %ecx,%ecx
movsd  0x177e(%rip),%xmm4
movsd  %xmm0,0x18(%rsp)
jle    18cc <simplex+0x72c>
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%rdx
mov    (%rdx,%rax,8),%rax
cmp    $0x4,%ecx
jae    1b71 <simplex+0x9d1>
xor    %edx,%edx
mov    0x30(%rsp),%rdi
mov    0x50(%rsp),%rsi
jmp    1d70 <simplex+0xbd0>
mov    0x48(%rsp),%rdi
call   *0x58(%rsp)
mov    (%rsp),%r8
jmp    2420 <simplex+0x1280>
mov    0x30(%rsp),%rdi
call   *0x58(%rsp)
movapd 0x1753(%rip),%xmm7
movsd  0x1723(%rip),%xmm6
mov    (%rsp),%r8
movsd  0x18(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    0x50(%rsp),%r9
mov    0x10(%rsp),%rbp
jae    2420 <simplex+0x1280>
test   %r8d,%r8d
jg     1e2f <simplex+0xc8f>
jmp    2420 <simplex+0x1280>
cmpq   $0x0,0x20(%rsp)
mov    0x48(%rsp),%rdi
mov    0x58(%rsp),%rdx
mov    0x50(%rsp),%rsi
je     20b1 <simplex+0xf11>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%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(%r14,%rax,8),%xmm0
movupd 0x30(%r14,%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    1940 <simplex+0x7a0>
testb  $0x1,0x38(%rsp)
je     1a0b <simplex+0x86b>
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%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    0x28(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     1a95 <simplex+0x8f5>
mov    %rcx,%rax
test   $0x1,%bl
je     1a48 <simplex+0x8a8>
movsd  (%r14,%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    %rsi,%rcx
je     1a95 <simplex+0x8f5>
movsd  (%r14,%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(%r14,%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,%rbx
jne    1a50 <simplex+0x8b0>
call   *%rdx
mov    0xb8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1ba3 <simplex+0xa03>
mov    (%rsp),%r8
test   %r8d,%r8d
mov    0x10(%rsp),%rcx
jle    2420 <simplex+0x1280>
mov    0x40(%rsp),%rax
mov    (%rcx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1af1 <simplex+0x951>
cmp    0xe8(%rsp),%rax
mov    0x48(%rsp),%rsi
jae    21a5 <simplex+0x1005>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rsi
jae    21a5 <simplex+0x1005>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     1b24 <simplex+0x984>
mov    0x70(%rsp),%rsi
mov    0x48(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1b10 <simplex+0x970>
cmp    $0x3,%rdx
jb     2420 <simplex+0x1280>
xchg   %ax,%ax
mov    0x48(%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,%rbx
jne    1b30 <simplex+0x990>
jmp    2420 <simplex+0x1280>
lea    (%rax,%rbx,8),%rcx
mov    0x30(%rsp),%rdi
cmp    %rcx,%rdi
setb   %cl
cmp    0xa8(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0xd(%rsp),%dl
mov    0x50(%rsp),%rsi
je     1c6f <simplex+0xacf>
xor    %edx,%edx
jmp    1d70 <simplex+0xbd0>
mov    (%rsp),%r8
test   %r8d,%r8d
mov    0x10(%rsp),%rcx
jle    2420 <simplex+0x1280>
mov    0x40(%rsp),%rax
mov    (%rcx,%rax,8),%rax
cmp    $0x4,%r8d
jb     1bdf <simplex+0xa3f>
cmp    0x88(%rsp),%rax
jae    21b4 <simplex+0x1014>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rbp
jae    21b4 <simplex+0x1014>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     1c15 <simplex+0xa75>
mov    0x70(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1c00 <simplex+0xa60>
cmp    $0x3,%rdx
jb     2420 <simplex+0x1280>
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,%rbx
jne    1c20 <simplex+0xa80>
jmp    2420 <simplex+0x1280>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    16ff <simplex+0x55f>
jmp    173b <simplex+0x59b>
cmpq   $0x0,0x20(%rsp)
je     20cf <simplex+0xf2f>
mov    0x78(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%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(%r14,%rcx,8),%xmm0
movupd 0x30(%r14,%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    1c90 <simplex+0xaf0>
testb  $0x1,0x38(%rsp)
je     1d59 <simplex+0xbb9>
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%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    0x28(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
je     1df4 <simplex+0xc54>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%bl
je     1d9b <simplex+0xbfb>
movsd  (%r14,%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    %rsi,%rdx
je     1df4 <simplex+0xc54>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%r14,%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,%rbx
jne    1db0 <simplex+0xc10>
call   *0x58(%rsp)
movsd  0x18(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    1ff0 <simplex+0xe50>
mov    (%rsp),%r8
test   %r8d,%r8d
movsd  0x11f1(%rip),%xmm6
movapd 0x1211(%rip),%xmm7
mov    0x50(%rsp),%r9
mov    0x10(%rsp),%rbp
jle    2420 <simplex+0x1280>
mov    $0x1,%eax
jmp    1e4d <simplex+0xcad>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r15,%rax
je     2420 <simplex+0x1280>
test   %r8d,%r8d
jle    1e40 <simplex+0xca0>
mov    0x0(%rbp),%rcx
mov    0x0(%rbp,%rax,8),%rdx
cmp    $0x4,%r8d
jb     1e7b <simplex+0xcdb>
lea    (%rcx,%rbx,8),%rsi
cmp    %rsi,%rdx
jae    1ef7 <simplex+0xd57>
lea    (%rdx,%rbx,8),%rsi
cmp    %rsi,%rcx
jae    1ef7 <simplex+0xd57>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bl
je     1ea7 <simplex+0xd07>
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    %r9,%rdi
je     1e40 <simplex+0xca0>
nop
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,%rbx
jne    1eb0 <simplex+0xd10>
jmp    1e40 <simplex+0xca0>
cmpq   $0x0,0x20(%rsp)
je     1fe5 <simplex+0xe45>
mov    0x78(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
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    1f10 <simplex+0xd70>
testb  $0x1,0x38(%rsp)
je     1fcf <simplex+0xe2f>
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    0x28(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbx,%rsi
je     1e40 <simplex+0xca0>
jmp    1e7d <simplex+0xcdd>
xor    %esi,%esi
testb  $0x1,0x38(%rsp)
jne    1f96 <simplex+0xdf6>
jmp    1fcf <simplex+0xe2f>
mov    (%rsp),%r8
test   %r8d,%r8d
mov    0x10(%rsp),%rcx
jle    2420 <simplex+0x1280>
mov    0x40(%rsp),%rax
mov    (%rcx,%rax,8),%rax
cmp    $0x4,%r8d
jb     2031 <simplex+0xe91>
cmp    0xa8(%rsp),%rax
mov    0x30(%rsp),%rsi
jae    21c7 <simplex+0x1027>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rsi
jae    21c7 <simplex+0x1027>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     2064 <simplex+0xec4>
mov    0x70(%rsp),%rsi
mov    0x30(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2050 <simplex+0xeb0>
cmp    $0x3,%rdx
jb     2420 <simplex+0x1280>
xchg   %ax,%ax
mov    0x30(%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,%rbx
jne    2070 <simplex+0xed0>
jmp    2420 <simplex+0x1280>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    19cf <simplex+0x82f>
jmp    1a0b <simplex+0x86b>
cmpq   $0xc,0x20(%rsp)
jae    20e1 <simplex+0xf41>
xor    %ecx,%ecx
jmp    214d <simplex+0xfad>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1d1e <simplex+0xb7e>
jmp    1d59 <simplex+0xbb9>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
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    20f0 <simplex+0xf50>
cmpq   $0x0,0xf0(%rsp)
je     218f <simplex+0xfef>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xa0(%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,%r12
jne    2170 <simplex+0xfd0>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
je     2420 <simplex+0x1280>
jmp    17be <simplex+0x61e>
cmpq   $0xc,0x20(%rsp)
jae    21da <simplex+0x103a>
xor    %ecx,%ecx
jmp    224c <simplex+0x10ac>
cmpq   $0xc,0x20(%rsp)
jae    22a5 <simplex+0x1105>
xor    %ecx,%ecx
jmp    230d <simplex+0x116d>
cmpq   $0xc,0x20(%rsp)
jae    2365 <simplex+0x11c5>
xor    %ecx,%ecx
jmp    23cc <simplex+0x122c>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    21f0 <simplex+0x1050>
testb  $0x3,0x38(%rsp)
je     228f <simplex+0x10ef>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xd8(%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,%r12
jne    2270 <simplex+0x10d0>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
je     2420 <simplex+0x1280>
jmp    1af3 <simplex+0x953>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
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    22b0 <simplex+0x1110>
testb  $0x3,0x38(%rsp)
je     234f <simplex+0x11af>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xa0(%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,%r12
jne    2330 <simplex+0x1190>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
je     2420 <simplex+0x1280>
jmp    1be1 <simplex+0xa41>
mov    0x68(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%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    2370 <simplex+0x11d0>
testb  $0x3,0x38(%rsp)
je     240f <simplex+0x126f>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xe0(%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,%r12
jne    23f0 <simplex+0x1250>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
jne    2033 <simplex+0xe93>
test   %r8d,%r8d
js     2460 <simplex+0x12c0>
cmpq   $0x7,0xc0(%rsp)
mov    0x2bab(%rip),%r12
mov    0x108(%rsp),%rcx
mov    0xc8(%rsp),%r14
xorpd  %xmm0,%xmm0
jae    2480 <simplex+0x12e0>
xor    %eax,%eax
mov    0xb0(%rsp),%rdx
jmp    24d1 <simplex+0x1331>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
mov    0x2b75(%rip),%r12
mov    0xc8(%rsp),%r14
jmp    2620 <simplex+0x1480>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0xb0(%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    2490 <simplex+0x12f0>
test   %rdx,%rdx
je     24fe <simplex+0x135e>
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    24f0 <simplex+0x1350>
test   %r8d,%r8d
js     25c0 <simplex+0x1420>
divsd  0x100(%rsp),%xmm0
cmpq   $0x0,0xc0(%rsp)
movsd  %xmm0,0x18(%rsp)
mov    %r14,%r12
xorpd  %xmm2,%xmm2
je     25c6 <simplex+0x1426>
xor    %ebp,%ebp
mov    0xf8(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm2,0x60(%rsp)
movsd  0x0(%r13,%rbp,8),%xmm0
subsd  0x18(%rsp),%xmm0
movsd  0xab5(%rip),%xmm1
call   1070 <pow@plt>
cltd
idivl  (%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%r13,%rbp,8),%xmm0
subsd  0x18(%rsp),%xmm0
movsd  0xa84(%rip),%xmm1
call   1070 <pow@plt>
mov    (%rsp),%r8
cltd
idiv   %r8d
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  0x60(%rsp),%xmm2
add    $0x2,%rbp
cmp    %rbp,%r14
jne    2540 <simplex+0x13a0>
jmp    25c8 <simplex+0x1428>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
jmp    2620 <simplex+0x1480>
xor    %ebp,%ebp
movsd  0x18(%rsp),%xmm1
test   $0x1,%r15b
mov    %r12,%r14
mov    0x2a04(%rip),%r12
je     2620 <simplex+0x1480>
movsd  0x0(%r13,%rbp,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0xa1f(%rip),%xmm1
movsd  %xmm2,0x60(%rsp)
call   1070 <pow@plt>
movsd  0x60(%rsp),%xmm2
mov    (%rsp),%r8
cltd
idiv   %r8d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd 0x9f8(%rip),%xmm2
jb     2640 <simplex+0x14a0>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    264d <simplex+0x14ad>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm2,%xmm0
call   1080 <sqrt@plt>
mov    (%rsp),%r8
movsd  %xmm0,0x18(%rsp)
lea    0x1(%r14),%ebp
cmp    $0xc6,%r14d
ja     2677 <simplex+0x14d7>
movsd  0x18(%rsp),%xmm0
ucomisd 0x9aa(%rip),%xmm0
mov    %ebp,%r14d
ja     13d0 <simplex+0x230>
movsd  0x0(%r13),%xmm0
movsd  %xmm0,(%rsp)
mov    (%r12),%edi
lea    0x9ce(%rip),%rsi
xor    %eax,%eax
mov    %r8,%r15
call   1040 <fprintf@plt>
test   %r15d,%r15d
mov    0x10(%rsp),%r14
jle    26d4 <simplex+0x1534>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12),%edi
mov    (%r14),%rax
movsd  (%rax,%r15,8),%xmm0
lea    0x98c(%rip),%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%rbx
jne    26b0 <simplex+0x1510>
mov    (%r12),%edi
lea    0x978(%rip),%rsi
movsd  (%rsp),%xmm0
mov    $0x1,%al
call   1040 <fprintf@plt>
mov    (%r12),%edi
lea    0x96e(%rip),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x98(%rsp),%rdi
call   1090 <freeShortVector@plt>
mov    0x48(%rsp),%rdi
call   1060 <freeDoubleVector@plt>
mov    0x30(%rsp),%rdi
call   1060 <freeDoubleVector@plt>
mov    0x90(%rsp),%rdi
call   1060 <freeDoubleVector@plt>
mov    0x80(%rsp),%rdi
call   1060 <freeDoubleVector@plt>
mov    %r13,%rdi
call   1060 <freeDoubleVector@plt>
movsd  (%rsp),%xmm0
add    $0x128,%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(double (double*)* %0, double** %1, i32 %2) {
%4 = alloca double (double*)*
%5 = alloca double**
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca 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 i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i16*
store double (double*)* %0, double (double*)** %4
store double** %1, double*** %5
store i32 %2, i32* %6
store double 1.000000e+09, double* %12
store double 1.000000e+00, double* %18
store double 2.000000e+00, double* %19
store double 5.000000e-01, double* %20
store double 5.000000e-01, double* %21
store i32 0, i32* %24
%26 = load i32, i32* %6
%27 = add nsw i32 %26, 1
%28 = call i16* @allocateShortVector(i32 %27)
store i16* %28, i16** %25
%29 = load i32, i32* %6
%30 = add nsw i32 %29, 1
%31 = call double* @allocateDoubleVector(i32 %30)
store double* %31, double** %11
%32 = load i32, i32* %6
%33 = call double* @allocateDoubleVector(i32 %32)
store double* %33, double** %7
%34 = load i32, i32* %6
%35 = call double* @allocateDoubleVector(i32 %34)
store double* %35, double** %8
%36 = load i32, i32* %6
%37 = call double* @allocateDoubleVector(i32 %36)
store double* %37, double** %9
%38 = load i32, i32* %6
%39 = call double* @allocateDoubleVector(i32 %38)
store double* %39, double** %10
br label %40
40: ; preds = %467, %3
%41 = load i32, i32* %24
%42 = icmp slt i32 %41, 200
br i1 %42, label %43, label %46
43: ; preds = %40
%44 = load double, double* %12
%45 = fcmp ogt double %44, 1.000000e-09
br label %46
46: ; preds = %43, %40
%47 = phi i1 [ false, %40 ], [ %45, %43 ]
br i1 %47, label %48, label %472
48: ; preds = %46
store i32 0, i32* %22
br label %49
49: ; preds = %72, %48
%50 = load i32, i32* %22
%51 = load i32, i32* %6
%52 = add nsw i32 %51, 1
%53 = icmp slt i32 %50, %52
br i1 %53, label %54, label %75
54: ; preds = %49
%55 = load double (double*)*, double (double*)** %4
%56 = load double**, double*** %5
%57 = load i32, i32* %22
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double*, double** %56, i64 %58
%60 = load double*, double** %59
%61 = call double %55(double* %60)
%62 = load double*, double** %11
%63 = load i32, i32* %22
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
store double %61, double* %65
%66 = load i32, i32* %22
%67 = trunc i32 %66 to i16
%68 = load i16*, i16** %25
%69 = load i32, i32* %22
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i16, i16* %68, i64 %70
store i16 %67, i16* %71
br label %72
72: ; preds = %54
%73 = load i32, i32* %22
%74 = add nsw i32 %73, 1
store i32 %74, i32* %22
br label %49
75: ; preds = %49
%76 = load double*, double** %11
%77 = load i32, i32* %6
%78 = add nsw i32 %77, 1
%79 = load i16*, i16** %25
%80 = call i32 @sortSimplex(double* %76, i32 %78, i16* %79)
%81 = load i16*, i16** %25
%82 = load double**, double*** %5
%83 = load i32, i32* %6
%84 = call i32 @repositionSimplex(i16* %81, double** %82, i32 %83)
%85 = load double**, double*** %5
%86 = load i32, i32* %6
%87 = load double*, double** %7
%88 = call i32 @calcCentroid(double** %85, i32 %86, double* %87)
%89 = load i32, i32* @stdout
%90 = load i32, i32* %24
%91 = call i32 (i32, i8*, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %90)
store i32 0, i32* %22
br label %92
92: ; preds = %126, %75
%93 = load i32, i32* %22
%94 = load i32, i32* %6
%95 = add nsw i32 %94, 1
%96 = icmp slt i32 %93, %95
br i1 %96, label %97, label %129
97: ; preds = %92
store i32 0, i32* %23
br label %98
98: ; preds = %114, %97
%99 = load i32, i32* %23
%100 = load i32, i32* %6
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %117
102: ; preds = %98
%103 = load i32, i32* @stdout
%104 = load double**, double*** %5
%105 = load i32, i32* %22
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double*, double** %104, i64 %106
%108 = load double*, double** %107
%109 = load i32, i32* %23
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %108, i64 %110
%112 = load double, double* %111
%113 = call i32 (i32, i8*, ...) @fprintf(i32 %103, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double %112)
br label %114
114: ; preds = %102
%115 = load i32, i32* %23
%116 = add nsw i32 %115, 1
store i32 %116, i32* %23
br label %98
117: ; preds = %98
%118 = load i32, i32* @stdout
%119 = load double*, double** %11
%120 = load i32, i32* %22
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %119, i64 %121
%123 = load double, double* %122
%124 = load double, double* %12
%125 = call i32 (i32, i8*, ...) @fprintf(i32 %118, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), double %123, double %124)
br label %126
126: ; preds = %117
%127 = load i32, i32* %22
%128 = add nsw i32 %127, 1
store i32 %128, i32* %22
br label %92
129: ; preds = %92
store i32 0, i32* %22
br label %130
130: ; preds = %161, %129
%131 = load i32, i32* %22
%132 = load i32, i32* %6
%133 = icmp slt i32 %131, %132
br i1 %133, label %134, label %164
134: ; preds = %130
%135 = load double*, double** %7
%136 = load i32, i32* %22
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %135, i64 %137
%139 = load double, double* %138
%140 = load double, double* %18
%141 = load double*, double** %7
%142 = load i32, i32* %22
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double**, double*** %5
%147 = load i32, i32* %6
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double*, double** %146, i64 %148
%150 = load double*, double** %149
%151 = load i32, i32* %22
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %150, i64 %152
%154 = load double, double* %153
%155 = fsub double %145, %154
%156 = call double @llvm.fmuladd.f64(double %140, double %155, double %139)
%157 = load double*, double** %8
%158 = load i32, i32* %22
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
store double %156, double* %160
br label %161
161: ; preds = %134
%162 = load i32, i32* %22
%163 = add nsw i32 %162, 1
store i32 %163, i32* %22
br label %130
164: ; preds = %130
%165 = load double (double*)*, double (double*)** %4
%166 = load double*, double** %8
%167 = call double %165(double* %166)
store double %167, double* %13
%168 = load double*, double** %11
%169 = getelementptr inbounds double, double* %168, i64 0
%170 = load double, double* %169
%171 = load double, double* %13
%172 = fcmp ole double %170, %171
br i1 %172, label %173, label %205
173: ; preds = %164
%174 = load double, double* %13
%175 = load double*, double** %11
%176 = load i32, i32* %6
%177 = sub nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %175, i64 %178
%180 = load double, double* %179
%181 = fcmp olt double %174, %180
br i1 %181, label %182, label %205
182: ; preds = %173
store i32 0, i32* %22
br label %183
183: ; preds = %201, %182
%184 = load i32, i32* %22
%185 = load i32, i32* %6
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %204
187: ; preds = %183
%188 = load double*, double** %8
%189 = load i32, i32* %22
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
%193 = load double**, double*** %5
%194 = load i32, i32* %6
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double*, double** %193, i64 %195
%197 = load double*, double** %196
%198 = load i32, i32* %22
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %197, i64 %199
store double %192, double* %200
br label %201
201: ; preds = %187
%202 = load i32, i32* %22
%203 = add nsw i32 %202, 1
store i32 %203, i32* %22
br label %183
204: ; preds = %183
br label %422
205: ; preds = %173, %164
%206 = load double, double* %13
%207 = load double*, double** %11
%208 = getelementptr inbounds double, double* %207, i64 0
%209 = load double, double* %208
%210 = fcmp olt double %206, %209
br i1 %210, label %211, label %301
211: ; preds = %205
store i32 0, i32* %22
br label %212
212: ; preds = %239, %211
%213 = load i32, i32* %22
%214 = load i32, i32* %6
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %242
216: ; preds = %212
%217 = load double*, double** %7
%218 = load i32, i32* %22
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %217, i64 %219
%221 = load double, double* %220
%222 = load double, double* %19
%223 = load double*, double** %8
%224 = load i32, i32* %22
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
%227 = load double, double* %226
%228 = load double*, double** %7
%229 = load i32, i32* %22
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
%232 = load double, double* %231
%233 = fsub double %227, %232
%234 = call double @llvm.fmuladd.f64(double %222, double %233, double %221)
%235 = load double*, double** %9
%236 = load i32, i32* %22
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds double, double* %235, i64 %237
store double %234, double* %238
br label %239
239: ; preds = %216
%240 = load i32, i32* %22
%241 = add nsw i32 %240, 1
store i32 %241, i32* %22
br label %212
242: ; preds = %212
%243 = load double (double*)*, double (double*)** %4
%244 = load double*, double** %9
%245 = call double %243(double* %244)
store double %245, double* %14
%246 = load double, double* %14
%247 = load double*, double** %11
%248 = load i32, i32* %6
%249 = sub nsw i32 %248, 1
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %247, i64 %250
%252 = load double, double* %251
%253 = fcmp olt double %246, %252
br i1 %253, label %254, label %277
254: ; preds = %242
store i32 0, i32* %22
br label %255
255: ; preds = %273, %254
%256 = load i32, i32* %22
%257 = load i32, i32* %6
%258 = icmp slt i32 %256, %257
br i1 %258, label %259, label %276
259: ; preds = %255
%260 = load double*, double** %9
%261 = load i32, i32* %22
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %260, i64 %262
%264 = load double, double* %263
%265 = load double**, double*** %5
%266 = load i32, i32* %6
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double*, double** %265, i64 %267
%269 = load double*, double** %268
%270 = load i32, i32* %22
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %269, i64 %271
store double %264, double* %272
br label %273
273: ; preds = %259
%274 = load i32, i32* %22
%275 = add nsw i32 %274, 1
store i32 %275, i32* %22
br label %255
276: ; preds = %255
br label %300
277: ; preds = %242
store i32 0, i32* %22
br label %278
278: ; preds = %296, %277
%279 = load i32, i32* %22
%280 = load i32, i32* %6
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %299
282: ; preds = %278
%283 = load double*, double** %8
%284 = load i32, i32* %22
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
%288 = load double**, double*** %5
%289 = load i32, i32* %6
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double*, double** %288, i64 %290
%292 = load double*, double** %291
%293 = load i32, i32* %22
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
store double %287, double* %295
br label %296
296: ; preds = %282
%297 = load i32, i32* %22
%298 = add nsw i32 %297, 1
store i32 %298, i32* %22
br label %278
299: ; preds = %278
br label %300
300: ; preds = %299, %276
br label %421
301: ; preds = %205
store i32 0, i32* %22
br label %302
302: ; preds = %333, %301
%303 = load i32, i32* %22
%304 = load i32, i32* %6
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %336
306: ; preds = %302
%307 = load double*, double** %7
%308 = load i32, i32* %22
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = load double, double* %20
%313 = load double**, double*** %5
%314 = load i32, i32* %6
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double*, double** %313, i64 %315
%317 = load double*, double** %316
%318 = load i32, i32* %22
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
%322 = load double*, double** %7
%323 = load i32, i32* %22
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
%326 = load double, double* %325
%327 = fsub double %321, %326
%328 = call double @llvm.fmuladd.f64(double %312, double %327, double %311)
%329 = load double*, double** %10
%330 = load i32, i32* %22
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %329, i64 %331
store double %328, double* %332
br label %333
333: ; preds = %306
%334 = load i32, i32* %22
%335 = add nsw i32 %334, 1
store i32 %335, i32* %22
br label %302
336: ; preds = %302
%337 = load double (double*)*, double (double*)** %4
%338 = load double*, double** %10
%339 = call double %337(double* %338)
store double %339, double* %15
%340 = load double, double* %15
%341 = load double, double* %13
%342 = fcmp ole double %340, %341
br i1 %342, label %343, label %366
343: ; preds = %336
store i32 0, i32* %22
br label %344
344: ; preds = %362, %343
%345 = load i32, i32* %22
%346 = load i32, i32* %6
%347 = icmp slt i32 %345, %346
br i1 %347, label %348, label %365
348: ; preds = %344
%349 = load double*, double** %10
%350 = load i32, i32* %22
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %349, i64 %351
%353 = load double, double* %352
%354 = load double**, double*** %5
%355 = load i32, i32* %6
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double*, double** %354, i64 %356
%358 = load double*, double** %357
%359 = load i32, i32* %22
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %358, i64 %360
store double %353, double* %361
br label %362
362: ; preds = %348
%363 = load i32, i32* %22
%364 = add nsw i32 %363, 1
store i32 %364, i32* %22
br label %344
365: ; preds = %344
br label %420
366: ; preds = %336
store i32 1, i32* %23
br label %367
367: ; preds = %416, %366
%368 = load i32, i32* %23
%369 = load i32, i32* %6
%370 = add nsw i32 %369, 1
%371 = icmp slt i32 %368, %370
br i1 %371, label %372, label %419
372: ; preds = %367
store i32 0, i32* %22
br label %373
373: ; preds = %412, %372
%374 = load i32, i32* %22
%375 = load i32, i32* %6
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %415
377: ; preds = %373
%378 = load double**, double*** %5
%379 = getelementptr inbounds double*, double** %378, i64 0
%380 = load double*, double** %379
%381 = load i32, i32* %22
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %380, i64 %382
%384 = load double, double* %383
%385 = load double, double* %21
%386 = load double**, double*** %5
%387 = load i32, i32* %23
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double*, double** %386, i64 %388
%390 = load double*, double** %389
%391 = load i32, i32* %22
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %390, i64 %392
%394 = load double, double* %393
%395 = load double**, double*** %5
%396 = getelementptr inbounds double*, double** %395, i64 0
%397 = load double*, double** %396
%398 = load i32, i32* %22
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %397, i64 %399
%401 = load double, double* %400
%402 = fsub double %394, %401
%403 = call double @llvm.fmuladd.f64(double %385, double %402, double %384)
%404 = load double**, double*** %5
%405 = load i32, i32* %23
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double*, double** %404, i64 %406
%408 = load double*, double** %407
%409 = load i32, i32* %22
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %408, i64 %410
store double %403, double* %411
br label %412
412: ; preds = %377
%413 = load i32, i32* %22
%414 = add nsw i32 %413, 1
store i32 %414, i32* %22
br label %373
415: ; preds = %373
br label %416
416: ; preds = %415
%417 = load i32, i32* %23
%418 = add nsw i32 %417, 1
store i32 %418, i32* %23
br label %367
419: ; preds = %367
br label %420
420: ; preds = %419, %365
br label %421
421: ; preds = %420, %300
br label %422
422: ; preds = %421, %204
store double 0.000000e+00, double* %17
store i32 0, i32* %22
br label %423
423: ; preds = %436, %422
%424 = load i32, i32* %22
%425 = load i32, i32* %6
%426 = add nsw i32 %425, 1
%427 = icmp slt i32 %424, %426
br i1 %427, label %428, label %439
428: ; preds = %423
%429 = load double*, double** %11
%430 = load i32, i32* %22
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %429, i64 %431
%433 = load double, double* %432
%434 = load double, double* %17
%435 = fadd double %434, %433
store double %435, double* %17
br label %436
436: ; preds = %428
%437 = load i32, i32* %22
%438 = add nsw i32 %437, 1
store i32 %438, i32* %22
br label %423
439: ; preds = %423
%440 = load double, double* %17
%441 = load i32, i32* %6
%442 = add nsw i32 %441, 1
%443 = sitofp i32 %442 to double
%444 = fdiv double %440, %443
store double %444, double* %17
store double 0.000000e+00, double* %12
store i32 0, i32* %22
br label %445
445: ; preds = %464, %439
%446 = load i32, i32* %22
%447 = load i32, i32* %6
%448 = add nsw i32 %447, 1
%449 = icmp slt i32 %446, %448
br i1 %449, label %450, label %467
450: ; preds = %445
%451 = load double*, double** %11
%452 = load i32, i32* %22
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %451, i64 %453
%455 = load double, double* %454
%456 = load double, double* %17
%457 = fsub double %455, %456
%458 = call i32 @pow(double %457, double 2.000000e+00)
%459 = load i32, i32* %6
%460 = sdiv i32 %458, %459
%461 = sitofp i32 %460 to double
%462 = load double, double* %12
%463 = fadd double %462, %461
store double %463, double* %12
br label %464
464: ; preds = %450
%465 = load i32, i32* %22
%466 = add nsw i32 %465, 1
store i32 %466, i32* %22
br label %445
467: ; preds = %445
%468 = load double, double* %12
%469 = call double @sqrt(double %468)
store double %469, double* %12
%470 = load i32, i32* %24
%471 = add nsw i32 %470, 1
store i32 %471, i32* %24
br label %40
472: ; preds = %46
%473 = load double*, double** %11
%474 = getelementptr inbounds double, double* %473, i64 0
%475 = load double, double* %474
store double %475, double* %16
%476 = load i32, i32* @stdout
%477 = call i32 (i32, i8*, ...) @fprintf(i32 %476, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %22
br label %478
478: ; preds = %492, %472
%479 = load i32, i32* %22
%480 = load i32, i32* %6
%481 = icmp slt i32 %479, %480
br i1 %481, label %482, label %495
482: ; preds = %478
%483 = load i32, i32* @stdout
%484 = load double**, double*** %5
%485 = getelementptr inbounds double*, double** %484, i64 0
%486 = load double*, double** %485
%487 = load i32, i32* %22
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double, double* %486, i64 %488
%490 = load double, double* %489
%491 = call i32 (i32, i8*, ...) @fprintf(i32 %483, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double %490)
br label %492
492: ; preds = %482
%493 = load i32, i32* %22
%494 = add nsw i32 %493, 1
store i32 %494, i32* %22
br label %478
495: ; preds = %478
%496 = load i32, i32* @stdout
%497 = load double, double* %16
%498 = call i32 (i32, i8*, ...) @fprintf(i32 %496, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %497)
%499 = load i32, i32* @stdout
%500 = load i32, i32* %24
%501 = call i32 (i32, i8*, ...) @fprintf(i32 %499, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i32 %500)
%502 = load i16*, i16** %25
%503 = call i32 @freeShortVector(i16* %502)
%504 = load double*, double** %9
%505 = call i32 @freeDoubleVector(double* %504)
%506 = load double*, double** %10
%507 = call i32 @freeDoubleVector(double* %506)
%508 = load double*, double** %8
%509 = call i32 @freeDoubleVector(double* %508)
%510 = load double*, double** %7
%511 = call i32 @freeDoubleVector(double* %510)
%512 = load double*, double** %11
%513 = call i32 @freeDoubleVector(double* %512)
%514 = load double, double* %16
ret double %514
}

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