#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 evaluate(int, double *, char *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int pow(double, double);
int /*<<< orphan*/ printf(char *, ...);
int sqrt(double);
double simplex(double start[], int n, double EPSILON, double scale,
               char *filename) {
  int vs;
  int vh;
  int vg;
  int i, j, m, row;
  int k;
  int itr;
  double **v;
  double pn, qn;
  double *f;
  double fr;
  double fe;
  double fc;
  double *vr;
  double *ve;
  double *vc;
  double *vm;
  double min;
  double fsum, favg, s, cent;
  v = (double **)malloc((n + 1) * sizeof(double *));
  f = (double *)malloc((n + 1) * sizeof(double));
  vr = (double *)malloc(n * sizeof(double));
  ve = (double *)malloc(n * sizeof(double));
  vc = (double *)malloc(n * sizeof(double));
  vm = (double *)malloc(n * sizeof(double));
  for (i = 0; i <= n; i++) {
    v[i] = (double *)malloc(n * sizeof(double));
  }
  pn = scale * (sqrt(n + 1) - 1 + n) / (n * sqrt(2));
  qn = scale * (sqrt(n + 1) - 1) / (n * sqrt(2));
  for (i = 0; i < n; i++) {
    v[0][i] = start[i];
  }
  for (i = 1; i <= n; i++) {
    for (j = 0; j < n; j++) {
      if (i - 1 == j) {
        v[i][j] = pn + start[j];
      } else {
        v[i][j] = qn + start[j];
      }
    }
  }
  for (j = 0; j <= n; j++) {
    f[j] = evaluate(n, v[j], filename);
  }
  k = n + 1;
  printf("Initial Values\n");
  for (j = 0; j <= n; j++) {
    printf("%f %f %f\n", v[j][0], v[j][1], f[j]);
  }
  for (itr = 1; itr <= 1000; itr++) {
    vg = 0;
    for (j = 0; j <= n; j++) {
      if (f[j] > f[vg]) {
        vg = j;
      }
    }
    vs = 0;
    for (j = 0; j <= n; j++) {
      if (f[j] < f[vs]) {
        vs = j;
      }
    }
    vh = vs;
    for (j = 0; j <= n; j++) {
      if (f[j] > f[vh] && f[j] < f[vg]) {
        vh = j;
      }
    }
    for (j = 0; j <= n - 1; j++) {
      cent = 0.0;
      for (m = 0; m <= n; m++) {
        if (m != vg) {
          cent += v[m][j];
        }
      }
      vm[j] = cent / n;
    }
    for (j = 0; j <= n - 1; j++) {
      vr[j] = vm[j] + 1.0 * (vm[j] - v[vg][j]);
    }
    fr = evaluate(n, vr, filename);
    k++;
    if (fr < f[vh] && fr >= f[vs]) {
      for (j = 0; j <= n - 1; j++) {
        v[vg][j] = vr[j];
      }
      f[vg] = fr;
    }
    if (fr < f[vs]) {
      for (j = 0; j <= n - 1; j++) {
        ve[j] = vm[j] + 2.0 * (vr[j] - vm[j]);
      }
      fe = evaluate(n, ve, filename);
      k++;
      if (fe < fr) {
        for (j = 0; j <= n - 1; j++) {
          v[vg][j] = ve[j];
        }
        f[vg] = fe;
      } else {
        for (j = 0; j <= n - 1; j++) {
          v[vg][j] = vr[j];
        }
        f[vg] = fr;
      }
    }
    if (fr >= f[vh]) {
      if (fr < f[vg] && fr >= f[vh]) {
        for (j = 0; j <= n - 1; j++) {
          vc[j] = vm[j] + 0.5 * (vr[j] - vm[j]);
        }
        fc = evaluate(n, vc, filename);
        k++;
      } else {
        for (j = 0; j <= n - 1; j++) {
          vc[j] = vm[j] - 0.5 * (vm[j] - v[vg][j]);
        }
        fc = evaluate(n, vc, filename);
        k++;
      }
      if (fc < f[vg]) {
        for (j = 0; j <= n - 1; j++) {
          v[vg][j] = vc[j];
        }
        f[vg] = fc;
      } else {
        for (row = 0; row <= n; row++) {
          if (row != vs) {
            for (j = 0; j <= n - 1; j++) {
              v[row][j] = v[vs][j] + (v[row][j] - v[vs][j]) / 2.0;
            }
          }
        }
        f[vg] = evaluate(n, v[vg], filename);
        k++;
        f[vh] = evaluate(n, v[vh], filename);
        k++;
      }
    }
    printf("Iteration %d\n", itr);
    for (j = 0; j <= n; j++) {
      printf("%f %f %f\n", v[j][0], v[j][1], f[j]);
    }
    fsum = 0.0;
    for (j = 0; j <= n; j++) {
      fsum += f[j];
    }
    favg = fsum / (n + 1);
    s = 0.0;
    for (j = 0; j <= n; j++) {
      s += pow((f[j] - favg), 2.0) / (n);
    }
    s = sqrt(s);
    if (s < EPSILON)
      break;
  }
  vs = 0;
  for (j = 0; j <= n; j++) {
    if (f[j] < f[vs]) {
      vs = j;
    }
  }
  printf("The minimum was found at\n");
  for (j = 0; j < n; j++) {
    printf("%e\n", v[vs][j]);
    start[j] = v[vs][j];
  }
  min = evaluate(n, v[vs], filename);
  k++;
  printf("%d Function Evaluations\n", k);
  printf("%d Iterations through program\n", itr);
  free(f);
  free(vr);
  free(ve);
  free(vc);
  free(vm);
  free(*v);
  return min;
}


x86 assembly (clang, -O0):
<simplex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1245 <simplex+0xe5>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    120d <simplex+0xad>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
call   1080 <sqrt@plt>
movsd  -0x100(%rbp),%xmm0
ff
sub    $0x1,%eax
add    -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0xec(%rbp)
movsd  0xd70(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  -0xf8(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0xec(%rbp),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
call   1080 <sqrt@plt>
movsd  -0xe8(%rbp),%xmm0
ff
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0xd4(%rbp)
movsd  0xd03(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  -0xe0(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1360 <simplex+0x200>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1329 <simplex+0x1c9>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     140e <simplex+0x2ae>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13fb <simplex+0x29b>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
cmp    -0x3c(%rbp),%eax
jne    13c1 <simplex+0x261>
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13e8 <simplex+0x288>
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13ed <simplex+0x28d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    137a <simplex+0x21a>
jmp    1400 <simplex+0x2a0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1367 <simplex+0x207>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1454 <simplex+0x2f4>
mov    -0xc(%rbp),%edi
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1415 <simplex+0x2b5>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
lea    0xbb4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14c8 <simplex+0x368>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0xb75(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1472 <simplex+0x312>
movl   $0x1,-0x4c(%rbp)
cmpl   $0x3e8,-0x4c(%rbp)
jg     1dfc <simplex+0xc9c>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     152f <simplex+0x3cf>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    151c <simplex+0x3bc>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1521 <simplex+0x3c1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ea <simplex+0x38a>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1586 <simplex+0x426>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1573 <simplex+0x413>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1578 <simplex+0x418>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    153d <simplex+0x3dd>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15fc <simplex+0x49c>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    15e9 <simplex+0x489>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    15e9 <simplex+0x489>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    15ee <simplex+0x48e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1593 <simplex+0x433>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16a5 <simplex+0x545>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1676 <simplex+0x516>
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1663 <simplex+0x503>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1668 <simplex+0x508>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1626 <simplex+0x4c6>
movsd  -0xd0(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1603 <simplex+0x4a3>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1714 <simplex+0x5b4>
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16ac <simplex+0x54c>
mov    -0xc(%rbp),%edi
mov    -0x90(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    17c6 <simplex+0x666>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     17c6 <simplex+0x666>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17b4 <simplex+0x654>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1770 <simplex+0x610>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1949 <simplex+0x7e9>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1850 <simplex+0x6f0>
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17e9 <simplex+0x689>
mov    -0xc(%rbp),%edi
mov    -0x98(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    18e7 <simplex+0x787>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     18d0 <simplex+0x770>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    188c <simplex+0x72c>
movsd  -0x80(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1944 <simplex+0x7e4>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1932 <simplex+0x7d2>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18ee <simplex+0x78e>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1949 <simplex+0x7e9>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1c79 <simplex+0xb19>
movsd  -0x78(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a34 <simplex+0x8d4>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1a34 <simplex+0x8d4>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1a0b <simplex+0x8ab>
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x62b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    199c <simplex+0x83c>
mov    -0xc(%rbp),%edi
mov    -0xa0(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1ad3 <simplex+0x973>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1aaf <simplex+0x94f>
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x57f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a3b <simplex+0x8db>
mov    -0xc(%rbp),%edi
mov    -0xa0(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b57 <simplex+0x9f7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1b3d <simplex+0x9dd>
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1af9 <simplex+0x999>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c74 <simplex+0xb14>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1c18 <simplex+0xab8>
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1c05 <simplex+0xaa5>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1c00 <simplex+0xaa0>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0x42b(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b7d <simplex+0xa1d>
jmp    1c05 <simplex+0xaa5>
jmp    1c0a <simplex+0xaaa>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b5e <simplex+0x9fe>
mov    -0xc(%rbp),%edi
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1c79 <simplex+0xb19>
mov    -0x4c(%rbp),%esi
lea    0x3af(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1ce7 <simplex+0xb87>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x356(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c91 <simplex+0xb31>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1d30 <simplex+0xbd0>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1cf9 <simplex+0xb99>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1db4 <simplex+0xc54>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xc0(%rbp),%xmm0
ff
movsd  0x277(%rip),%xmm1
call   1070 <pow@plt>
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d60 <simplex+0xc00>
movsd  -0xc8(%rbp),%xmm0
ff
call   1080 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1de9 <simplex+0xc89>
jmp    1dfc <simplex+0xc9c>
jmp    1dee <simplex+0xc8e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14cf <simplex+0x36f>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1e53 <simplex+0xcf3>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e40 <simplex+0xce0>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1e45 <simplex+0xce5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e0a <simplex+0xcaa>
lea    0x1e6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ec7 <simplex+0xd67>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1ca(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e68 <simplex+0xd08>
mov    -0xc(%rbp),%edi
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x28(%rbp),%rdx
call   1060 <evaluate@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%esi
lea    0x164(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%esi
lea    0x16c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
movsd  -0xb0(%rbp),%xmm0
ff
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rdx,%r12
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,0x138(%rsp)
mov    %esi,%ebx
mov    %rdi,0xc0(%rsp)
lea    0x1(%rbx),%r15d
lea    0x8(,%rbx,8),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %r15d,0x2c(%rsp)
mov    %r15d,%r15d
mov    %rbx,0x20(%rsp)
test   %ebx,%ebx
js     1225 <simplex+0xb5>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1210 <simplex+0xa0>
mov    %r15,0x10(%rsp)
mov    0x2c(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xe0(%rsp)
call   1090 <sqrt@plt>
mov    %eax,%ebx
movsd  0x2db3(%rip),%xmm0
call   1090 <sqrt@plt>
mov    %eax,%r15d
movsd  0xe0(%rsp),%xmm0
call   1090 <sqrt@plt>
mov    %eax,%ebp
movsd  0x2d93(%rip),%xmm0
call   1090 <sqrt@plt>
mov    $0x1,%r9b
mov    0x20(%rsp),%r10
mov    %r10d,%r11d
test   %r10d,%r10d
jle    1523 <simplex+0x3b3>
mov    0x0(%r13),%rcx
cmp    $0x4,%r10d
mov    %ebp,0x40(%rsp)
jae    12a3 <simplex+0x133>
xor    %edx,%edx
mov    0xc0(%rsp),%rbp
jmp    13b9 <simplex+0x249>
mov    0xc0(%rsp),%rbp
lea    0x0(,%r11,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    12cb <simplex+0x15b>
lea    (%rcx,%r11,8),%rdx
cmp    %rbp,%rdx
jbe    12cb <simplex+0x15b>
xor    %edx,%edx
jmp    13b9 <simplex+0x249>
mov    %rbx,0x18(%rsp)
mov    %r11d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rsi
jae    12f6 <simplex+0x186>
xor    %ebx,%ebx
jmp    136d <simplex+0x1fd>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movups %xmm0,(%rcx,%rbx,8)
movups %xmm1,0x10(%rcx,%rbx,8)
movups 0x20(%rbp,%rbx,8),%xmm0
movups 0x30(%rbp,%rbx,8),%xmm1
movups %xmm0,0x20(%rcx,%rbx,8)
movups %xmm1,0x30(%rcx,%rbx,8)
movups 0x40(%rbp,%rbx,8),%xmm0
movups 0x50(%rbp,%rbx,8),%xmm1
movups %xmm0,0x40(%rcx,%rbx,8)
movups %xmm1,0x50(%rcx,%rbx,8)
movupd 0x60(%rbp,%rbx,8),%xmm0
movupd 0x70(%rbp,%rbx,8),%xmm1
movupd %xmm0,0x60(%rcx,%rbx,8)
movupd %xmm1,0x70(%rcx,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1310 <simplex+0x1a0>
test   %r8,%r8
je     13af <simplex+0x23f>
lea    (%rcx,%rbx,8),%rdi
add    $0x10,%rdi
lea    0x10(,%rbx,8),%rbx
add    %rbp,%rbx
shl    $0x5,%r8
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rsi,1),%xmm0
movupd (%rbx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rsi,1)
movupd %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1390 <simplex+0x220>
cmp    %r11,%rdx
mov    0x18(%rsp),%rbx
je     1428 <simplex+0x2b8>
mov    %rdx,%rsi
not    %rsi
add    %r11,%rsi
mov    %r11,%rdi
and    $0x3,%rdi
je     13e5 <simplex+0x275>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    13d0 <simplex+0x260>
cmp    $0x3,%rsi
jb     1428 <simplex+0x2b8>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    13f0 <simplex+0x280>
test   %r10d,%r10d
setle  %r8b
jle    1523 <simplex+0x3b3>
lea    (%r10,%rbx,1),%ecx
add    $0xffffffff,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mov    0x40(%rsp),%ecx
add    $0xffffffff,%ecx
imul   %r10d,%r15d
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
imul   %r10d,%eax
movsd  0x8(%rsp),%xmm3
mulsd  %xmm3,%xmm0
cvtsi2sd %r15d,%xmm2
divsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm1
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    $0x1,%r9d
xor    %esi,%esi
jmp    14af <simplex+0x33f>
nopl   0x0(%rax,%rax,1)
addsd  0x0(%rbp,%rbx,8),%xmm2
mov    0x0(%r13,%r9,8),%rcx
movsd  %xmm2,(%rcx,%rbx,8)
add    $0x1,%r9
add    $0x1,%rsi
cmp    0x10(%rsp),%r9
je     1520 <simplex+0x3b0>
lea    -0x1(%r9),%rdi
cmp    $0x1,%r10d
jne    14d0 <simplex+0x360>
xor    %ebx,%ebx
test   $0x1,%r11b
je     14a0 <simplex+0x330>
movapd %xmm0,%xmm2
cmp    %rbx,%rdi
je     1490 <simplex+0x320>
movapd %xmm1,%xmm2
jmp    1490 <simplex+0x320>
mov    0x0(%r13,%r9,8),%rcx
xor    %ebx,%ebx
jmp    14f5 <simplex+0x385>
nopl   0x0(%rax)
addsd  0x8(%rbp,%rbx,8),%xmm2
movsd  %xmm2,0x8(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rax,%rbx
je     14bb <simplex+0x34b>
movapd %xmm0,%xmm2
cmp    %rbx,%rsi
je     1502 <simplex+0x392>
movapd %xmm1,%xmm2
addsd  0x0(%rbp,%rbx,8),%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
lea    0x1(%rbx),%rdx
movapd %xmm0,%xmm2
cmp    %rdx,%rdi
je     14e0 <simplex+0x370>
movapd %xmm1,%xmm2
jmp    14e0 <simplex+0x370>
mov    %r8d,%r9d
test   %r10d,%r10d
mov    %r11,0x18(%rsp)
mov    %r12,0x80(%rsp)
mov    %r9b,0x36(%rsp)
js     15c9 <simplex+0x459>
xor    %ebx,%ebx
mov    %r10,%r15
mov    0x10(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rsi
mov    %r15d,%edi
mov    %r12,%rdx
call   1070 <evaluate@plt>
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1550 <simplex+0x3e0>
lea    0x2b1e(%rip),%rdi
call   1040 <puts@plt>
test   %r15d,%r15d
mov    0xb0(%rsp),%r15
js     15e2 <simplex+0x472>
xor    %ebx,%ebx
lea    0x2aaf(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rax
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
movsd  (%r14,%rbx,8),%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    15a0 <simplex+0x430>
jmp    15e2 <simplex+0x472>
lea    0x2ac4(%rip),%rdi
call   1040 <puts@plt>
mov    0xb0(%rsp),%r15
mov    0x10(%rsp),%rbp
mov    0x50(%rsp),%r8
mov    0x18(%rsp),%r9
lea    (%r8,%r9,8),%r10
mov    0x38(%rsp),%rsi
lea    (%rsi,%r9,8),%rdi
lea    (%r15,%r9,8),%r11
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x60(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x58(%rsp)
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %ebp,%ecx
and    $0x3,%ecx
mov    %rcx,0xf8(%rsp)
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xf0(%rsp)
mov    %ebp,%r12d
and    $0xfffffffe,%r12d
cmp    %r10,%rsi
setb   %cl
cmp    %rdi,%r8
setb   %dl
and    %cl,%dl
mov    %dl,0x35(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
lea    0x2(%rcx),%rdx
and    %rax,%rdx
mov    %rdx,0x88(%rsp)
mov    %r9,%rdx
neg    %rdx
mov    %rdx,0x90(%rsp)
mov    %eax,%ebx
and    $0x3,%ebx
mov    %rax,%rdx
mov    %rax,0x70(%rsp)
and    %rax,%rcx
mov    %rcx,0x98(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0xa0(%rsp)
cmp    %r10,%r15
setb   %cl
cmp    %r11,%r8
setb   %dl
and    %cl,%dl
cmp    %rdi,%r15
setb   %cl
mov    %r11,0x120(%rsp)
cmp    %r11,%rsi
setb   %al
and    %cl,%al
or     %dl,%al
mov    %al,0x37(%rsp)
mov    0xa8(%rsp),%rcx
lea    (%rcx,%r9,8),%rdx
cmp    %r10,%rcx
setb   %r10b
cmp    %rdx,%r8
setb   %al
and    %r10b,%al
mov    %rdi,0xc8(%rsp)
cmp    %rdi,%rcx
setb   %dil
mov    %rdx,0xd8(%rsp)
cmp    %rdx,%rsi
setb   %dl
and    %dil,%dl
mov    0x20(%rsp),%rdi
cvtsi2sd %edi,%xmm5
mov    %al,0x33(%rsp)
or     %al,%dl
mov    %dl,0x34(%rsp)
mov    %ebp,%eax
and    $0x7,%eax
mov    %rax,0xe8(%rsp)
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,0x128(%rsp)
mov    %rbx,0x118(%rsp)
shl    $0x5,%rbx
mov    %rbx,0xb8(%rsp)
add    $0x10,%r15
mov    %r15,0x108(%rsp)
lea    -0x1(%rbp),%r10
lea    0x10(%rsi),%rax
mov    %rax,0xd0(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x110(%rsp)
movl   $0x1,0x4c(%rsp)
mov    %r10,0x78(%rsp)
movsd  %xmm5,0x130(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x40(%rsp)
movl   $0x0,0x8(%rsp)
mov    $0x0,%r15d
test   %edi,%edi
js     19c0 <simplex+0x850>
xor    %eax,%eax
xor    %ecx,%ecx
cmp    $0x3,%r10
jae    1920 <simplex+0x7b0>
mov    0x10(%rsp),%r10
mov    0xf8(%rsp),%r11
mov    0xf0(%rsp),%r15
mov    %ecx,%ebp
test   %r11,%r11
je     1810 <simplex+0x6a0>
mov    %r11,%rdx
jmp    17ec <simplex+0x67c>
nopl   (%rax)
add    $0x1,%rax
mov    %ebp,%ecx
add    $0xffffffffffffffff,%rdx
je     1810 <simplex+0x6a0>
movsd  (%r14,%rax,8),%xmm0
movslq %ecx,%rbx
ucomisd (%r14,%rbx,8),%xmm0
mov    %eax,%ebp
ja     17e0 <simplex+0x670>
mov    %ecx,%ebp
jmp    17e0 <simplex+0x670>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %edi,%edi
mov    %ebp,0x8(%rsp)
js     19b0 <simplex+0x840>
cmpq   $0x3,0x78(%rsp)
jae    1b41 <simplex+0x9d1>
xor    %eax,%eax
xor    %ecx,%ecx
mov    %ecx,%r15d
test   $0x3,%r10b
je     1870 <simplex+0x700>
mov    %r11,%rdx
jmp    184d <simplex+0x6dd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %r15d,%ecx
add    $0xffffffffffffffff,%rdx
je     1870 <simplex+0x700>
movslq %ecx,%rbx
movsd  (%r14,%rbx,8),%xmm0
ucomisd (%r14,%rax,8),%xmm0
mov    %eax,%r15d
ja     1840 <simplex+0x6d0>
mov    %ecx,%r15d
jmp    1840 <simplex+0x6d0>
cs nopw 0x0(%rax,%rax,1)
test   %edi,%edi
mov    %r15d,0x40(%rsp)
js     1bb5 <simplex+0xa45>
movslq %ebp,%rax
mov    0x78(%rsp),%r10
xor    %ecx,%ecx
test   %r10,%r10
jne    18d9 <simplex+0x769>
testb  $0x1,0x10(%rsp)
je     19c0 <simplex+0x850>
movsd  (%r14,%rcx,8),%xmm0
movslq %r15d,%rdx
ucomisd (%r14,%rdx,8),%xmm0
jbe    19c0 <simplex+0x850>
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    19c0 <simplex+0x850>
mov    %ecx,%r15d
test   %edi,%edi
jg     19c8 <simplex+0x858>
jmp    1cc0 <simplex+0xb50>
nopl   0x0(%rax)
add    $0x2,%rcx
cmp    %rcx,%r12
je     188c <simplex+0x71c>
movsd  (%r14,%rcx,8),%xmm0
movslq %r15d,%rdx
ucomisd (%r14,%rdx,8),%xmm0
jbe    18f9 <simplex+0x789>
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    18f9 <simplex+0x789>
mov    %ecx,%r15d
movsd  0x8(%r14,%rcx,8),%xmm0
movslq %r15d,%rdx
ucomisd (%r14,%rdx,8),%xmm0
jbe    18d0 <simplex+0x760>
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    18d0 <simplex+0x760>
lea    0x1(%rcx),%r15d
jmp    18d0 <simplex+0x760>
nopl   (%rax)
mov    0x10(%rsp),%r10
mov    0xf8(%rsp),%r11
mov    0xf0(%rsp),%r15
jmp    194f <simplex+0x7df>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ecx
add    $0x4,%rax
cmp    %r15,%rax
je     17d1 <simplex+0x661>
movslq %ecx,%rdx
movsd  (%r14,%rax,8),%xmm0
ucomisd (%r14,%rdx,8),%xmm0
mov    %eax,%edx
ja     1964 <simplex+0x7f4>
mov    %ecx,%edx
movsd  0x8(%r14,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%r14,%rcx,8),%xmm0
jbe    1979 <simplex+0x809>
lea    0x1(%rax),%edx
movsd  0x10(%r14,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%r14,%rcx,8),%xmm0
jbe    198e <simplex+0x81e>
lea    0x2(%rax),%edx
movsd  0x18(%r14,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%r14,%rcx,8),%xmm0
jbe    1940 <simplex+0x7d0>
lea    0x3(%rax),%ecx
jmp    1942 <simplex+0x7d2>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,0x40(%rsp)
xor    %r15d,%r15d
mov    0x78(%rsp),%r10
test   %edi,%edi
jle    1cc0 <simplex+0xb50>
mov    0x8(%rsp),%eax
xor    %ecx,%ecx
jmp    19e7 <simplex+0x877>
divsd  %xmm5,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
cmp    %r9,%rcx
je     1a80 <simplex+0x910>
xorpd  %xmm0,%xmm0
test   %edi,%edi
js     19d0 <simplex+0x860>
test   %r10,%r10
je     1a50 <simplex+0x8e0>
xor    %edx,%edx
jmp    1a09 <simplex+0x899>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r12,%rdx
je     1a40 <simplex+0x8d0>
mov    %rdx,%rbx
cmp    %rdx,%rax
je     1a1b <simplex+0x8ab>
mov    0x0(%r13,%rbx,8),%rdx
addsd  (%rdx,%rcx,8),%xmm0
lea    0x1(%rbx),%rdx
cmp    %rax,%rdx
je     1a00 <simplex+0x890>
mov    0x8(%r13,%rbx,8),%rbp
addsd  0x0(%rbp,%rcx,8),%xmm0
jmp    1a00 <simplex+0x890>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
testb  $0x1,0x10(%rsp)
jne    1a5d <simplex+0x8ed>
jmp    19d0 <simplex+0x860>
nopl   (%rax)
xor    %ebx,%ebx
testb  $0x1,0x10(%rsp)
je     19d0 <simplex+0x860>
cmp    %rax,%rbx
je     19d0 <simplex+0x860>
mov    0x0(%r13,%rbx,8),%rdx
addsd  (%rdx,%rcx,8),%xmm0
jmp    19d0 <simplex+0x860>
cs nopw 0x0(%rax,%rax,1)
nop
test   %edi,%edi
jle    1cc0 <simplex+0xb50>
movslq 0x8(%rsp),%rax
mov    0x0(%r13,%rax,8),%rax
cmp    $0x4,%edi
jb     1ab8 <simplex+0x948>
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%rsi
setb   %cl
cmp    0xc8(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x35(%rsp),%dl
je     1bc7 <simplex+0xa57>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r9b
je     1ae2 <simplex+0x972>
movsd  (%r8,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x90(%rsp),%rdx
je     1cc0 <simplex+0xb50>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r8,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1b00 <simplex+0x990>
jmp    1cc0 <simplex+0xb50>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    1b5f <simplex+0x9ef>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ecx
add    $0x4,%rax
cmp    %r15,%rax
je     182c <simplex+0x6bc>
movslq %ecx,%rdx
movsd  (%r14,%rdx,8),%xmm0
ucomisd (%r14,%rax,8),%xmm0
mov    %eax,%edx
ja     1b74 <simplex+0xa04>
mov    %ecx,%edx
movslq %edx,%rcx
movsd  (%r14,%rcx,8),%xmm0
ucomisd 0x8(%r14,%rax,8),%xmm0
jbe    1b89 <simplex+0xa19>
lea    0x1(%rax),%edx
movslq %edx,%rcx
movsd  (%r14,%rcx,8),%xmm0
ucomisd 0x10(%r14,%rax,8),%xmm0
jbe    1b9e <simplex+0xa2e>
lea    0x2(%rax),%edx
movslq %edx,%rcx
movsd  (%r14,%rcx,8),%xmm0
ucomisd 0x18(%r14,%rax,8),%xmm0
jbe    1b50 <simplex+0x9e0>
lea    0x3(%rax),%ecx
jmp    1b52 <simplex+0x9e2>
mov    0x78(%rsp),%r10
test   %edi,%edi
jg     19c8 <simplex+0x858>
jmp    1cc0 <simplex+0xb50>
cmpq   $0x0,0x58(%rsp)
je     1dcb <simplex+0xc5b>
mov    0x88(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movupd (%r8,%rcx,8),%xmm0
movupd 0x10(%r8,%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,(%rsi,%rcx,8)
movupd %xmm2,0x10(%rsi,%rcx,8)
movupd 0x20(%r8,%rcx,8),%xmm0
movupd 0x30(%r8,%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(%rsi,%rcx,8)
movupd %xmm2,0x30(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1be0 <simplex+0xa70>
testb  $0x1,0x70(%rsp)
je     1ca9 <simplex+0xb39>
movupd (%r8,%rcx,8),%xmm0
movupd 0x10(%r8,%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,(%rsi,%rcx,8)
movupd %xmm2,0x10(%rsi,%rcx,8)
mov    0x60(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r9,%rcx
jne    1aba <simplex+0x94a>
nopw   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rdx
call   1070 <evaluate@plt>
movapd %xmm0,%xmm3
movslq %r15d,%r10
movsd  (%r14,%r10,8),%xmm0
ucomisd %xmm3,%xmm0
movslq 0x40(%rsp),%r11
mov    0xb0(%rsp),%r15
mov    0xb8(%rsp),%rax
jbe    1ea6 <simplex+0xd36>
ucomisd (%r14,%r11,8),%xmm3
jb     1ea6 <simplex+0xd36>
movslq 0x8(%rsp),%r8
mov    0x20(%rsp),%rdx
test   %edx,%edx
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%rbp
jle    1ea0 <simplex+0xd30>
mov    0x0(%r13,%r8,8),%rcx
cmp    $0x4,%edx
jb     1d42 <simplex+0xbd2>
cmp    0xc8(%rsp),%rcx
jae    1dbc <simplex+0xc4c>
lea    (%rcx,%rbp,8),%rdx
cmp    %rdx,%rbx
jae    1dbc <simplex+0xc4c>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rbp,%rsi
mov    0xa0(%rsp),%rdi
test   %rdi,%rdi
je     1d74 <simplex+0xc04>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1d60 <simplex+0xbf0>
cmp    $0x3,%rsi
jb     1ea0 <simplex+0xd30>
xchg   %ax,%ax
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1d80 <simplex+0xc10>
jmp    1ea0 <simplex+0xd30>
cmpq   $0xc,0x58(%rsp)
jae    1ddd <simplex+0xc6d>
xor    %edx,%edx
jmp    1e4c <simplex+0xcdc>
xor    %ecx,%ecx
testb  $0x1,0x70(%rsp)
jne    1c6e <simplex+0xafe>
jmp    1ca9 <simplex+0xb39>
mov    0x98(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm0
movups 0x30(%rbx,%rdx,8),%xmm1
movups %xmm0,0x20(%rcx,%rdx,8)
movups %xmm1,0x30(%rcx,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm0
movups 0x50(%rbx,%rdx,8),%xmm1
movups %xmm0,0x40(%rcx,%rdx,8)
movups %xmm1,0x50(%rcx,%rdx,8)
movupd 0x60(%rbx,%rdx,8),%xmm0
movupd 0x70(%rbx,%rdx,8),%xmm1
movupd %xmm0,0x60(%rcx,%rdx,8)
movupd %xmm1,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1df0 <simplex+0xc80>
cmpq   $0x0,0x118(%rsp)
je     1e8f <simplex+0xd1f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd0(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
nopl   (%rax)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rax
jne    1e70 <simplex+0xd00>
mov    0x60(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rbp,%rsi
jne    1d44 <simplex+0xbd4>
movsd  %xmm3,(%r14,%r8,8)
movsd  (%r14,%r11,8),%xmm0
ucomisd %xmm3,%xmm0
mov    0x50(%rsp),%rbx
mov    %r10,0x68(%rsp)
mov    %r11,0x140(%rsp)
jbe    1f00 <simplex+0xd90>
mov    0x20(%rsp),%rdi
test   %edi,%edi
mov    0x38(%rsp),%rdx
mov    0x18(%rsp),%rsi
movsd  %xmm3,0x100(%rsp)
jle    1f3a <simplex+0xdca>
cmp    $0x4,%edi
setb   %al
or     0x37(%rsp),%al
je     1f81 <simplex+0xe11>
xor    %ecx,%ecx
jmp    207a <simplex+0xf0a>
nopw   0x0(%rax,%rax,1)
addl   $0x1,0x2c(%rsp)
mov    0x38(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r15
movsd  0x20ef(%rip),%xmm4
movapd 0x2107(%rip),%xmm5
ucomisd (%r14,%r10,8),%xmm3
jae    2552 <simplex+0x13e2>
jmp    2d1b <simplex+0x1bab>
mov    %r15,%rsi
mov    0x80(%rsp),%rdx
call   1070 <evaluate@plt>
movsd  0x100(%rsp),%xmm3
mov    0x20(%rsp),%rdi
addl   $0x2,0x2c(%rsp)
ucomisd %xmm0,%xmm3
mov    0x10(%rsp),%r15
movsd  0x20a2(%rip),%xmm4
movapd 0x20ba(%rip),%xmm5
ja     21eb <simplex+0x107b>
jmp    21c9 <simplex+0x1059>
cmpq   $0x0,0x58(%rsp)
je     21d4 <simplex+0x1064>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movupd 0x20(%rdx,%rax,8),%xmm2
movupd 0x30(%rdx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r15,%rax,8)
movupd %xmm3,0x30(%r15,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1fa0 <simplex+0xe30>
testb  $0x1,0x70(%rsp)
je     2069 <simplex+0xef9>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
mov    0x60(%rsp),%rax
mov    %rax,%rcx
cmp    %rsi,%rax
je     2104 <simplex+0xf94>
mov    %rcx,%rax
test   $0x1,%sil
je     20a6 <simplex+0xf36>
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x90(%rsp),%rcx
je     2104 <simplex+0xf94>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  0x8(%rdx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    20c0 <simplex+0xf50>
mov    %r15,%rsi
mov    0x80(%rsp),%rdx
mov    %rdi,%rbx
call   1070 <evaluate@plt>
addl   $0x2,0x2c(%rsp)
movsd  0x100(%rsp),%xmm3
ucomisd %xmm0,%xmm3
jbe    2177 <simplex+0x1007>
test   %ebx,%ebx
mov    %rbx,%rdi
mov    0xb8(%rsp),%r10
movsd  0x1ed0(%rip),%xmm4
movapd 0x1ee8(%rip),%xmm5
jle    21e6 <simplex+0x1076>
movslq 0x8(%rsp),%r9
mov    0x0(%r13,%r9,8),%rcx
cmp    $0x4,%edi
jae    2209 <simplex+0x1099>
xor    %edx,%edx
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%rbx
mov    0x18(%rsp),%rbp
jmp    2235 <simplex+0x10c5>
test   %ebx,%ebx
mov    %rbx,%rdi
mov    0x10(%rsp),%r15
mov    0xb8(%rsp),%r10
movsd  0x1e7f(%rip),%xmm4
movapd 0x1e97(%rip),%xmm5
jle    21c9 <simplex+0x1059>
movslq 0x8(%rsp),%r9
mov    0x0(%r13,%r9,8),%rcx
cmp    $0x4,%edi
jae    22c0 <simplex+0x1150>
xor    %edx,%edx
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%rbx
mov    0x18(%rsp),%rbp
mov    0x68(%rsp),%r10
jmp    24c1 <simplex+0x1351>
movslq 0x8(%rsp),%r9
movapd %xmm3,%xmm0
jmp    21f0 <simplex+0x1080>
xor    %eax,%eax
testb  $0x1,0x70(%rsp)
jne    202e <simplex+0xebe>
jmp    2069 <simplex+0xef9>
mov    0x10(%rsp),%r15
movslq 0x8(%rsp),%r9
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%rbx
mov    0x18(%rsp),%rbp
mov    0x68(%rsp),%r10
jmp    2540 <simplex+0x13d0>
cmp    0x120(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%rbx
mov    0x18(%rsp),%rbp
jae    22ee <simplex+0x117e>
lea    (%rcx,%rbp,8),%rdx
cmp    %rdx,%r15
jae    22ee <simplex+0x117e>
xor    %edx,%edx
mov    0x68(%rsp),%r10
mov    %rdx,%rsi
not    %rsi
add    %rbp,%rsi
test   $0x3,%bpl
je     2275 <simplex+0x1105>
mov    0xa0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    2260 <simplex+0x10f0>
cmp    $0x3,%rsi
jb     23e5 <simplex+0x1275>
nop
movsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x8(%r15,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdx,8)
movsd  0x10(%r15,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rdx,8)
movsd  0x18(%r15,%rdx,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    2280 <simplex+0x1110>
jmp    23e5 <simplex+0x1275>
cmp    0xc8(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%rbx
mov    0x18(%rsp),%rbp
jae    22fd <simplex+0x118d>
lea    (%rcx,%rbp,8),%rdx
cmp    %rdx,%r8
jae    22fd <simplex+0x118d>
xor    %edx,%edx
mov    0x68(%rsp),%r10
jmp    24c1 <simplex+0x1351>
cmpq   $0xc,0x58(%rsp)
jae    2310 <simplex+0x11a0>
xor    %edx,%edx
jmp    2384 <simplex+0x1214>
cmpq   $0xc,0x58(%rsp)
jae    23ef <simplex+0x127f>
xor    %edx,%edx
jmp    2464 <simplex+0x12f4>
mov    0x98(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%r15,%rdx,8),%xmm1
movups 0x10(%r15,%rdx,8),%xmm2
movups %xmm1,(%rcx,%rdx,8)
movups %xmm2,0x10(%rcx,%rdx,8)
movups 0x20(%r15,%rdx,8),%xmm1
movups 0x30(%r15,%rdx,8),%xmm2
movups %xmm1,0x20(%rcx,%rdx,8)
movups %xmm2,0x30(%rcx,%rdx,8)
movups 0x40(%r15,%rdx,8),%xmm1
movups 0x50(%r15,%rdx,8),%xmm2
movups %xmm1,0x40(%rcx,%rdx,8)
movups %xmm2,0x50(%rcx,%rdx,8)
movupd 0x60(%r15,%rdx,8),%xmm1
movupd 0x70(%r15,%rdx,8),%xmm2
movupd %xmm1,0x60(%rcx,%rdx,8)
movupd %xmm2,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    2320 <simplex+0x11b0>
testb  $0x3,0x70(%rsp)
je     23cf <simplex+0x125f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0x108(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rax,1),%xmm1
movupd (%rdx,%rax,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rax,1)
movupd %xmm2,(%rsi,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    23b0 <simplex+0x1240>
mov    0x60(%rsp),%rax
mov    %rax,%rdx
cmp    %rbp,%rax
mov    0x68(%rsp),%r10
jne    223a <simplex+0x10ca>
mov    0x10(%rsp),%r15
jmp    2540 <simplex+0x13d0>
mov    0x98(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%r8,%rdx,8),%xmm0
movups 0x10(%r8,%rdx,8),%xmm1
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movups 0x20(%r8,%rdx,8),%xmm0
movups 0x30(%r8,%rdx,8),%xmm1
movups %xmm0,0x20(%rcx,%rdx,8)
movups %xmm1,0x30(%rcx,%rdx,8)
movups 0x40(%r8,%rdx,8),%xmm0
movups 0x50(%r8,%rdx,8),%xmm1
movups %xmm0,0x40(%rcx,%rdx,8)
movups %xmm1,0x50(%rcx,%rdx,8)
movupd 0x60(%r8,%rdx,8),%xmm0
movupd 0x70(%r8,%rdx,8),%xmm1
movupd %xmm0,0x60(%rcx,%rdx,8)
movupd %xmm1,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    2400 <simplex+0x1290>
testb  $0x3,0x70(%rsp)
je     24af <simplex+0x133f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd0(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rax,1),%xmm0
movupd (%rdx,%rax,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rax,1)
movupd %xmm1,(%rsi,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    2490 <simplex+0x1320>
mov    0x60(%rsp),%rax
mov    %rax,%rdx
cmp    %rbp,%rax
mov    0x68(%rsp),%r10
je     253b <simplex+0x13cb>
mov    %rdx,%rsi
not    %rsi
add    %rbp,%rsi
test   $0x3,%bpl
je     24f5 <simplex+0x1385>
mov    0xa0(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    24e0 <simplex+0x1370>
cmp    $0x3,%rsi
jb     253b <simplex+0x13cb>
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%r8,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%r8,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%r8,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    2500 <simplex+0x1390>
movapd %xmm3,%xmm0
nop
movsd  %xmm0,(%r14,%r9,8)
ucomisd (%r14,%r10,8),%xmm3
jb     2d1b <simplex+0x1bab>
movslq 0x8(%rsp),%rax
mov    %rax,0x8(%rsp)
movsd  (%r14,%rax,8),%xmm0
ucomisd %xmm3,%xmm0
mov    0xa8(%rsp),%rsi
jbe    2590 <simplex+0x1420>
test   %edi,%edi
jle    2900 <simplex+0x1790>
cmp    $0x4,%edi
setb   %al
or     0x34(%rsp),%al
je     265f <simplex+0x14ef>
xor    %ecx,%ecx
jmp    275a <simplex+0x15ea>
nop
test   %edi,%edi
jle    2900 <simplex+0x1790>
mov    0x8(%rsp),%rax
mov    0x0(%r13,%rax,8),%rax
cmp    $0x4,%edi
jb     25c8 <simplex+0x1458>
lea    (%rax,%rbp,8),%rcx
cmp    %rcx,%rsi
setb   %cl
cmp    0xd8(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x33(%rsp),%dl
je     27e9 <simplex+0x1679>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bpl
je     25f9 <simplex+0x1489>
movsd  (%rbx,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
mulsd  0x1a1f(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x90(%rsp),%rdx
je     2900 <simplex+0x1790>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0x19e2(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    2610 <simplex+0x14a0>
jmp    2900 <simplex+0x1790>
cmpq   $0x0,0x58(%rsp)
je     2c3a <simplex+0x1aca>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%r8,%rax,8),%xmm2
movupd 0x10(%r8,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movupd 0x20(%r8,%rax,8),%xmm2
movupd 0x30(%r8,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rsi,%rax,8)
movupd %xmm3,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2680 <simplex+0x1510>
testb  $0x1,0x70(%rsp)
je     2749 <simplex+0x15d9>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%r8,%rax,8),%xmm2
movupd 0x10(%r8,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
mov    0x60(%rsp),%rax
mov    %rax,%rcx
cmp    %rbp,%rax
je     2900 <simplex+0x1790>
mov    %rcx,%rax
test   $0x1,%bpl
je     2786 <simplex+0x1616>
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%r8,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x90(%rsp),%rcx
je     2900 <simplex+0x1790>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  (%r8,%rax,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  0x8(%r8,%rax,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    27a0 <simplex+0x1630>
jmp    2900 <simplex+0x1790>
cmpq   $0x0,0x58(%rsp)
movapd 0x1829(%rip),%xmm5
je     2f59 <simplex+0x1de9>
mov    0x88(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%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
mulpd  %xmm5,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm4,(%rsi,%rcx,8)
movupd %xmm2,0x10(%rsi,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm0
movupd 0x30(%rbx,%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
mulpd  %xmm5,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm4,0x20(%rsi,%rcx,8)
movupd %xmm2,0x30(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2810 <simplex+0x16a0>
testb  $0x1,0x70(%rsp)
je     28eb <simplex+0x177b>
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%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
mulpd  %xmm5,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm4,(%rsi,%rcx,8)
movupd %xmm2,0x10(%rsi,%rcx,8)
mov    0x60(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbp,%rcx
jne    25ca <simplex+0x145a>
nopl   0x0(%rax)
mov    0x80(%rsp),%rdx
mov    %rdi,%rbx
call   1070 <evaluate@plt>
mov    0x8(%rsp),%r11
movsd  (%r14,%r11,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    29e0 <simplex+0x1870>
test   %ebx,%ebx
mov    0xa8(%rsp),%rdi
mov    0x18(%rsp),%rbp
mov    0xb8(%rsp),%r8
jle    2d10 <simplex+0x1ba0>
mov    0x0(%r13,%r11,8),%rax
cmp    $0x4,%ebx
jb     2967 <simplex+0x17f7>
cmp    0xd8(%rsp),%rax
jae    2c2b <simplex+0x1abb>
lea    (%rax,%rbp,8),%rcx
cmp    %rcx,%rdi
jae    2c2b <simplex+0x1abb>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
test   $0x3,%bpl
je     2994 <simplex+0x1824>
mov    0xa0(%rsp),%rsi
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2980 <simplex+0x1810>
cmp    $0x3,%rdx
jb     2d10 <simplex+0x1ba0>
xchg   %ax,%ax
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
movsd  0x10(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rax,%rcx,8)
movsd  0x18(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    29a0 <simplex+0x1830>
jmp    2d10 <simplex+0x1ba0>
nopl   0x0(%rax)
test   %ebx,%ebx
mov    %rbx,%rdi
mov    0x18(%rsp),%rbp
mov    0x36(%rsp),%r9b
movsd  0x1619(%rip),%xmm6
movapd 0x1631(%rip),%xmm7
mov    0x140(%rsp),%r10
js     2be0 <simplex+0x1a70>
mov    0x40(%rsp),%r8d
xor    %ecx,%ecx
jmp    2a2d <simplex+0x18bd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r15,%rcx
je     2be0 <simplex+0x1a70>
cmp    %r8,%rcx
sete   %dl
or     %r9b,%dl
jne    2a20 <simplex+0x18b0>
mov    0x0(%r13,%r10,8),%rdx
mov    0x0(%r13,%rcx,8),%rsi
cmp    $0x4,%edi
jb     2a61 <simplex+0x18f1>
lea    (%rdx,%rbp,8),%rax
cmp    %rax,%rsi
jae    2ae7 <simplex+0x1977>
lea    (%rsi,%rbp,8),%rax
cmp    %rax,%rdx
jae    2ae7 <simplex+0x1977>
xor    %eax,%eax
mov    %rax,%rbx
test   $0x1,%bpl
je     2a8e <simplex+0x191e>
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    0x90(%rsp),%rax
je     2a20 <simplex+0x18b0>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,8),%xmm0
movsd  (%rsi,%rbx,8),%xmm1
movsd  0x8(%rsi,%rbx,8),%xmm2
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  0x8(%rdx,%rbx,8),%xmm0
subsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsi,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rbp
jne    2aa0 <simplex+0x1930>
jmp    2a20 <simplex+0x18b0>
cmpq   $0x0,0x58(%rsp)
je     2bd5 <simplex+0x1a65>
mov    0x88(%rsp),%rbx
xor    %eax,%eax
nopl   (%rax)
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
movupd 0x20(%rsi,%rax,8),%xmm4
movupd 0x30(%rsi,%rax,8),%xmm5
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm0,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm1,%xmm5
mulpd  %xmm7,%xmm4
mulpd  %xmm7,%xmm5
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm5
movupd %xmm4,0x20(%rsi,%rax,8)
movupd %xmm5,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    2b00 <simplex+0x1990>
testb  $0x1,0x70(%rsp)
je     2bbf <simplex+0x1a4f>
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm0,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
mov    0x60(%rsp),%rbx
mov    %rbx,%rax
cmp    %rbp,%rbx
je     2a20 <simplex+0x18b0>
jmp    2a63 <simplex+0x18f3>
xor    %eax,%eax
testb  $0x1,0x70(%rsp)
jne    2b86 <simplex+0x1a16>
jmp    2bbf <simplex+0x1a4f>
mov    0x0(%r13,%r11,8),%rsi
mov    0x80(%rsp),%rbx
mov    %rbx,%rdx
mov    %rdi,%r15
mov    %r11,%rbp
call   1070 <evaluate@plt>
movsd  %xmm0,(%r14,%rbp,8)
mov    0x68(%rsp),%rbp
mov    0x0(%r13,%rbp,8),%rsi
mov    %r15d,%edi
mov    0x10(%rsp),%r15
mov    %rbx,%rdx
call   1070 <evaluate@plt>
movsd  %xmm0,(%r14,%rbp,8)
addl   $0x3,0x2c(%rsp)
jmp    2d1b <simplex+0x1bab>
cmpq   $0xc,0x58(%rsp)
jae    2c4c <simplex+0x1adc>
xor    %ecx,%ecx
jmp    2cbc <simplex+0x1b4c>
xor    %eax,%eax
testb  $0x1,0x70(%rsp)
jne    270e <simplex+0x159e>
jmp    2749 <simplex+0x15d9>
mov    0x98(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rcx,8),%xmm1
movups 0x10(%rdi,%rcx,8),%xmm2
movups %xmm1,(%rax,%rcx,8)
movups %xmm2,0x10(%rax,%rcx,8)
movups 0x20(%rdi,%rcx,8),%xmm1
movups 0x30(%rdi,%rcx,8),%xmm2
movups %xmm1,0x20(%rax,%rcx,8)
movups %xmm2,0x30(%rax,%rcx,8)
movups 0x40(%rdi,%rcx,8),%xmm1
movups 0x50(%rdi,%rcx,8),%xmm2
movups %xmm1,0x40(%rax,%rcx,8)
movups %xmm2,0x50(%rax,%rcx,8)
movupd 0x60(%rdi,%rcx,8),%xmm1
movupd 0x70(%rdi,%rcx,8),%xmm2
movupd %xmm1,0x60(%rax,%rcx,8)
movupd %xmm2,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2c60 <simplex+0x1af0>
testb  $0x3,0x70(%rsp)
je     2cff <simplex+0x1b8f>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0x110(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    2ce0 <simplex+0x1b70>
mov    0x60(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
jne    2969 <simplex+0x17f9>
addl   $0x1,0x2c(%rsp)
movsd  %xmm0,(%r14,%r11,8)
lea    0x1328(%rip),%rdi
mov    0x4c(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
xorpd  %xmm2,%xmm2
cmpl   $0x0,0x20(%rsp)
js     2f00 <simplex+0x1d90>
xor    %ebx,%ebx
lea    0x12fb(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rbx,8),%rax
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
movsd  (%r14,%rbx,8),%xmm2
mov    %rbp,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    2d50 <simplex+0x1be0>
mov    0x20(%rsp),%rdx
test   %edx,%edx
xorpd  %xmm2,%xmm2
js     2f00 <simplex+0x1d90>
mov    0x78(%rsp),%rdi
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cmp    $0x7,%rdi
jae    2da3 <simplex+0x1c33>
mov    0xe8(%rsp),%rsi
jmp    2e00 <simplex+0x1c90>
mov    0xe8(%rsp),%rsi
mov    0x128(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%r14,%rax,8),%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
addsd  0x10(%r14,%rax,8),%xmm0
addsd  0x18(%r14,%rax,8),%xmm0
addsd  0x20(%r14,%rax,8),%xmm0
addsd  0x28(%r14,%rax,8),%xmm0
addsd  0x30(%r14,%rax,8),%xmm0
addsd  0x38(%r14,%rax,8),%xmm0
add    $0x8,%rax
cmp    %rax,%rcx
jne    2dc0 <simplex+0x1c50>
test   %rsi,%rsi
je     2e1e <simplex+0x1cae>
lea    (%r14,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    2e10 <simplex+0x1ca0>
test   %edx,%edx
js     2eae <simplex+0x1d3e>
divsd  0xe0(%rsp),%xmm0
test   %rdi,%rdi
movsd  %xmm0,0x8(%rsp)
xorpd  %xmm2,%xmm2
je     2eb4 <simplex+0x1d44>
xor    %ebx,%ebx
movsd  %xmm2,0x40(%rsp)
movsd  (%r14,%rbx,8),%xmm0
subsd  0x8(%rsp),%xmm0
movsd  0x11a6(%rip),%xmm1
call   1080 <pow@plt>
cltd
idivl  0x20(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%r14,%rbx,8),%xmm0
subsd  0x8(%rsp),%xmm0
movsd  0x1174(%rip),%xmm1
call   1080 <pow@plt>
cltd
idivl  0x20(%rsp)
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  0x40(%rsp),%xmm2
add    $0x2,%rbx
cmp    %rbx,%r12
jne    2e40 <simplex+0x1cd0>
jmp    2eb6 <simplex+0x1d46>
xorpd  %xmm2,%xmm2
jmp    2f00 <simplex+0x1d90>
xor    %ebx,%ebx
movsd  0x8(%rsp),%xmm1
test   $0x1,%r15b
je     2f00 <simplex+0x1d90>
movsd  (%r14,%rbx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0x112c(%rip),%xmm1
movsd  %xmm2,0x40(%rsp)
call   1080 <pow@plt>
movsd  0x40(%rsp),%xmm2
cltd
idivl  0x20(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm2,%xmm0
call   1090 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x138(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     2f6b <simplex+0x1dfb>
mov    0x4c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x4c(%rsp)
cmp    $0x3e9,%eax
mov    0x38(%rsp),%rsi
mov    0x50(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%r9
movsd  0x130(%rsp),%xmm5
mov    0x78(%rsp),%r10
jne    1790 <simplex+0x620>
jmp    2f77 <simplex+0x1e07>
xor    %ecx,%ecx
testb  $0x1,0x70(%rsp)
jne    28aa <simplex+0x173a>
jmp    28eb <simplex+0x177b>
mov    0x20(%rsp),%rdi
mov    0x78(%rsp),%r10
jmp    2f7f <simplex+0x1e0f>
movl   $0x3e9,0x4c(%rsp)
xor    %r15d,%r15d
test   %edi,%edi
js     2fa7 <simplex+0x1e37>
mov    0x10(%rsp),%rcx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%r10
jae    30c0 <simplex+0x1f50>
xor    %ecx,%ecx
mov    %r15d,%edx
test   %rax,%rax
jne    300d <simplex+0x1e9d>
movslq %edx,%r15
lea    0x10f5(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x20(%rsp)
jle    3025 <simplex+0x1eb5>
mov    0x0(%r13,%r15,8),%rsi
xor    %ebx,%ebx
mov    0xc0(%rsp),%rbp
mov    0x18(%rsp),%r12
xchg   %ax,%ax
movsd  (%rsi,%rbx,8),%xmm0
lea    0x107c(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x0(%r13,%r15,8),%rsi
movsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    2fd0 <simplex+0x1e60>
jmp    302a <simplex+0x1eba>
xchg   %ax,%ax
add    $0x1,%rcx
mov    %edx,%r15d
add    $0xffffffffffffffff,%rax
je     2fa4 <simplex+0x1e34>
movslq %r15d,%rdx
movsd  (%r14,%rdx,8),%xmm0
ucomisd (%r14,%rcx,8),%xmm0
mov    %ecx,%edx
ja     3000 <simplex+0x1e90>
mov    %r15d,%edx
jmp    3000 <simplex+0x1e90>
mov    0x0(%r13,%r15,8),%rsi
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%rdx
call   1070 <evaluate@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x2c(%rsp),%esi
add    $0x1,%esi
lea    0x100c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1017(%rip),%rdi
mov    0x4c(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x0(%r13),%rdi
call   1030 <free@plt>
movsd  0x10(%rsp),%xmm0
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%ecx
mov    %rcx,%rdi
xor    %ecx,%ecx
xor    %r15d,%r15d
jmp    30e0 <simplex+0x1f70>
nopl   (%rax)
mov    %edx,%r15d
add    $0x4,%rcx
cmp    %rdi,%rcx
je     2f9c <simplex+0x1e2c>
movslq %r15d,%rdx
movsd  (%r14,%rdx,8),%xmm0
ucomisd (%r14,%rcx,8),%xmm0
mov    %ecx,%edx
ja     30f6 <simplex+0x1f86>
mov    %r15d,%edx
movslq %edx,%rsi
movsd  (%r14,%rsi,8),%xmm0
ucomisd 0x8(%r14,%rcx,8),%xmm0
jbe    310b <simplex+0x1f9b>
lea    0x1(%rcx),%edx
movslq %edx,%rsi
movsd  (%r14,%rsi,8),%xmm0
ucomisd 0x10(%r14,%rcx,8),%xmm0
jbe    3120 <simplex+0x1fb0>
lea    0x2(%rcx),%edx
movslq %edx,%rsi
movsd  (%r14,%rsi,8),%xmm0
ucomisd 0x18(%r14,%rcx,8),%xmm0
jbe    30d0 <simplex+0x1f60>
lea    0x3(%rcx),%r15d
jmp    30d3 <simplex+0x1f63>

LLVM IR (-O0):
@.str = [16 x i8] c"Initial Values\0A\00"
@.str.1 = [10 x i8] c"%f %f %f\0A\00"
@.str.2 = [14 x i8] c"Iteration %d\0A\00"
@.str.3 = [26 x i8] c"The minimum was found at\0A\00"
@.str.4 = [4 x i8] c"%e\0A\00"
@.str.5 = [25 x i8] c"%d Function Evaluations\0A\00"
@.str.6 = [31 x i8] c"%d Iterations through program\0A\00"
define double @simplex(double* %0, i32 %1, double %2, double %3, i8* %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca double
%9 = alloca double
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca double**
%21 = alloca double
%22 = alloca double
%23 = alloca double*
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
store double* %0, double** %6
store i32 %1, i32* %7
store double %2, double* %8
store double %3, double* %9
store i8* %4, i8** %10
%36 = load i32, i32* %7
%37 = add nsw i32 %36, 1
%38 = sext i32 %37 to i64
%39 = mul i64 %38, 8
%40 = trunc i64 %39 to i32
%41 = call i64 @malloc(i32 %40)
%42 = inttoptr i64 %41 to double**
store double** %42, double*** %20
%43 = load i32, i32* %7
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = mul i64 %45, 8
%47 = trunc i64 %46 to i32
%48 = call i64 @malloc(i32 %47)
%49 = inttoptr i64 %48 to double*
store double* %49, double** %23
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = mul i64 %51, 8
%53 = trunc i64 %52 to i32
%54 = call i64 @malloc(i32 %53)
%55 = inttoptr i64 %54 to double*
store double* %55, double** %27
%56 = load i32, i32* %7
%57 = sext i32 %56 to i64
%58 = mul i64 %57, 8
%59 = trunc i64 %58 to i32
%60 = call i64 @malloc(i32 %59)
%61 = inttoptr i64 %60 to double*
store double* %61, double** %28
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = mul i64 %63, 8
%65 = trunc i64 %64 to i32
%66 = call i64 @malloc(i32 %65)
%67 = inttoptr i64 %66 to double*
store double* %67, double** %29
%68 = load i32, i32* %7
%69 = sext i32 %68 to i64
%70 = mul i64 %69, 8
%71 = trunc i64 %70 to i32
%72 = call i64 @malloc(i32 %71)
%73 = inttoptr i64 %72 to double*
store double* %73, double** %30
store i32 0, i32* %14
br label %74
74: ; preds = %89, %5
%75 = load i32, i32* %14
%76 = load i32, i32* %7
%77 = icmp sle i32 %75, %76
br i1 %77, label %78, label %92
78: ; preds = %74
%79 = load i32, i32* %7
%80 = sext i32 %79 to i64
%81 = mul i64 %80, 8
%82 = trunc i64 %81 to i32
%83 = call i64 @malloc(i32 %82)
%84 = inttoptr i64 %83 to double*
%85 = load double**, double*** %20
%86 = load i32, i32* %14
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double*, double** %85, i64 %87
store double* %84, double** %88
br label %89
89: ; preds = %78
%90 = load i32, i32* %14
%91 = add nsw i32 %90, 1
store i32 %91, i32* %14
br label %74
92: ; preds = %74
%93 = load double, double* %9
%94 = load i32, i32* %7
%95 = add nsw i32 %94, 1
%96 = sitofp i32 %95 to double
%97 = call i32 @sqrt(double %96)
%98 = sub nsw i32 %97, 1
%99 = load i32, i32* %7
%100 = add nsw i32 %98, %99
%101 = sitofp i32 %100 to double
%102 = fmul double %93, %101
%103 = load i32, i32* %7
%104 = call i32 @sqrt(double 2.000000e+00)
%105 = mul nsw i32 %103, %104
%106 = sitofp i32 %105 to double
%107 = fdiv double %102, %106
store double %107, double* %21
%108 = load double, double* %9
%109 = load i32, i32* %7
%110 = add nsw i32 %109, 1
%111 = sitofp i32 %110 to double
%112 = call i32 @sqrt(double %111)
%113 = sub nsw i32 %112, 1
%114 = sitofp i32 %113 to double
%115 = fmul double %108, %114
%116 = load i32, i32* %7
%117 = call i32 @sqrt(double 2.000000e+00)
%118 = mul nsw i32 %116, %117
%119 = sitofp i32 %118 to double
%120 = fdiv double %115, %119
store double %120, double* %22
store i32 0, i32* %14
br label %121
121: ; preds = %137, %92
%122 = load i32, i32* %14
%123 = load i32, i32* %7
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %140
125: ; preds = %121
%126 = load double*, double** %6
%127 = load i32, i32* %14
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %126, i64 %128
%130 = load double, double* %129
%131 = load double**, double*** %20
%132 = getelementptr inbounds double*, double** %131, i64 0
%133 = load double*, double** %132
%134 = load i32, i32* %14
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double %130, double* %136
br label %137
137: ; preds = %125
%138 = load i32, i32* %14
%139 = add nsw i32 %138, 1
store i32 %139, i32* %14
br label %121
140: ; preds = %121
store i32 1, i32* %14
br label %141
141: ; preds = %192, %140
%142 = load i32, i32* %14
%143 = load i32, i32* %7
%144 = icmp sle i32 %142, %143
br i1 %144, label %145, label %195
145: ; preds = %141
store i32 0, i32* %15
br label %146
146: ; preds = %188, %145
%147 = load i32, i32* %15
%148 = load i32, i32* %7
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %191
150: ; preds = %146
%151 = load i32, i32* %14
%152 = sub nsw i32 %151, 1
%153 = load i32, i32* %15
%154 = icmp eq i32 %152, %153
br i1 %154, label %155, label %171
155: ; preds = %150
%156 = load double, double* %21
%157 = load double*, double** %6
%158 = load i32, i32* %15
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
%161 = load double, double* %160
%162 = fadd double %156, %161
%163 = load double**, double*** %20
%164 = load i32, i32* %14
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double*, double** %163, i64 %165
%167 = load double*, double** %166
%168 = load i32, i32* %15
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
store double %162, double* %170
br label %187
171: ; preds = %150
%172 = load double, double* %22
%173 = load double*, double** %6
%174 = load i32, i32* %15
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %173, i64 %175
%177 = load double, double* %176
%178 = fadd double %172, %177
%179 = load double**, double*** %20
%180 = load i32, i32* %14
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double*, double** %179, i64 %181
%183 = load double*, double** %182
%184 = load i32, i32* %15
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
store double %178, double* %186
br label %187
187: ; preds = %171, %155
br label %188
188: ; preds = %187
%189 = load i32, i32* %15
%190 = add nsw i32 %189, 1
store i32 %190, i32* %15
br label %146
191: ; preds = %146
br label %192
192: ; preds = %191
%193 = load i32, i32* %14
%194 = add nsw i32 %193, 1
store i32 %194, i32* %14
br label %141
195: ; preds = %141
store i32 0, i32* %15
br label %196
196: ; preds = %213, %195
%197 = load i32, i32* %15
%198 = load i32, i32* %7
%199 = icmp sle i32 %197, %198
br i1 %199, label %200, label %216
200: ; preds = %196
%201 = load i32, i32* %7
%202 = load double**, double*** %20
%203 = load i32, i32* %15
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double*, double** %202, i64 %204
%206 = load double*, double** %205
%207 = load i8*, i8** %10
%208 = call double @evaluate(i32 %201, double* %206, i8* %207)
%209 = load double*, double** %23
%210 = load i32, i32* %15
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
store double %208, double* %212
br label %213
213: ; preds = %200
%214 = load i32, i32* %15
%215 = add nsw i32 %214, 1
store i32 %215, i32* %15
br label %196
216: ; preds = %196
%217 = load i32, i32* %7
%218 = add nsw i32 %217, 1
store i32 %218, i32* %18
%219 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %15
br label %220
220: ; preds = %245, %216
%221 = load i32, i32* %15
%222 = load i32, i32* %7
%223 = icmp sle i32 %221, %222
br i1 %223, label %224, label %248
224: ; preds = %220
%225 = load double**, double*** %20
%226 = load i32, i32* %15
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double*, double** %225, i64 %227
%229 = load double*, double** %228
%230 = getelementptr inbounds double, double* %229, i64 0
%231 = load double, double* %230
%232 = load double**, double*** %20
%233 = load i32, i32* %15
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double*, double** %232, i64 %234
%236 = load double*, double** %235
%237 = getelementptr inbounds double, double* %236, i64 1
%238 = load double, double* %237
%239 = load double*, double** %23
%240 = load i32, i32* %15
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %239, i64 %241
%243 = load double, double* %242
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), double %231, double %238, double %243)
br label %245
245: ; preds = %224
%246 = load i32, i32* %15
%247 = add nsw i32 %246, 1
store i32 %247, i32* %15
br label %220
248: ; preds = %220
store i32 1, i32* %19
br label %249
249: ; preds = %887, %248
%250 = load i32, i32* %19
%251 = icmp sle i32 %250, 1000
br i1 %251, label %252, label %890
252: ; preds = %249
store i32 0, i32* %13
store i32 0, i32* %15
br label %253
253: ; preds = %272, %252
%254 = load i32, i32* %15
%255 = load i32, i32* %7
%256 = icmp sle i32 %254, %255
br i1 %256, label %257, label %275
257: ; preds = %253
%258 = load double*, double** %23
%259 = load i32, i32* %15
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = load double*, double** %23
%264 = load i32, i32* %13
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %263, i64 %265
%267 = load double, double* %266
%268 = fcmp ogt double %262, %267
br i1 %268, label %269, label %271
269: ; preds = %257
%270 = load i32, i32* %15
store i32 %270, i32* %13
br label %271
271: ; preds = %269, %257
br label %272
272: ; preds = %271
%273 = load i32, i32* %15
%274 = add nsw i32 %273, 1
store i32 %274, i32* %15
br label %253
275: ; preds = %253
store i32 0, i32* %11
store i32 0, i32* %15
br label %276
276: ; preds = %295, %275
%277 = load i32, i32* %15
%278 = load i32, i32* %7
%279 = icmp sle i32 %277, %278
br i1 %279, label %280, label %298
280: ; preds = %276
%281 = load double*, double** %23
%282 = load i32, i32* %15
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = load double*, double** %23
%287 = load i32, i32* %11
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %286, i64 %288
%290 = load double, double* %289
%291 = fcmp olt double %285, %290
br i1 %291, label %292, label %294
292: ; preds = %280
%293 = load i32, i32* %15
store i32 %293, i32* %11
br label %294
294: ; preds = %292, %280
br label %295
295: ; preds = %294
%296 = load i32, i32* %15
%297 = add nsw i32 %296, 1
store i32 %297, i32* %15
br label %276
298: ; preds = %276
%299 = load i32, i32* %11
store i32 %299, i32* %12
store i32 0, i32* %15
br label %300
300: ; preds = %331, %298
%301 = load i32, i32* %15
%302 = load i32, i32* %7
%303 = icmp sle i32 %301, %302
br i1 %303, label %304, label %334
304: ; preds = %300
%305 = load double*, double** %23
%306 = load i32, i32* %15
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
%310 = load double*, double** %23
%311 = load i32, i32* %12
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %310, i64 %312
%314 = load double, double* %313
%315 = fcmp ogt double %309, %314
br i1 %315, label %316, label %330
316: ; preds = %304
%317 = load double*, double** %23
%318 = load i32, i32* %15
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
%322 = load double*, double** %23
%323 = load i32, i32* %13
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
%326 = load double, double* %325
%327 = fcmp olt double %321, %326
br i1 %327, label %328, label %330
328: ; preds = %316
%329 = load i32, i32* %15
store i32 %329, i32* %12
br label %330
330: ; preds = %328, %316, %304
br label %331
331: ; preds = %330
%332 = load i32, i32* %15
%333 = add nsw i32 %332, 1
store i32 %333, i32* %15
br label %300
334: ; preds = %300
store i32 0, i32* %15
br label %335
335: ; preds = %374, %334
%336 = load i32, i32* %15
%337 = load i32, i32* %7
%338 = sub nsw i32 %337, 1
%339 = icmp sle i32 %336, %338
br i1 %339, label %340, label %377
340: ; preds = %335
store double 0.000000e+00, double* %35
store i32 0, i32* %16
br label %341
341: ; preds = %362, %340
%342 = load i32, i32* %16
%343 = load i32, i32* %7
%344 = icmp sle i32 %342, %343
br i1 %344, label %345, label %365
345: ; preds = %341
%346 = load i32, i32* %16
%347 = load i32, i32* %13
%348 = icmp ne i32 %346, %347
br i1 %348, label %349, label %361
349: ; preds = %345
%350 = load double**, double*** %20
%351 = load i32, i32* %16
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double*, double** %350, i64 %352
%354 = load double*, double** %353
%355 = load i32, i32* %15
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %354, i64 %356
%358 = load double, double* %357
%359 = load double, double* %35
%360 = fadd double %359, %358
store double %360, double* %35
br label %361
361: ; preds = %349, %345
br label %362
362: ; preds = %361
%363 = load i32, i32* %16
%364 = add nsw i32 %363, 1
store i32 %364, i32* %16
br label %341
365: ; preds = %341
%366 = load double, double* %35
%367 = load i32, i32* %7
%368 = sitofp i32 %367 to double
%369 = fdiv double %366, %368
%370 = load double*, double** %30
%371 = load i32, i32* %15
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %370, i64 %372
store double %369, double* %373
br label %374
374: ; preds = %365
%375 = load i32, i32* %15
%376 = add nsw i32 %375, 1
store i32 %376, i32* %15
br label %335
377: ; preds = %335
store i32 0, i32* %15
br label %378
378: ; preds = %409, %377
%379 = load i32, i32* %15
%380 = load i32, i32* %7
%381 = sub nsw i32 %380, 1
%382 = icmp sle i32 %379, %381
br i1 %382, label %383, label %412
383: ; preds = %378
%384 = load double*, double** %30
%385 = load i32, i32* %15
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = load double*, double** %30
%390 = load i32, i32* %15
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %389, i64 %391
%393 = load double, double* %392
%394 = load double**, double*** %20
%395 = load i32, i32* %13
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double*, double** %394, i64 %396
%398 = load double*, double** %397
%399 = load i32, i32* %15
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %398, i64 %400
%402 = load double, double* %401
%403 = fsub double %393, %402
%404 = call double @llvm.fmuladd.f64(double 1.000000e+00, double %403, double %388)
%405 = load double*, double** %27
%406 = load i32, i32* %15
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %405, i64 %407
store double %404, double* %408
br label %409
409: ; preds = %383
%410 = load i32, i32* %15
%411 = add nsw i32 %410, 1
store i32 %411, i32* %15
br label %378
412: ; preds = %378
%413 = load i32, i32* %7
%414 = load double*, double** %27
%415 = load i8*, i8** %10
%416 = call double @evaluate(i32 %413, double* %414, i8* %415)
store double %416, double* %24
%417 = load i32, i32* %18
%418 = add nsw i32 %417, 1
store i32 %418, i32* %18
%419 = load double, double* %24
%420 = load double*, double** %23
%421 = load i32, i32* %12
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %420, i64 %422
%424 = load double, double* %423
%425 = fcmp olt double %419, %424
br i1 %425, label %426, label %463
426: ; preds = %412
%427 = load double, double* %24
%428 = load double*, double** %23
%429 = load i32, i32* %11
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %428, i64 %430
%432 = load double, double* %431
%433 = fcmp oge double %427, %432
br i1 %433, label %434, label %463
434: ; preds = %426
store i32 0, i32* %15
br label %435
435: ; preds = %454, %434
%436 = load i32, i32* %15
%437 = load i32, i32* %7
%438 = sub nsw i32 %437, 1
%439 = icmp sle i32 %436, %438
br i1 %439, label %440, label %457
440: ; preds = %435
%441 = load double*, double** %27
%442 = load i32, i32* %15
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %441, i64 %443
%445 = load double, double* %444
%446 = load double**, double*** %20
%447 = load i32, i32* %13
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double*, double** %446, i64 %448
%450 = load double*, double** %449
%451 = load i32, i32* %15
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %450, i64 %452
store double %445, double* %453
br label %454
454: ; preds = %440
%455 = load i32, i32* %15
%456 = add nsw i32 %455, 1
store i32 %456, i32* %15
br label %435
457: ; preds = %435
%458 = load double, double* %24
%459 = load double*, double** %23
%460 = load i32, i32* %13
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %459, i64 %461
store double %458, double* %462
br label %463
463: ; preds = %457, %426, %412
%464 = load double, double* %24
%465 = load double*, double** %23
%466 = load i32, i32* %11
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds double, double* %465, i64 %467
%469 = load double, double* %468
%470 = fcmp olt double %464, %469
br i1 %470, label %471, label %571
471: ; preds = %463
store i32 0, i32* %15
br label %472
472: ; preds = %499, %471
%473 = load i32, i32* %15
%474 = load i32, i32* %7
%475 = sub nsw i32 %474, 1
%476 = icmp sle i32 %473, %475
br i1 %476, label %477, label %502
477: ; preds = %472
%478 = load double*, double** %30
%479 = load i32, i32* %15
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %478, i64 %480
%482 = load double, double* %481
%483 = load double*, double** %27
%484 = load i32, i32* %15
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds double, double* %483, i64 %485
%487 = load double, double* %486
%488 = load double*, double** %30
%489 = load i32, i32* %15
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %488, i64 %490
%492 = load double, double* %491
%493 = fsub double %487, %492
%494 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %493, double %482)
%495 = load double*, double** %28
%496 = load i32, i32* %15
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %495, i64 %497
store double %494, double* %498
br label %499
499: ; preds = %477
%500 = load i32, i32* %15
%501 = add nsw i32 %500, 1
store i32 %501, i32* %15
br label %472
502: ; preds = %472
%503 = load i32, i32* %7
%504 = load double*, double** %28
%505 = load i8*, i8** %10
%506 = call double @evaluate(i32 %503, double* %504, i8* %505)
store double %506, double* %25
%507 = load i32, i32* %18
%508 = add nsw i32 %507, 1
store i32 %508, i32* %18
%509 = load double, double* %25
%510 = load double, double* %24
%511 = fcmp olt double %509, %510
br i1 %511, label %512, label %541
512: ; preds = %502
store i32 0, i32* %15
br label %513
513: ; preds = %532, %512
%514 = load i32, i32* %15
%515 = load i32, i32* %7
%516 = sub nsw i32 %515, 1
%517 = icmp sle i32 %514, %516
br i1 %517, label %518, label %535
518: ; preds = %513
%519 = load double*, double** %28
%520 = load i32, i32* %15
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double**, double*** %20
%525 = load i32, i32* %13
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double*, double** %524, i64 %526
%528 = load double*, double** %527
%529 = load i32, i32* %15
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds double, double* %528, i64 %530
store double %523, double* %531
br label %532
532: ; preds = %518
%533 = load i32, i32* %15
%534 = add nsw i32 %533, 1
store i32 %534, i32* %15
br label %513
535: ; preds = %513
%536 = load double, double* %25
%537 = load double*, double** %23
%538 = load i32, i32* %13
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %537, i64 %539
store double %536, double* %540
br label %570
541: ; preds = %502
store i32 0, i32* %15
br label %542
542: ; preds = %561, %541
%543 = load i32, i32* %15
%544 = load i32, i32* %7
%545 = sub nsw i32 %544, 1
%546 = icmp sle i32 %543, %545
br i1 %546, label %547, label %564
547: ; preds = %542
%548 = load double*, double** %27
%549 = load i32, i32* %15
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds double, double* %548, i64 %550
%552 = load double, double* %551
%553 = load double**, double*** %20
%554 = load i32, i32* %13
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double*, double** %553, i64 %555
%557 = load double*, double** %556
%558 = load i32, i32* %15
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds double, double* %557, i64 %559
store double %552, double* %560
br label %561
561: ; preds = %547
%562 = load i32, i32* %15
%563 = add nsw i32 %562, 1
store i32 %563, i32* %15
br label %542
564: ; preds = %542
%565 = load double, double* %24
%566 = load double*, double** %23
%567 = load i32, i32* %13
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds double, double* %566, i64 %568
store double %565, double* %569
br label %570
570: ; preds = %564, %535
br label %571
571: ; preds = %570, %463
%572 = load double, double* %24
%573 = load double*, double** %23
%574 = load i32, i32* %12
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double, double* %573, i64 %575
%577 = load double, double* %576
%578 = fcmp oge double %572, %577
br i1 %578, label %579, label %804
579: ; preds = %571
%580 = load double, double* %24
%581 = load double*, double** %23
%582 = load i32, i32* %13
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %581, i64 %583
%585 = load double, double* %584
%586 = fcmp olt double %580, %585
br i1 %586, label %587, label %633
587: ; preds = %579
%588 = load double, double* %24
%589 = load double*, double** %23
%590 = load i32, i32* %12
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %589, i64 %591
%593 = load double, double* %592
%594 = fcmp oge double %588, %593
br i1 %594, label %595, label %633
595: ; preds = %587
store i32 0, i32* %15
br label %596
596: ; preds = %623, %595
%597 = load i32, i32* %15
%598 = load i32, i32* %7
%599 = sub nsw i32 %598, 1
%600 = icmp sle i32 %597, %599
br i1 %600, label %601, label %626
601: ; preds = %596
%602 = load double*, double** %30
%603 = load i32, i32* %15
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %602, i64 %604
%606 = load double, double* %605
%607 = load double*, double** %27
%608 = load i32, i32* %15
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds double, double* %607, i64 %609
%611 = load double, double* %610
%612 = load double*, double** %30
%613 = load i32, i32* %15
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %612, i64 %614
%616 = load double, double* %615
%617 = fsub double %611, %616
%618 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %617, double %606)
%619 = load double*, double** %29
%620 = load i32, i32* %15
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %619, i64 %621
store double %618, double* %622
br label %623
623: ; preds = %601
%624 = load i32, i32* %15
%625 = add nsw i32 %624, 1
store i32 %625, i32* %15
br label %596
626: ; preds = %596
%627 = load i32, i32* %7
%628 = load double*, double** %29
%629 = load i8*, i8** %10
%630 = call double @evaluate(i32 %627, double* %628, i8* %629)
store double %630, double* %26
%631 = load i32, i32* %18
%632 = add nsw i32 %631, 1
store i32 %632, i32* %18
br label %675
633: ; preds = %587, %579
store i32 0, i32* %15
br label %634
634: ; preds = %665, %633
%635 = load i32, i32* %15
%636 = load i32, i32* %7
%637 = sub nsw i32 %636, 1
%638 = icmp sle i32 %635, %637
br i1 %638, label %639, label %668
639: ; preds = %634
%640 = load double*, double** %30
%641 = load i32, i32* %15
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %640, i64 %642
%644 = load double, double* %643
%645 = load double*, double** %30
%646 = load i32, i32* %15
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %645, i64 %647
%649 = load double, double* %648
%650 = load double**, double*** %20
%651 = load i32, i32* %13
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double*, double** %650, i64 %652
%654 = load double*, double** %653
%655 = load i32, i32* %15
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds double, double* %654, i64 %656
%658 = load double, double* %657
%659 = fsub double %649, %658
%660 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %659, double %644)
%661 = load double*, double** %29
%662 = load i32, i32* %15
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds double, double* %661, i64 %663
store double %660, double* %664
br label %665
665: ; preds = %639
%666 = load i32, i32* %15
%667 = add nsw i32 %666, 1
store i32 %667, i32* %15
br label %634
668: ; preds = %634
%669 = load i32, i32* %7
%670 = load double*, double** %29
%671 = load i8*, i8** %10
%672 = call double @evaluate(i32 %669, double* %670, i8* %671)
store double %672, double* %26
%673 = load i32, i32* %18
%674 = add nsw i32 %673, 1
store i32 %674, i32* %18
br label %675
675: ; preds = %668, %626
%676 = load double, double* %26
%677 = load double*, double** %23
%678 = load i32, i32* %13
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %677, i64 %679
%681 = load double, double* %680
%682 = fcmp olt double %676, %681
br i1 %682, label %683, label %712
683: ; preds = %675
store i32 0, i32* %15
br label %684
684: ; preds = %703, %683
%685 = load i32, i32* %15
%686 = load i32, i32* %7
%687 = sub nsw i32 %686, 1
%688 = icmp sle i32 %685, %687
br i1 %688, label %689, label %706
689: ; preds = %684
%690 = load double*, double** %29
%691 = load i32, i32* %15
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds double, double* %690, i64 %692
%694 = load double, double* %693
%695 = load double**, double*** %20
%696 = load i32, i32* %13
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds double*, double** %695, i64 %697
%699 = load double*, double** %698
%700 = load i32, i32* %15
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %699, i64 %701
store double %694, double* %702
br label %703
703: ; preds = %689
%704 = load i32, i32* %15
%705 = add nsw i32 %704, 1
store i32 %705, i32* %15
br label %684
706: ; preds = %684
%707 = load double, double* %26
%708 = load double*, double** %23
%709 = load i32, i32* %13
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %708, i64 %710
store double %707, double* %711
br label %803
712: ; preds = %675
store i32 0, i32* %17
br label %713
713: ; preds = %771, %712
%714 = load i32, i32* %17
%715 = load i32, i32* %7
%716 = icmp sle i32 %714, %715
br i1 %716, label %717, label %774
717: ; preds = %713
%718 = load i32, i32* %17
%719 = load i32, i32* %11
%720 = icmp ne i32 %718, %719
br i1 %720, label %721, label %770
721: ; preds = %717
store i32 0, i32* %15
br label %722
722: ; preds = %766, %721
%723 = load i32, i32* %15
%724 = load i32, i32* %7
%725 = sub nsw i32 %724, 1
%726 = icmp sle i32 %723, %725
br i1 %726, label %727, label %769
727: ; preds = %722
%728 = load double**, double*** %20
%729 = load i32, i32* %11
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds double*, double** %728, i64 %730
%732 = load double*, double** %731
%733 = load i32, i32* %15
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %732, i64 %734
%736 = load double, double* %735
%737 = load double**, double*** %20
%738 = load i32, i32* %17
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds double*, double** %737, i64 %739
%741 = load double*, double** %740
%742 = load i32, i32* %15
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds double, double* %741, i64 %743
%745 = load double, double* %744
%746 = load double**, double*** %20
%747 = load i32, i32* %11
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double*, double** %746, i64 %748
%750 = load double*, double** %749
%751 = load i32, i32* %15
%752 = sext i32 %751 to i64
%753 = getelementptr inbounds double, double* %750, i64 %752
%754 = load double, double* %753
%755 = fsub double %745, %754
%756 = fdiv double %755, 2.000000e+00
%757 = fadd double %736, %756
%758 = load double**, double*** %20
%759 = load i32, i32* %17
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds double*, double** %758, i64 %760
%762 = load double*, double** %761
%763 = load i32, i32* %15
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds double, double* %762, i64 %764
store double %757, double* %765
br label %766
766: ; preds = %727
%767 = load i32, i32* %15
%768 = add nsw i32 %767, 1
store i32 %768, i32* %15
br label %722
769: ; preds = %722
br label %770
770: ; preds = %769, %717
br label %771
771: ; preds = %770
%772 = load i32, i32* %17
%773 = add nsw i32 %772, 1
store i32 %773, i32* %17
br label %713
774: ; preds = %713
%775 = load i32, i32* %7
%776 = load double**, double*** %20
%777 = load i32, i32* %13
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double*, double** %776, i64 %778
%780 = load double*, double** %779
%781 = load i8*, i8** %10
%782 = call double @evaluate(i32 %775, double* %780, i8* %781)
%783 = load double*, double** %23
%784 = load i32, i32* %13
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %783, i64 %785
store double %782, double* %786
%787 = load i32, i32* %18
%788 = add nsw i32 %787, 1
store i32 %788, i32* %18
%789 = load i32, i32* %7
%790 = load double**, double*** %20
%791 = load i32, i32* %12
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds double*, double** %790, i64 %792
%794 = load double*, double** %793
%795 = load i8*, i8** %10
%796 = call double @evaluate(i32 %789, double* %794, i8* %795)
%797 = load double*, double** %23
%798 = load i32, i32* %12
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %797, i64 %799
store double %796, double* %800
%801 = load i32, i32* %18
%802 = add nsw i32 %801, 1
store i32 %802, i32* %18
br label %803
803: ; preds = %774, %706
br label %804
804: ; preds = %803, %571
%805 = load i32, i32* %19
%806 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), i32 %805)
store i32 0, i32* %15
br label %807
807: ; preds = %832, %804
%808 = load i32, i32* %15
%809 = load i32, i32* %7
%810 = icmp sle i32 %808, %809
br i1 %810, label %811, label %835
811: ; preds = %807
%812 = load double**, double*** %20
%813 = load i32, i32* %15
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds double*, double** %812, i64 %814
%816 = load double*, double** %815
%817 = getelementptr inbounds double, double* %816, i64 0
%818 = load double, double* %817
%819 = load double**, double*** %20
%820 = load i32, i32* %15
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double*, double** %819, i64 %821
%823 = load double*, double** %822
%824 = getelementptr inbounds double, double* %823, i64 1
%825 = load double, double* %824
%826 = load double*, double** %23
%827 = load i32, i32* %15
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds double, double* %826, i64 %828
%830 = load double, double* %829
%831 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), double %818, double %825, double %830)
br label %832
832: ; preds = %811
%833 = load i32, i32* %15
%834 = add nsw i32 %833, 1
store i32 %834, i32* %15
br label %807
835: ; preds = %807
store double 0.000000e+00, double* %32
store i32 0, i32* %15
br label %836
836: ; preds = %848, %835
%837 = load i32, i32* %15
%838 = load i32, i32* %7
%839 = icmp sle i32 %837, %838
br i1 %839, label %840, label %851
840: ; preds = %836
%841 = load double*, double** %23
%842 = load i32, i32* %15
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds double, double* %841, i64 %843
%845 = load double, double* %844
%846 = load double, double* %32
%847 = fadd double %846, %845
store double %847, double* %32
br label %848
848: ; preds = %840
%849 = load i32, i32* %15
%850 = add nsw i32 %849, 1
store i32 %850, i32* %15
br label %836
851: ; preds = %836
%852 = load double, double* %32
%853 = load i32, i32* %7
%854 = add nsw i32 %853, 1
%855 = sitofp i32 %854 to double
%856 = fdiv double %852, %855
store double %856, double* %33
store double 0.000000e+00, double* %34
store i32 0, i32* %15
br label %857
857: ; preds = %875, %851
%858 = load i32, i32* %15
%859 = load i32, i32* %7
%860 = icmp sle i32 %858, %859
br i1 %860, label %861, label %878
861: ; preds = %857
%862 = load double*, double** %23
%863 = load i32, i32* %15
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double, double* %862, i64 %864
%866 = load double, double* %865
%867 = load double, double* %33
%868 = fsub double %866, %867
%869 = call i32 @pow(double %868, double 2.000000e+00)
%870 = load i32, i32* %7
%871 = sdiv i32 %869, %870
%872 = sitofp i32 %871 to double
%873 = load double, double* %34
%874 = fadd double %873, %872
store double %874, double* %34
br label %875
875: ; preds = %861
%876 = load i32, i32* %15
%877 = add nsw i32 %876, 1
store i32 %877, i32* %15
br label %857
878: ; preds = %857
%879 = load double, double* %34
%880 = call i32 @sqrt(double %879)
%881 = sitofp i32 %880 to double
store double %881, double* %34
%882 = load double, double* %34
%883 = load double, double* %8
%884 = fcmp olt double %882, %883
br i1 %884, label %885, label %886
885: ; preds = %878
br label %890
886: ; preds = %878
br label %887
887: ; preds = %886
%888 = load i32, i32* %19
%889 = add nsw i32 %888, 1
store i32 %889, i32* %19
br label %249
890: ; preds = %885, %249
store i32 0, i32* %11
store i32 0, i32* %15
br label %891
891: ; preds = %910, %890
%892 = load i32, i32* %15
%893 = load i32, i32* %7
%894 = icmp sle i32 %892, %893
br i1 %894, label %895, label %913
895: ; preds = %891
%896 = load double*, double** %23
%897 = load i32, i32* %15
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds double, double* %896, i64 %898
%900 = load double, double* %899
%901 = load double*, double** %23
%902 = load i32, i32* %11
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds double, double* %901, i64 %903
%905 = load double, double* %904
%906 = fcmp olt double %900, %905
br i1 %906, label %907, label %909
907: ; preds = %895
%908 = load i32, i32* %15
store i32 %908, i32* %11
br label %909
909: ; preds = %907, %895
br label %910
910: ; preds = %909
%911 = load i32, i32* %15
%912 = add nsw i32 %911, 1
store i32 %912, i32* %15
br label %891
913: ; preds = %891
%914 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %15
br label %915
915: ; preds = %943, %913
%916 = load i32, i32* %15
%917 = load i32, i32* %7
%918 = icmp slt i32 %916, %917
br i1 %918, label %919, label %946
919: ; preds = %915
%920 = load double**, double*** %20
%921 = load i32, i32* %11
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds double*, double** %920, i64 %922
%924 = load double*, double** %923
%925 = load i32, i32* %15
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds double, double* %924, i64 %926
%928 = load double, double* %927
%929 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %928)
%930 = load double**, double*** %20
%931 = load i32, i32* %11
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds double*, double** %930, i64 %932
%934 = load double*, double** %933
%935 = load i32, i32* %15
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %934, i64 %936
%938 = load double, double* %937
%939 = load double*, double** %6
%940 = load i32, i32* %15
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds double, double* %939, i64 %941
store double %938, double* %942
br label %943
943: ; preds = %919
%944 = load i32, i32* %15
%945 = add nsw i32 %944, 1
store i32 %945, i32* %15
br label %915
946: ; preds = %915
%947 = load i32, i32* %7
%948 = load double**, double*** %20
%949 = load i32, i32* %11
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds double*, double** %948, i64 %950
%952 = load double*, double** %951
%953 = load i8*, i8** %10
%954 = call double @evaluate(i32 %947, double* %952, i8* %953)
store double %954, double* %31
%955 = load i32, i32* %18
%956 = add nsw i32 %955, 1
store i32 %956, i32* %18
%957 = load i32, i32* %18
%958 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0), i32 %957)
%959 = load i32, i32* %19
%960 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i32 %959)
%961 = load double*, double** %23
%962 = call i32 @free(double* %961)
%963 = load double*, double** %27
%964 = call i32 @free(double* %963)
%965 = load double*, double** %28
%966 = call i32 @free(double* %965)
%967 = load double*, double** %29
%968 = call i32 @free(double* %967)
%969 = load double*, double** %30
%970 = call i32 @free(double* %969)
%971 = load double**, double*** %20
%972 = load double*, double** %971
%973 = call i32 @free(double* %972)
%974 = load double, double* %31
ret double %974
}

LLVM IR (-O2):
@.str.1 = [10 x i8] c"%f %f %f\0A\00"
@.str.2 = [14 x i8] c"Iteration %d\0A\00"
@.str.4 = [4 x i8] c"%e\0A\00"
@.str.5 = [25 x i8] c"%d Function Evaluations\0A\00"
@.str.6 = [31 x i8] c"%d Iterations through program\0A\00"
@str = [15 x i8] c"Initial Values\00"
@str.7 = [25 x i8] c"The minimum was found at\00"
define double @simplex(double* nocapture %0, i32 %1, double %2, double %3, i8* %4) {
%6 = add i32 %1, 1
%7 = shl i32 %6, 3
%8 = tail call i64 @malloc(i32 %7)
%9 = inttoptr i64 %8 to double**
%10 = tail call i64 @malloc(i32 %7)
%11 = inttoptr i64 %10 to double*
%12 = shl i32 %1, 3
%13 = tail call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to double*
%15 = inttoptr i64 %13 to i8*
%16 = tail call i64 @malloc(i32 %12)
%17 = inttoptr i64 %16 to double*
%18 = inttoptr i64 %16 to i8*
%19 = tail call i64 @malloc(i32 %12)
%20 = inttoptr i64 %19 to double*
%21 = inttoptr i64 %19 to i8*
%22 = tail call i64 @malloc(i32 %12)
%23 = inttoptr i64 %22 to double*
%24 = inttoptr i64 %22 to i8*
%25 = icmp slt i32 %1, 0
br i1 %25, label %35, label %26
26: ; preds = %5
%27 = zext i32 %6 to i64
br label %28
28: ; preds = %26, %28
%29 = phi i64 [ 0, %26 ], [ %33, %28 ]
%30 = tail call i64 @malloc(i32 %12)
%31 = inttoptr i64 %30 to double*
%32 = getelementptr inbounds double*, double** %9, i64 %29
store double* %31, double** %32
%33 = add nuw nsw i64 %29, 1
%34 = icmp eq i64 %33, %27
br i1 %34, label %35, label %28
35: ; preds = %28, %5
%36 = sitofp i32 %6 to double
%37 = tail call i32 @sqrt(double %36)
%38 = add i32 %1, -1
%39 = add i32 %38, %37
%40 = sitofp i32 %39 to double
%41 = fmul double %40, %3
%42 = tail call i32 @sqrt(double 2.000000e+00)
%43 = mul nsw i32 %42, %1
%44 = sitofp i32 %43 to double
%45 = fdiv double %41, %44
%46 = tail call i32 @sqrt(double %36)
%47 = add nsw i32 %46, -1
%48 = sitofp i32 %47 to double
%49 = fmul double %48, %3
%50 = tail call i32 @sqrt(double 2.000000e+00)
%51 = mul nsw i32 %50, %1
%52 = sitofp i32 %51 to double
%53 = fdiv double %49, %52
%54 = icmp sgt i32 %1, 0
br i1 %54, label %55, label %196
55: ; preds = %35
%56 = load double*, double** %9
%57 = zext i32 %1 to i64
%58 = icmp ult i32 %1, 4
br i1 %58, label %144, label %59
59: ; preds = %55
%60 = getelementptr double, double* %56, i64 %57
%61 = getelementptr double, double* %0, i64 %57
%62 = icmp ult double* %56, %61
%63 = icmp ugt double* %60, %0
%64 = and i1 %62, %63
br i1 %64, label %144, label %65
65: ; preds = %59
%66 = and i64 %57, 4294967292
%67 = add nsw i64 %66, -4
%68 = lshr exact i64 %67, 2
%69 = add nuw nsw i64 %68, 1
%70 = and i64 %69, 3
%71 = icmp ult i64 %67, 12
br i1 %71, label %123, label %72
72: ; preds = %65
%73 = and i64 %69, 9223372036854775804
br label %74
74: ; preds = %74, %72
%75 = phi i64 [ 0, %72 ], [ %120, %74 ]
%76 = phi i64 [ 0, %72 ], [ %121, %74 ]
%77 = getelementptr inbounds double, double* %0, i64 %75
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = getelementptr inbounds double, double* %77, i64 2
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = getelementptr inbounds double, double* %56, i64 %75
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %79, <2 x double>* %84
%85 = getelementptr inbounds double, double* %83, i64 2
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %82, <2 x double>* %86
%87 = or i64 %75, 4
%88 = getelementptr inbounds double, double* %0, i64 %87
%89 = bitcast double* %88 to <2 x double>*
%90 = load <2 x double>, <2 x double>* %89
%91 = getelementptr inbounds double, double* %88, i64 2
%92 = bitcast double* %91 to <2 x double>*
%93 = load <2 x double>, <2 x double>* %92
%94 = getelementptr inbounds double, double* %56, i64 %87
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %90, <2 x double>* %95
%96 = getelementptr inbounds double, double* %94, i64 2
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> %93, <2 x double>* %97
%98 = or i64 %75, 8
%99 = getelementptr inbounds double, double* %0, i64 %98
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = getelementptr inbounds double, double* %99, i64 2
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = getelementptr inbounds double, double* %56, i64 %98
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %101, <2 x double>* %106
%107 = getelementptr inbounds double, double* %105, i64 2
%108 = bitcast double* %107 to <2 x double>*
store <2 x double> %104, <2 x double>* %108
%109 = or i64 %75, 12
%110 = getelementptr inbounds double, double* %0, i64 %109
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = getelementptr inbounds double, double* %110, i64 2
%114 = bitcast double* %113 to <2 x double>*
%115 = load <2 x double>, <2 x double>* %114
%116 = getelementptr inbounds double, double* %56, i64 %109
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %112, <2 x double>* %117
%118 = getelementptr inbounds double, double* %116, i64 2
%119 = bitcast double* %118 to <2 x double>*
store <2 x double> %115, <2 x double>* %119
%120 = add nuw i64 %75, 16
%121 = add nuw i64 %76, 4
%122 = icmp eq i64 %121, %73
br i1 %122, label %123, label %74
123: ; preds = %74, %65
%124 = phi i64 [ 0, %65 ], [ %120, %74 ]
%125 = icmp eq i64 %70, 0
br i1 %125, label %142, label %126
126: ; preds = %123, %126
%127 = phi i64 [ %139, %126 ], [ %124, %123 ]
%128 = phi i64 [ %140, %126 ], [ 0, %123 ]
%129 = getelementptr inbounds double, double* %0, i64 %127
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = getelementptr inbounds double, double* %129, i64 2
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %56, i64 %127
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %131, <2 x double>* %136
%137 = getelementptr inbounds double, double* %135, i64 2
%138 = bitcast double* %137 to <2 x double>*
store <2 x double> %134, <2 x double>* %138
%139 = add nuw i64 %127, 4
%140 = add i64 %128, 1
%141 = icmp eq i64 %140, %70
br i1 %141, label %142, label %126
142: ; preds = %126, %123
%143 = icmp eq i64 %66, %57
br i1 %143, label %162, label %144
144: ; preds = %59, %55, %142
%145 = phi i64 [ 0, %59 ], [ 0, %55 ], [ %66, %142 ]
%146 = xor i64 %145, -1
%147 = add nsw i64 %146, %57
%148 = and i64 %57, 3
%149 = icmp eq i64 %148, 0
br i1 %149, label %159, label %150
150: ; preds = %144, %150
%151 = phi i64 [ %156, %150 ], [ %145, %144 ]
%152 = phi i64 [ %157, %150 ], [ 0, %144 ]
%153 = getelementptr inbounds double, double* %0, i64 %151
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %56, i64 %151
store double %154, double* %155
%156 = add nuw nsw i64 %151, 1
%157 = add i64 %152, 1
%158 = icmp eq i64 %157, %148
br i1 %158, label %159, label %150
159: ; preds = %150, %144
%160 = phi i64 [ %145, %144 ], [ %156, %150 ]
%161 = icmp ult i64 %147, 3
br i1 %161, label %162, label %170
162: ; preds = %159, %170, %142
%163 = icmp slt i32 %1, 1
br i1 %163, label %196, label %164
164: ; preds = %162
%165 = zext i32 %6 to i64
%166 = and i64 %57, 1
%167 = icmp eq i32 %1, 1
%168 = and i64 %57, 4294967294
%169 = icmp eq i64 %166, 0
br label %189
170: ; preds = %159, %170
%171 = phi i64 [ %187, %170 ], [ %160, %159 ]
%172 = getelementptr inbounds double, double* %0, i64 %171
%173 = load double, double* %172
%174 = getelementptr inbounds double, double* %56, i64 %171
store double %173, double* %174
%175 = add nuw nsw i64 %171, 1
%176 = getelementptr inbounds double, double* %0, i64 %175
%177 = load double, double* %176
%178 = getelementptr inbounds double, double* %56, i64 %175
store double %177, double* %178
%179 = add nuw nsw i64 %171, 2
%180 = getelementptr inbounds double, double* %0, i64 %179
%181 = load double, double* %180
%182 = getelementptr inbounds double, double* %56, i64 %179
store double %181, double* %182
%183 = add nuw nsw i64 %171, 3
%184 = getelementptr inbounds double, double* %0, i64 %183
%185 = load double, double* %184
%186 = getelementptr inbounds double, double* %56, i64 %183
store double %185, double* %186
%187 = add nuw nsw i64 %171, 4
%188 = icmp eq i64 %187, %57
br i1 %188, label %162, label %170
189: ; preds = %231, %164
%190 = phi i64 [ 1, %164 ], [ %232, %231 ]
%191 = add nsw i64 %190, -1
%192 = getelementptr inbounds double*, double** %9, i64 %190
br i1 %167, label %221, label %193
193: ; preds = %189
%194 = load double*, double** %192
%195 = load double*, double** %192
br label %202
196: ; preds = %231, %35, %162
%197 = phi i1 [ true, %162 ], [ true, %35 ], [ %163, %231 ]
br i1 %25, label %198, label %200
198: ; preds = %196
%199 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str, i64 0, i64 0))
br label %246
200: ; preds = %196
%201 = zext i32 %6 to i64
br label %234
202: ; preds = %202, %193
%203 = phi i64 [ 0, %193 ], [ %218, %202 ]
%204 = phi i64 [ 0, %193 ], [ %219, %202 ]
%205 = icmp eq i64 %191, %203
%206 = getelementptr inbounds double, double* %0, i64 %203
%207 = select i1 %205, double %45, double %53
%208 = load double, double* %206
%209 = fadd double %207, %208
%210 = getelementptr inbounds double, double* %194, i64 %203
store double %209, double* %210
%211 = or i64 %203, 1
%212 = icmp eq i64 %191, %211
%213 = getelementptr inbounds double, double* %0, i64 %211
%214 = select i1 %212, double %45, double %53
%215 = load double, double* %213
%216 = fadd double %214, %215
%217 = getelementptr inbounds double, double* %195, i64 %211
store double %216, double* %217
%218 = add nuw nsw i64 %203, 2
%219 = add i64 %204, 2
%220 = icmp eq i64 %219, %168
br i1 %220, label %221, label %202
221: ; preds = %202, %189
%222 = phi i64 [ 0, %189 ], [ %218, %202 ]
br i1 %169, label %231, label %223
223: ; preds = %221
%224 = icmp eq i64 %191, %222
%225 = getelementptr inbounds double, double* %0, i64 %222
%226 = select i1 %224, double %45, double %53
%227 = load double, double* %225
%228 = fadd double %226, %227
%229 = load double*, double** %192
%230 = getelementptr inbounds double, double* %229, i64 %222
store double %228, double* %230
br label %231
231: ; preds = %221, %223
%232 = add nuw nsw i64 %190, 1
%233 = icmp eq i64 %232, %165
br i1 %233, label %196, label %189
234: ; preds = %200, %234
%235 = phi i64 [ 0, %200 ], [ %240, %234 ]
%236 = getelementptr inbounds double*, double** %9, i64 %235
%237 = load double*, double** %236
%238 = tail call double @evaluate(i32 %1, double* %237, i8* %4)
%239 = getelementptr inbounds double, double* %11, i64 %235
store double %238, double* %239
%240 = add nuw nsw i64 %235, 1
%241 = icmp eq i64 %240, %201
br i1 %241, label %242, label %234
242: ; preds = %234
%243 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str, i64 0, i64 0))
br i1 %25, label %246, label %244
244: ; preds = %242
%245 = zext i32 %6 to i64
br label %419
246: ; preds = %419, %198, %242
%247 = sitofp i32 %1 to double
%248 = zext i32 %1 to i64
%249 = zext i32 %1 to i64
%250 = zext i32 %1 to i64
%251 = zext i32 %1 to i64
%252 = zext i32 %1 to i64
%253 = zext i32 %1 to i64
%254 = zext i32 %1 to i64
%255 = zext i32 %1 to i64
%256 = zext i32 %6 to i64
%257 = zext i32 %1 to i64
%258 = zext i32 %1 to i64
%259 = zext i32 %6 to i64
%260 = getelementptr double, double* %20, i64 %248
%261 = getelementptr double, double* %20, i64 %248
%262 = bitcast double* %261 to i8*
%263 = getelementptr double, double* %23, i64 %248
%264 = bitcast double* %263 to i8*
%265 = getelementptr double, double* %14, i64 %248
%266 = bitcast double* %265 to i8*
%267 = getelementptr double, double* %20, i64 %248
%268 = bitcast double* %267 to i8*
%269 = getelementptr double, double* %23, i64 %248
%270 = bitcast double* %269 to i8*
%271 = getelementptr double, double* %17, i64 %248
%272 = getelementptr double, double* %14, i64 %248
%273 = getelementptr double, double* %17, i64 %248
%274 = bitcast double* %273 to i8*
%275 = getelementptr double, double* %23, i64 %248
%276 = bitcast double* %275 to i8*
%277 = getelementptr double, double* %14, i64 %248
%278 = bitcast double* %277 to i8*
%279 = getelementptr double, double* %14, i64 %248
%280 = getelementptr double, double* %14, i64 %248
%281 = bitcast double* %280 to i8*
%282 = getelementptr double, double* %23, i64 %248
%283 = bitcast double* %282 to i8*
%284 = add nsw i64 %256, -1
%285 = and i64 %248, 4294967292
%286 = add nsw i64 %285, -4
%287 = lshr exact i64 %286, 2
%288 = add nuw nsw i64 %287, 1
%289 = and i64 %256, 3
%290 = icmp ult i64 %284, 3
%291 = and i64 %256, 4294967292
%292 = icmp eq i64 %289, 0
%293 = and i64 %256, 3
%294 = icmp ult i64 %284, 3
%295 = and i64 %256, 4294967292
%296 = icmp eq i64 %293, 0
%297 = and i64 %256, 1
%298 = icmp eq i64 %284, 0
%299 = and i64 %256, 4294967294
%300 = icmp eq i64 %297, 0
%301 = and i64 %256, 1
%302 = icmp eq i64 %284, 0
%303 = and i64 %256, 4294967294
%304 = icmp eq i64 %301, 0
%305 = icmp ult i32 %1, 4
%306 = icmp ult i8* %15, %283
%307 = icmp ult i8* %24, %281
%308 = and i1 %306, %307
%309 = and i64 %248, 4294967292
%310 = and i64 %288, 1
%311 = icmp eq i64 %286, 0
%312 = and i64 %288, 9223372036854775806
%313 = icmp eq i64 %310, 0
%314 = icmp eq i64 %309, %248
%315 = and i64 %248, 1
%316 = icmp eq i64 %315, 0
%317 = sub nsw i64 0, %248
%318 = icmp ult i32 %1, 4
%319 = and i64 %248, 4294967292
%320 = and i64 %288, 3
%321 = icmp ult i64 %286, 12
%322 = and i64 %288, 9223372036854775804
%323 = icmp eq i64 %320, 0
%324 = icmp eq i64 %319, %248
%325 = and i64 %248, 3
%326 = icmp eq i64 %325, 0
%327 = icmp ult i32 %1, 4
%328 = icmp ult i8* %18, %276
%329 = icmp ult i8* %24, %274
%330 = and i1 %328, %329
%331 = icmp ult i8* %18, %278
%332 = icmp ult i8* %15, %274
%333 = and i1 %331, %332
%334 = or i1 %330, %333
%335 = and i64 %248, 4294967292
%336 = and i64 %288, 1
%337 = icmp eq i64 %286, 0
%338 = and i64 %288, 9223372036854775806
%339 = icmp eq i64 %336, 0
%340 = icmp eq i64 %335, %248
%341 = and i64 %248, 1
%342 = icmp eq i64 %341, 0
%343 = sub nsw i64 0, %248
%344 = icmp ult i32 %1, 4
%345 = and i64 %248, 4294967292
%346 = and i64 %288, 3
%347 = icmp ult i64 %286, 12
%348 = and i64 %288, 9223372036854775804
%349 = icmp eq i64 %346, 0
%350 = icmp eq i64 %345, %248
%351 = and i64 %248, 3
%352 = icmp eq i64 %351, 0
%353 = icmp ult i32 %1, 4
%354 = and i64 %248, 4294967292
%355 = and i64 %288, 3
%356 = icmp ult i64 %286, 12
%357 = and i64 %288, 9223372036854775804
%358 = icmp eq i64 %355, 0
%359 = icmp eq i64 %354, %248
%360 = and i64 %248, 3
%361 = icmp eq i64 %360, 0
%362 = icmp ult i32 %1, 4
%363 = icmp ult i8* %21, %270
%364 = icmp ult i8* %24, %268
%365 = and i1 %363, %364
%366 = and i64 %248, 4294967292
%367 = and i64 %288, 1
%368 = icmp eq i64 %286, 0
%369 = and i64 %288, 9223372036854775806
%370 = icmp eq i64 %367, 0
%371 = icmp eq i64 %366, %248
%372 = and i64 %248, 1
%373 = icmp eq i64 %372, 0
%374 = sub nsw i64 0, %248
%375 = icmp ult i32 %1, 4
%376 = icmp ult i8* %21, %264
%377 = icmp ult i8* %24, %262
%378 = and i1 %376, %377
%379 = icmp ult i8* %21, %266
%380 = icmp ult i8* %15, %262
%381 = and i1 %379, %380
%382 = or i1 %378, %381
%383 = and i64 %248, 4294967292
%384 = and i64 %288, 1
%385 = icmp eq i64 %286, 0
%386 = and i64 %288, 9223372036854775806
%387 = icmp eq i64 %384, 0
%388 = icmp eq i64 %383, %248
%389 = and i64 %248, 1
%390 = icmp eq i64 %389, 0
%391 = sub nsw i64 0, %248
%392 = icmp ult i32 %1, 4
%393 = and i64 %248, 4294967292
%394 = and i64 %288, 1
%395 = icmp eq i64 %286, 0
%396 = and i64 %288, 9223372036854775806
%397 = icmp eq i64 %394, 0
%398 = icmp eq i64 %393, %248
%399 = and i64 %248, 1
%400 = icmp eq i64 %399, 0
%401 = sub nsw i64 0, %248
%402 = icmp ult i32 %1, 4
%403 = and i64 %248, 4294967292
%404 = and i64 %288, 3
%405 = icmp ult i64 %286, 12
%406 = and i64 %288, 9223372036854775804
%407 = icmp eq i64 %404, 0
%408 = icmp eq i64 %403, %248
%409 = and i64 %248, 3
%410 = icmp eq i64 %409, 0
%411 = and i64 %256, 7
%412 = icmp ult i64 %284, 7
%413 = and i64 %256, 4294967288
%414 = icmp eq i64 %411, 0
%415 = and i64 %256, 1
%416 = icmp eq i64 %284, 0
%417 = and i64 %256, 4294967294
%418 = icmp eq i64 %415, 0
br label %431
419: ; preds = %244, %419
%420 = phi i64 [ 0, %244 ], [ %429, %419 ]
%421 = getelementptr inbounds double*, double** %9, i64 %420
%422 = load double*, double** %421
%423 = load double, double* %422
%424 = getelementptr inbounds double, double* %422, i64 1
%425 = load double, double* %424
%426 = getelementptr inbounds double, double* %11, i64 %420
%427 = load double, double* %426
%428 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), double %423, double %425, double %427)
%429 = add nuw nsw i64 %420, 1
%430 = icmp eq i64 %429, %245
br i1 %430, label %246, label %419
431: ; preds = %246, %1880
%432 = phi i32 [ %6, %246 ], [ %1769, %1880 ]
%433 = phi i32 [ 1, %246 ], [ %1881, %1880 ]
br i1 %25, label %581, label %434
434: ; preds = %431
br i1 %290, label %435, label %457
435: ; preds = %457, %434
%436 = phi i32 [ undef, %434 ], [ %495, %457 ]
%437 = phi i64 [ 0, %434 ], [ %496, %457 ]
%438 = phi i32 [ 0, %434 ], [ %495, %457 ]
br i1 %292, label %454, label %439
439: ; preds = %435, %439
%440 = phi i64 [ %451, %439 ], [ %437, %435 ]
%441 = phi i32 [ %450, %439 ], [ %438, %435 ]
%442 = phi i64 [ %452, %439 ], [ 0, %435 ]
%443 = getelementptr inbounds double, double* %11, i64 %440
%444 = load double, double* %443
%445 = sext i32 %441 to i64
%446 = getelementptr inbounds double, double* %11, i64 %445
%447 = load double, double* %446
%448 = fcmp ogt double %444, %447
%449 = trunc i64 %440 to i32
%450 = select i1 %448, i32 %449, i32 %441
%451 = add nuw nsw i64 %440, 1
%452 = add i64 %442, 1
%453 = icmp eq i64 %452, %289
br i1 %453, label %454, label %439
454: ; preds = %439, %435
%455 = phi i32 [ %436, %435 ], [ %450, %439 ]
br i1 %25, label %581, label %456
456: ; preds = %454
br i1 %294, label %499, label %523
457: ; preds = %434, %457
%458 = phi i64 [ %496, %457 ], [ 0, %434 ]
%459 = phi i32 [ %495, %457 ], [ 0, %434 ]
%460 = phi i64 [ %497, %457 ], [ 0, %434 ]
%461 = getelementptr inbounds double, double* %11, i64 %458
%462 = load double, double* %461
%463 = sext i32 %459 to i64
%464 = getelementptr inbounds double, double* %11, i64 %463
%465 = load double, double* %464
%466 = fcmp ogt double %462, %465
%467 = trunc i64 %458 to i32
%468 = select i1 %466, i32 %467, i32 %459
%469 = or i64 %458, 1
%470 = getelementptr inbounds double, double* %11, i64 %469
%471 = load double, double* %470
%472 = sext i32 %468 to i64
%473 = getelementptr inbounds double, double* %11, i64 %472
%474 = load double, double* %473
%475 = fcmp ogt double %471, %474
%476 = trunc i64 %469 to i32
%477 = select i1 %475, i32 %476, i32 %468
%478 = or i64 %458, 2
%479 = getelementptr inbounds double, double* %11, i64 %478
%480 = load double, double* %479
%481 = sext i32 %477 to i64
%482 = getelementptr inbounds double, double* %11, i64 %481
%483 = load double, double* %482
%484 = fcmp ogt double %480, %483
%485 = trunc i64 %478 to i32
%486 = select i1 %484, i32 %485, i32 %477
%487 = or i64 %458, 3
%488 = getelementptr inbounds double, double* %11, i64 %487
%489 = load double, double* %488
%490 = sext i32 %486 to i64
%491 = getelementptr inbounds double, double* %11, i64 %490
%492 = load double, double* %491
%493 = fcmp ogt double %489, %492
%494 = trunc i64 %487 to i32
%495 = select i1 %493, i32 %494, i32 %486
%496 = add nuw nsw i64 %458, 4
%497 = add i64 %460, 4
%498 = icmp eq i64 %497, %291
br i1 %498, label %435, label %457
499: ; preds = %523, %456
%500 = phi i32 [ undef, %456 ], [ %561, %523 ]
%501 = phi i64 [ 0, %456 ], [ %562, %523 ]
%502 = phi i32 [ 0, %456 ], [ %561, %523 ]
br i1 %296, label %518, label %503
503: ; preds = %499, %503
%504 = phi i64 [ %515, %503 ], [ %501, %499 ]
%505 = phi i32 [ %514, %503 ], [ %502, %499 ]
%506 = phi i64 [ %516, %503 ], [ 0, %499 ]
%507 = getelementptr inbounds double, double* %11, i64 %504
%508 = load double, double* %507
%509 = sext i32 %505 to i64
%510 = getelementptr inbounds double, double* %11, i64 %509
%511 = load double, double* %510
%512 = fcmp olt double %508, %511
%513 = trunc i64 %504 to i32
%514 = select i1 %512, i32 %513, i32 %505
%515 = add nuw nsw i64 %504, 1
%516 = add i64 %506, 1
%517 = icmp eq i64 %516, %293
br i1 %517, label %518, label %503
518: ; preds = %503, %499
%519 = phi i32 [ %500, %499 ], [ %514, %503 ]
br i1 %25, label %581, label %520
520: ; preds = %518
%521 = sext i32 %455 to i64
%522 = getelementptr inbounds double, double* %11, i64 %521
br i1 %298, label %565, label %587
523: ; preds = %456, %523
%524 = phi i64 [ %562, %523 ], [ 0, %456 ]
%525 = phi i32 [ %561, %523 ], [ 0, %456 ]
%526 = phi i64 [ %563, %523 ], [ 0, %456 ]
%527 = getelementptr inbounds double, double* %11, i64 %524
%528 = load double, double* %527
%529 = sext i32 %525 to i64
%530 = getelementptr inbounds double, double* %11, i64 %529
%531 = load double, double* %530
%532 = fcmp olt double %528, %531
%533 = trunc i64 %524 to i32
%534 = select i1 %532, i32 %533, i32 %525
%535 = or i64 %524, 1
%536 = getelementptr inbounds double, double* %11, i64 %535
%537 = load double, double* %536
%538 = sext i32 %534 to i64
%539 = getelementptr inbounds double, double* %11, i64 %538
%540 = load double, double* %539
%541 = fcmp olt double %537, %540
%542 = trunc i64 %535 to i32
%543 = select i1 %541, i32 %542, i32 %534
%544 = or i64 %524, 2
%545 = getelementptr inbounds double, double* %11, i64 %544
%546 = load double, double* %545
%547 = sext i32 %543 to i64
%548 = getelementptr inbounds double, double* %11, i64 %547
%549 = load double, double* %548
%550 = fcmp olt double %546, %549
%551 = trunc i64 %544 to i32
%552 = select i1 %550, i32 %551, i32 %543
%553 = or i64 %524, 3
%554 = getelementptr inbounds double, double* %11, i64 %553
%555 = load double, double* %554
%556 = sext i32 %552 to i64
%557 = getelementptr inbounds double, double* %11, i64 %556
%558 = load double, double* %557
%559 = fcmp olt double %555, %558
%560 = trunc i64 %553 to i32
%561 = select i1 %559, i32 %560, i32 %552
%562 = add nuw nsw i64 %524, 4
%563 = add i64 %526, 4
%564 = icmp eq i64 %563, %295
br i1 %564, label %499, label %523
565: ; preds = %616, %520
%566 = phi i32 [ undef, %520 ], [ %617, %616 ]
%567 = phi i64 [ 0, %520 ], [ %618, %616 ]
%568 = phi i32 [ %519, %520 ], [ %617, %616 ]
br i1 %300, label %581, label %569
569: ; preds = %565
%570 = getelementptr inbounds double, double* %11, i64 %567
%571 = load double, double* %570
%572 = sext i32 %568 to i64
%573 = getelementptr inbounds double, double* %11, i64 %572
%574 = load double, double* %573
%575 = fcmp ogt double %571, %574
br i1 %575, label %576, label %581
576: ; preds = %569
%577 = load double, double* %522
%578 = fcmp olt double %571, %577
br i1 %578, label %579, label %581
579: ; preds = %576
%580 = trunc i64 %567 to i32
br label %581
581: ; preds = %565, %579, %576, %569, %431, %454, %518
%582 = phi i32 [ %519, %518 ], [ 0, %454 ], [ 0, %431 ], [ %519, %569 ], [ %519, %576 ], [ %519, %579 ], [ %519, %565 ]
%583 = phi i32 [ %455, %518 ], [ %455, %454 ], [ 0, %431 ], [ %455, %569 ], [ %455, %576 ], [ %455, %579 ], [ %455, %565 ]
%584 = phi i32 [ %519, %518 ], [ 0, %454 ], [ 0, %431 ], [ %566, %565 ], [ %580, %579 ], [ %568, %576 ], [ %568, %569 ]
br i1 %54, label %585, label %786
585: ; preds = %581
%586 = zext i32 %583 to i64
br label %720
587: ; preds = %520, %616
%588 = phi i64 [ %618, %616 ], [ 0, %520 ]
%589 = phi i32 [ %617, %616 ], [ %519, %520 ]
%590 = phi i64 [ %619, %616 ], [ 0, %520 ]
%591 = getelementptr inbounds double, double* %11, i64 %588
%592 = load double, double* %591
%593 = sext i32 %589 to i64
%594 = getelementptr inbounds double, double* %11, i64 %593
%595 = load double, double* %594
%596 = fcmp ogt double %592, %595
br i1 %596, label %597, label %602
597: ; preds = %587
%598 = load double, double* %522
%599 = fcmp olt double %592, %598
br i1 %599, label %600, label %602
600: ; preds = %597
%601 = trunc i64 %588 to i32
br label %602
602: ; preds = %587, %597, %600
%603 = phi i32 [ %601, %600 ], [ %589, %597 ], [ %589, %587 ]
%604 = or i64 %588, 1
%605 = getelementptr inbounds double, double* %11, i64 %604
%606 = load double, double* %605
%607 = sext i32 %603 to i64
%608 = getelementptr inbounds double, double* %11, i64 %607
%609 = load double, double* %608
%610 = fcmp ogt double %606, %609
br i1 %610, label %611, label %616
611: ; preds = %602
%612 = load double, double* %522
%613 = fcmp olt double %606, %612
br i1 %613, label %614, label %616
614: ; preds = %611
%615 = trunc i64 %604 to i32
br label %616
616: ; preds = %614, %611, %602
%617 = phi i32 [ %615, %614 ], [ %603, %611 ], [ %603, %602 ]
%618 = add nuw nsw i64 %588, 2
%619 = add i64 %590, 2
%620 = icmp eq i64 %619, %299
br i1 %620, label %565, label %587
621: ; preds = %761
br i1 %54, label %622, label %786
622: ; preds = %621
%623 = sext i32 %583 to i64
%624 = getelementptr inbounds double*, double** %9, i64 %623
%625 = load double*, double** %624
br i1 %305, label %705, label %626
626: ; preds = %622
%627 = getelementptr double, double* %625, i64 %248
%628 = bitcast double* %627 to i8*
%629 = icmp ult i8* %15, %628
%630 = icmp ult double* %625, %280
%631 = and i1 %629, %630
%632 = or i1 %308, %631
br i1 %632, label %705, label %633
633: ; preds = %626
br i1 %311, label %681, label %634
634: ; preds = %633, %634
%635 = phi i64 [ %678, %634 ], [ 0, %633 ]
%636 = phi i64 [ %679, %634 ], [ 0, %633 ]
%637 = getelementptr inbounds double, double* %23, i64 %635
%638 = bitcast double* %637 to <2 x double>*
%639 = load <2 x double>, <2 x double>* %638
%640 = getelementptr inbounds double, double* %637, i64 2
%641 = bitcast double* %640 to <2 x double>*
%642 = load <2 x double>, <2 x double>* %641
%643 = getelementptr inbounds double, double* %625, i64 %635
%644 = bitcast double* %643 to <2 x double>*
%645 = load <2 x double>, <2 x double>* %644
%646 = getelementptr inbounds double, double* %643, i64 2
%647 = bitcast double* %646 to <2 x double>*
%648 = load <2 x double>, <2 x double>* %647
%649 = fsub <2 x double> %639, %645
%650 = fsub <2 x double> %642, %648
%651 = fadd <2 x double> %639, %649
%652 = fadd <2 x double> %642, %650
%653 = getelementptr inbounds double, double* %14, i64 %635
%654 = bitcast double* %653 to <2 x double>*
store <2 x double> %651, <2 x double>* %654
%655 = getelementptr inbounds double, double* %653, i64 2
%656 = bitcast double* %655 to <2 x double>*
store <2 x double> %652, <2 x double>* %656
%657 = or i64 %635, 4
%658 = getelementptr inbounds double, double* %23, i64 %657
%659 = bitcast double* %658 to <2 x double>*
%660 = load <2 x double>, <2 x double>* %659
%661 = getelementptr inbounds double, double* %658, i64 2
%662 = bitcast double* %661 to <2 x double>*
%663 = load <2 x double>, <2 x double>* %662
%664 = getelementptr inbounds double, double* %625, i64 %657
%665 = bitcast double* %664 to <2 x double>*
%666 = load <2 x double>, <2 x double>* %665
%667 = getelementptr inbounds double, double* %664, i64 2
%668 = bitcast double* %667 to <2 x double>*
%669 = load <2 x double>, <2 x double>* %668
%670 = fsub <2 x double> %660, %666
%671 = fsub <2 x double> %663, %669
%672 = fadd <2 x double> %660, %670
%673 = fadd <2 x double> %663, %671
%674 = getelementptr inbounds double, double* %14, i64 %657
%675 = bitcast double* %674 to <2 x double>*
store <2 x double> %672, <2 x double>* %675
%676 = getelementptr inbounds double, double* %674, i64 2
%677 = bitcast double* %676 to <2 x double>*
store <2 x double> %673, <2 x double>* %677
%678 = add nuw i64 %635, 8
%679 = add i64 %636, 2
%680 = icmp eq i64 %679, %312
br i1 %680, label %681, label %634
681: ; preds = %634, %633
%682 = phi i64 [ 0, %633 ], [ %678, %634 ]
br i1 %313, label %704, label %683
683: ; preds = %681
%684 = getelementptr inbounds double, double* %23, i64 %682
%685 = bitcast double* %684 to <2 x double>*
%686 = load <2 x double>, <2 x double>* %685
%687 = getelementptr inbounds double, double* %684, i64 2
%688 = bitcast double* %687 to <2 x double>*
%689 = load <2 x double>, <2 x double>* %688
%690 = getelementptr inbounds double, double* %625, i64 %682
%691 = bitcast double* %690 to <2 x double>*
%692 = load <2 x double>, <2 x double>* %691
%693 = getelementptr inbounds double, double* %690, i64 2
%694 = bitcast double* %693 to <2 x double>*
%695 = load <2 x double>, <2 x double>* %694
%696 = fsub <2 x double> %686, %692
%697 = fsub <2 x double> %689, %695
%698 = fadd <2 x double> %686, %696
%699 = fadd <2 x double> %689, %697
%700 = getelementptr inbounds double, double* %14, i64 %682
%701 = bitcast double* %700 to <2 x double>*
store <2 x double> %698, <2 x double>* %701
%702 = getelementptr inbounds double, double* %700, i64 2
%703 = bitcast double* %702 to <2 x double>*
store <2 x double> %699, <2 x double>* %703
br label %704
704: ; preds = %681, %683
br i1 %314, label %786, label %705
705: ; preds = %626, %622, %704
%706 = phi i64 [ 0, %626 ], [ 0, %622 ], [ %309, %704 ]
%707 = xor i64 %706, -1
br i1 %316, label %717, label %708
708: ; preds = %705
%709 = getelementptr inbounds double, double* %23, i64 %706
%710 = load double, double* %709
%711 = getelementptr inbounds double, double* %625, i64 %706
%712 = load double, double* %711
%713 = fsub double %710, %712
%714 = fadd double %710, %713
%715 = getelementptr inbounds double, double* %14, i64 %706
store double %714, double* %715
%716 = or i64 %706, 1
br label %717
717: ; preds = %708, %705
%718 = phi i64 [ %706, %705 ], [ %716, %708 ]
%719 = icmp eq i64 %707, %317
br i1 %719, label %786, label %767
720: ; preds = %585, %761
%721 = phi i64 [ 0, %585 ], [ %765, %761 ]
br i1 %25, label %761, label %722
722: ; preds = %720
br i1 %302, label %749, label %723
723: ; preds = %722, %744
%724 = phi i64 [ %746, %744 ], [ 0, %722 ]
%725 = phi double [ %745, %744 ], [ 0.000000e+00, %722 ]
%726 = phi i64 [ %747, %744 ], [ 0, %722 ]
%727 = icmp eq i64 %724, %586
br i1 %727, label %734, label %728
728: ; preds = %723
%729 = getelementptr inbounds double*, double** %9, i64 %724
%730 = load double*, double** %729
%731 = getelementptr inbounds double, double* %730, i64 %721
%732 = load double, double* %731
%733 = fadd double %725, %732
br label %734
734: ; preds = %723, %728
%735 = phi double [ %733, %728 ], [ %725, %723 ]
%736 = or i64 %724, 1
%737 = icmp eq i64 %736, %586
br i1 %737, label %744, label %738
738: ; preds = %734
%739 = getelementptr inbounds double*, double** %9, i64 %736
%740 = load double*, double** %739
%741 = getelementptr inbounds double, double* %740, i64 %721
%742 = load double, double* %741
%743 = fadd double %735, %742
br label %744
744: ; preds = %738, %734
%745 = phi double [ %743, %738 ], [ %735, %734 ]
%746 = add nuw nsw i64 %724, 2
%747 = add i64 %726, 2
%748 = icmp eq i64 %747, %303
br i1 %748, label %749, label %723
749: ; preds = %744, %722
%750 = phi double [ undef, %722 ], [ %745, %744 ]
%751 = phi i64 [ 0, %722 ], [ %746, %744 ]
%752 = phi double [ 0.000000e+00, %722 ], [ %745, %744 ]
br i1 %304, label %761, label %753
753: ; preds = %749
%754 = icmp eq i64 %751, %586
br i1 %754, label %761, label %755
755: ; preds = %753
%756 = getelementptr inbounds double*, double** %9, i64 %751
%757 = load double*, double** %756
%758 = getelementptr inbounds double, double* %757, i64 %721
%759 = load double, double* %758
%760 = fadd double %752, %759
br label %761
761: ; preds = %749, %755, %753, %720
%762 = phi double [ 0.000000e+00, %720 ], [ %750, %749 ], [ %760, %755 ], [ %752, %753 ]
%763 = fdiv double %762, %247
%764 = getelementptr inbounds double, double* %23, i64 %721
store double %763, double* %764
%765 = add nuw nsw i64 %721, 1
%766 = icmp eq i64 %765, %248
br i1 %766, label %621, label %720
767: ; preds = %717, %767
%768 = phi i64 [ %784, %767 ], [ %718, %717 ]
%769 = getelementptr inbounds double, double* %23, i64 %768
%770 = load double, double* %769
%771 = getelementptr inbounds double, double* %625, i64 %768
%772 = load double, double* %771
%773 = fsub double %770, %772
%774 = fadd double %770, %773
%775 = getelementptr inbounds double, double* %14, i64 %768
store double %774, double* %775
%776 = add nuw nsw i64 %768, 1
%777 = getelementptr inbounds double, double* %23, i64 %776
%778 = load double, double* %777
%779 = getelementptr inbounds double, double* %625, i64 %776
%780 = load double, double* %779
%781 = fsub double %778, %780
%782 = fadd double %778, %781
%783 = getelementptr inbounds double, double* %14, i64 %776
store double %782, double* %783
%784 = add nuw nsw i64 %768, 2
%785 = icmp eq i64 %784, %249
br i1 %785, label %786, label %767
786: ; preds = %717, %767, %704, %581, %621
%787 = tail call double @evaluate(i32 %1, double* %14, i8* %4)
%788 = add nsw i32 %432, 1
%789 = sext i32 %584 to i64
%790 = getelementptr inbounds double, double* %11, i64 %789
%791 = load double, double* %790
%792 = fcmp olt double %787, %791
%793 = sext i32 %582 to i64
br i1 %792, label %794, label %915
794: ; preds = %786
%795 = getelementptr inbounds double, double* %11, i64 %793
%796 = load double, double* %795
%797 = fcmp ult double %787, %796
br i1 %797, label %915, label %798
798: ; preds = %794
%799 = sext i32 %583 to i64
br i1 %54, label %800, label %913
800: ; preds = %798
%801 = getelementptr inbounds double*, double** %9, i64 %799
%802 = load double*, double** %801
br i1 %318, label %878, label %803
803: ; preds = %800
%804 = getelementptr double, double* %802, i64 %248
%805 = bitcast double* %804 to i8*
%806 = icmp ult double* %802, %279
%807 = icmp ult i8* %15, %805
%808 = and i1 %806, %807
br i1 %808, label %878, label %809
809: ; preds = %803
br i1 %321, label %859, label %810
810: ; preds = %809, %810
%811 = phi i64 [ %856, %810 ], [ 0, %809 ]
%812 = phi i64 [ %857, %810 ], [ 0, %809 ]
%813 = getelementptr inbounds double, double* %14, i64 %811
%814 = bitcast double* %813 to <2 x double>*
%815 = load <2 x double>, <2 x double>* %814
%816 = getelementptr inbounds double, double* %813, i64 2
%817 = bitcast double* %816 to <2 x double>*
%818 = load <2 x double>, <2 x double>* %817
%819 = getelementptr inbounds double, double* %802, i64 %811
%820 = bitcast double* %819 to <2 x double>*
store <2 x double> %815, <2 x double>* %820
%821 = getelementptr inbounds double, double* %819, i64 2
%822 = bitcast double* %821 to <2 x double>*
store <2 x double> %818, <2 x double>* %822
%823 = or i64 %811, 4
%824 = getelementptr inbounds double, double* %14, i64 %823
%825 = bitcast double* %824 to <2 x double>*
%826 = load <2 x double>, <2 x double>* %825
%827 = getelementptr inbounds double, double* %824, i64 2
%828 = bitcast double* %827 to <2 x double>*
%829 = load <2 x double>, <2 x double>* %828
%830 = getelementptr inbounds double, double* %802, i64 %823
%831 = bitcast double* %830 to <2 x double>*
store <2 x double> %826, <2 x double>* %831
%832 = getelementptr inbounds double, double* %830, i64 2
%833 = bitcast double* %832 to <2 x double>*
store <2 x double> %829, <2 x double>* %833
%834 = or i64 %811, 8
%835 = getelementptr inbounds double, double* %14, i64 %834
%836 = bitcast double* %835 to <2 x double>*
%837 = load <2 x double>, <2 x double>* %836
%838 = getelementptr inbounds double, double* %835, i64 2
%839 = bitcast double* %838 to <2 x double>*
%840 = load <2 x double>, <2 x double>* %839
%841 = getelementptr inbounds double, double* %802, i64 %834
%842 = bitcast double* %841 to <2 x double>*
store <2 x double> %837, <2 x double>* %842
%843 = getelementptr inbounds double, double* %841, i64 2
%844 = bitcast double* %843 to <2 x double>*
store <2 x double> %840, <2 x double>* %844
%845 = or i64 %811, 12
%846 = getelementptr inbounds double, double* %14, i64 %845
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = getelementptr inbounds double, double* %846, i64 2
%850 = bitcast double* %849 to <2 x double>*
%851 = load <2 x double>, <2 x double>* %850
%852 = getelementptr inbounds double, double* %802, i64 %845
%853 = bitcast double* %852 to <2 x double>*
store <2 x double> %848, <2 x double>* %853
%854 = getelementptr inbounds double, double* %852, i64 2
%855 = bitcast double* %854 to <2 x double>*
store <2 x double> %851, <2 x double>* %855
%856 = add nuw i64 %811, 16
%857 = add nuw i64 %812, 4
%858 = icmp eq i64 %857, %322
br i1 %858, label %859, label %810
859: ; preds = %810, %809
%860 = phi i64 [ 0, %809 ], [ %856, %810 ]
br i1 %323, label %877, label %861
861: ; preds = %859, %861
%862 = phi i64 [ %874, %861 ], [ %860, %859 ]
%863 = phi i64 [ %875, %861 ], [ 0, %859 ]
%864 = getelementptr inbounds double, double* %14, i64 %862
%865 = bitcast double* %864 to <2 x double>*
%866 = load <2 x double>, <2 x double>* %865
%867 = getelementptr inbounds double, double* %864, i64 2
%868 = bitcast double* %867 to <2 x double>*
%869 = load <2 x double>, <2 x double>* %868
%870 = getelementptr inbounds double, double* %802, i64 %862
%871 = bitcast double* %870 to <2 x double>*
store <2 x double> %866, <2 x double>* %871
%872 = getelementptr inbounds double, double* %870, i64 2
%873 = bitcast double* %872 to <2 x double>*
store <2 x double> %869, <2 x double>* %873
%874 = add nuw i64 %862, 4
%875 = add i64 %863, 1
%876 = icmp eq i64 %875, %320
br i1 %876, label %877, label %861
877: ; preds = %861, %859
br i1 %324, label %913, label %878
878: ; preds = %803, %800, %877
%879 = phi i64 [ 0, %803 ], [ 0, %800 ], [ %319, %877 ]
%880 = xor i64 %879, -1
%881 = add nsw i64 %880, %248
br i1 %326, label %891, label %882
882: ; preds = %878, %882
%883 = phi i64 [ %888, %882 ], [ %879, %878 ]
%884 = phi i64 [ %889, %882 ], [ 0, %878 ]
%885 = getelementptr inbounds double, double* %14, i64 %883
%886 = load double, double* %885
%887 = getelementptr inbounds double, double* %802, i64 %883
store double %886, double* %887
%888 = add nuw nsw i64 %883, 1
%889 = add i64 %884, 1
%890 = icmp eq i64 %889, %325
br i1 %890, label %891, label %882
891: ; preds = %882, %878
%892 = phi i64 [ %879, %878 ], [ %888, %882 ]
%893 = icmp ult i64 %881, 3
br i1 %893, label %913, label %894
894: ; preds = %891, %894
%895 = phi i64 [ %911, %894 ], [ %892, %891 ]
%896 = getelementptr inbounds double, double* %14, i64 %895
%897 = load double, double* %896
%898 = getelementptr inbounds double, double* %802, i64 %895
store double %897, double* %898
%899 = add nuw nsw i64 %895, 1
%900 = getelementptr inbounds double, double* %14, i64 %899
%901 = load double, double* %900
%902 = getelementptr inbounds double, double* %802, i64 %899
store double %901, double* %902
%903 = add nuw nsw i64 %895, 2
%904 = getelementptr inbounds double, double* %14, i64 %903
%905 = load double, double* %904
%906 = getelementptr inbounds double, double* %802, i64 %903
store double %905, double* %906
%907 = add nuw nsw i64 %895, 3
%908 = getelementptr inbounds double, double* %14, i64 %907
%909 = load double, double* %908
%910 = getelementptr inbounds double, double* %802, i64 %907
store double %909, double* %910
%911 = add nuw nsw i64 %895, 4
%912 = icmp eq i64 %911, %250
br i1 %912, label %913, label %894
913: ; preds = %891, %894, %877, %798
%914 = getelementptr inbounds double, double* %11, i64 %799
store double %787, double* %914
br label %915
915: ; preds = %786, %913, %794
%916 = getelementptr inbounds double, double* %11, i64 %793
%917 = load double, double* %916
%918 = fcmp olt double %787, %917
br i1 %918, label %919, label %1278
919: ; preds = %915
br i1 %54, label %920, label %1032
920: ; preds = %919
%921 = select i1 %327, i1 true, i1 %334
br i1 %921, label %994, label %922
922: ; preds = %920
br i1 %337, label %970, label %923
923: ; preds = %922, %923
%924 = phi i64 [ %967, %923 ], [ 0, %922 ]
%925 = phi i64 [ %968, %923 ], [ 0, %922 ]
%926 = getelementptr inbounds double, double* %23, i64 %924
%927 = bitcast double* %926 to <2 x double>*
%928 = load <2 x double>, <2 x double>* %927
%929 = getelementptr inbounds double, double* %926, i64 2
%930 = bitcast double* %929 to <2 x double>*
%931 = load <2 x double>, <2 x double>* %930
%932 = getelementptr inbounds double, double* %14, i64 %924
%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 = fsub <2 x double> %934, %928
%939 = fsub <2 x double> %937, %931
%940 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %938, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %928)
%941 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %939, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %931)
%942 = getelementptr inbounds double, double* %17, i64 %924
%943 = bitcast double* %942 to <2 x double>*
store <2 x double> %940, <2 x double>* %943
%944 = getelementptr inbounds double, double* %942, i64 2
%945 = bitcast double* %944 to <2 x double>*
store <2 x double> %941, <2 x double>* %945
%946 = or i64 %924, 4
%947 = getelementptr inbounds double, double* %23, i64 %946
%948 = bitcast double* %947 to <2 x double>*
%949 = load <2 x double>, <2 x double>* %948
%950 = getelementptr inbounds double, double* %947, i64 2
%951 = bitcast double* %950 to <2 x double>*
%952 = load <2 x double>, <2 x double>* %951
%953 = getelementptr inbounds double, double* %14, i64 %946
%954 = bitcast double* %953 to <2 x double>*
%955 = load <2 x double>, <2 x double>* %954
%956 = getelementptr inbounds double, double* %953, i64 2
%957 = bitcast double* %956 to <2 x double>*
%958 = load <2 x double>, <2 x double>* %957
%959 = fsub <2 x double> %955, %949
%960 = fsub <2 x double> %958, %952
%961 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %959, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %949)
%962 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %960, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %952)
%963 = getelementptr inbounds double, double* %17, i64 %946
%964 = bitcast double* %963 to <2 x double>*
store <2 x double> %961, <2 x double>* %964
%965 = getelementptr inbounds double, double* %963, i64 2
%966 = bitcast double* %965 to <2 x double>*
store <2 x double> %962, <2 x double>* %966
%967 = add nuw i64 %924, 8
%968 = add i64 %925, 2
%969 = icmp eq i64 %968, %338
br i1 %969, label %970, label %923
970: ; preds = %923, %922
%971 = phi i64 [ 0, %922 ], [ %967, %923 ]
br i1 %339, label %993, label %972
972: ; preds = %970
%973 = getelementptr inbounds double, double* %23, i64 %971
%974 = bitcast double* %973 to <2 x double>*
%975 = load <2 x double>, <2 x double>* %974
%976 = getelementptr inbounds double, double* %973, i64 2
%977 = bitcast double* %976 to <2 x double>*
%978 = load <2 x double>, <2 x double>* %977
%979 = getelementptr inbounds double, double* %14, i64 %971
%980 = bitcast double* %979 to <2 x double>*
%981 = load <2 x double>, <2 x double>* %980
%982 = getelementptr inbounds double, double* %979, i64 2
%983 = bitcast double* %982 to <2 x double>*
%984 = load <2 x double>, <2 x double>* %983
%985 = fsub <2 x double> %981, %975
%986 = fsub <2 x double> %984, %978
%987 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %985, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %975)
%988 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %986, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %978)
%989 = getelementptr inbounds double, double* %17, i64 %971
%990 = bitcast double* %989 to <2 x double>*
store <2 x double> %987, <2 x double>* %990
%991 = getelementptr inbounds double, double* %989, i64 2
%992 = bitcast double* %991 to <2 x double>*
store <2 x double> %988, <2 x double>* %992
br label %993
993: ; preds = %970, %972
br i1 %340, label %1028, label %994
994: ; preds = %920, %993
%995 = phi i64 [ 0, %920 ], [ %335, %993 ]
%996 = xor i64 %995, -1
br i1 %342, label %1006, label %997
997: ; preds = %994
%998 = getelementptr inbounds double, double* %23, i64 %995
%999 = load double, double* %998
%1000 = getelementptr inbounds double, double* %14, i64 %995
%1001 = load double, double* %1000
%1002 = fsub double %1001, %999
%1003 = tail call double @llvm.fmuladd.f64(double %1002, double 2.000000e+00, double %999)
%1004 = getelementptr inbounds double, double* %17, i64 %995
store double %1003, double* %1004
%1005 = or i64 %995, 1
br label %1006
1006: ; preds = %997, %994
%1007 = phi i64 [ %995, %994 ], [ %1005, %997 ]
%1008 = icmp eq i64 %996, %343
br i1 %1008, label %1028, label %1009
1009: ; preds = %1006, %1009
%1010 = phi i64 [ %1026, %1009 ], [ %1007, %1006 ]
%1011 = getelementptr inbounds double, double* %23, i64 %1010
%1012 = load double, double* %1011
%1013 = getelementptr inbounds double, double* %14, i64 %1010
%1014 = load double, double* %1013
%1015 = fsub double %1014, %1012
%1016 = tail call double @llvm.fmuladd.f64(double %1015, double 2.000000e+00, double %1012)
%1017 = getelementptr inbounds double, double* %17, i64 %1010
store double %1016, double* %1017
%1018 = add nuw nsw i64 %1010, 1
%1019 = getelementptr inbounds double, double* %23, i64 %1018
%1020 = load double, double* %1019
%1021 = getelementptr inbounds double, double* %14, i64 %1018
%1022 = load double, double* %1021
%1023 = fsub double %1022, %1020
%1024 = tail call double @llvm.fmuladd.f64(double %1023, double 2.000000e+00, double %1020)
%1025 = getelementptr inbounds double, double* %17, i64 %1018
store double %1024, double* %1025
%1026 = add nuw nsw i64 %1010, 2
%1027 = icmp eq i64 %1026, %251
br i1 %1027, label %1028, label %1009
1028: ; preds = %1006, %1009, %993
%1029 = tail call double @evaluate(i32 %1, double* %17, i8* %4)
%1030 = add nsw i32 %432, 2
%1031 = fcmp olt double %1029, %787
br i1 %1031, label %1135, label %1036
1032: ; preds = %919
%1033 = tail call double @evaluate(i32 %1, double* %17, i8* %4)
%1034 = add nsw i32 %432, 2
%1035 = fcmp olt double %1033, %787
br i1 %1035, label %1136, label %1037
1036: ; preds = %1028
br i1 %54, label %1040, label %1037
1037: ; preds = %1032, %1036
%1038 = phi i32 [ %1030, %1036 ], [ %1034, %1032 ]
%1039 = sext i32 %583 to i64
br label %1273
1040: ; preds = %1036
%1041 = sext i32 %583 to i64
%1042 = getelementptr inbounds double*, double** %9, i64 %1041
%1043 = load double*, double** %1042
br i1 %344, label %1119, label %1044
1044: ; preds = %1040
%1045 = getelementptr double, double* %1043, i64 %248
%1046 = bitcast double* %1045 to i8*
%1047 = icmp ult double* %1043, %272
%1048 = icmp ult i8* %15, %1046
%1049 = and i1 %1047, %1048
br i1 %1049, label %1119, label %1050
1050: ; preds = %1044
br i1 %347, label %1100, label %1051
1051: ; preds = %1050, %1051
%1052 = phi i64 [ %1097, %1051 ], [ 0, %1050 ]
%1053 = phi i64 [ %1098, %1051 ], [ 0, %1050 ]
%1054 = getelementptr inbounds double, double* %14, i64 %1052
%1055 = bitcast double* %1054 to <2 x double>*
%1056 = load <2 x double>, <2 x double>* %1055
%1057 = getelementptr inbounds double, double* %1054, i64 2
%1058 = bitcast double* %1057 to <2 x double>*
%1059 = load <2 x double>, <2 x double>* %1058
%1060 = getelementptr inbounds double, double* %1043, i64 %1052
%1061 = bitcast double* %1060 to <2 x double>*
store <2 x double> %1056, <2 x double>* %1061
%1062 = getelementptr inbounds double, double* %1060, i64 2
%1063 = bitcast double* %1062 to <2 x double>*
store <2 x double> %1059, <2 x double>* %1063
%1064 = or i64 %1052, 4
%1065 = getelementptr inbounds double, double* %14, i64 %1064
%1066 = bitcast double* %1065 to <2 x double>*
%1067 = load <2 x double>, <2 x double>* %1066
%1068 = getelementptr inbounds double, double* %1065, i64 2
%1069 = bitcast double* %1068 to <2 x double>*
%1070 = load <2 x double>, <2 x double>* %1069
%1071 = getelementptr inbounds double, double* %1043, i64 %1064
%1072 = bitcast double* %1071 to <2 x double>*
store <2 x double> %1067, <2 x double>* %1072
%1073 = getelementptr inbounds double, double* %1071, i64 2
%1074 = bitcast double* %1073 to <2 x double>*
store <2 x double> %1070, <2 x double>* %1074
%1075 = or i64 %1052, 8
%1076 = getelementptr inbounds double, double* %14, i64 %1075
%1077 = bitcast double* %1076 to <2 x double>*
%1078 = load <2 x double>, <2 x double>* %1077
%1079 = getelementptr inbounds double, double* %1076, i64 2
%1080 = bitcast double* %1079 to <2 x double>*
%1081 = load <2 x double>, <2 x double>* %1080
%1082 = getelementptr inbounds double, double* %1043, i64 %1075
%1083 = bitcast double* %1082 to <2 x double>*
store <2 x double> %1078, <2 x double>* %1083
%1084 = getelementptr inbounds double, double* %1082, i64 2
%1085 = bitcast double* %1084 to <2 x double>*
store <2 x double> %1081, <2 x double>* %1085
%1086 = or i64 %1052, 12
%1087 = getelementptr inbounds double, double* %14, i64 %1086
%1088 = bitcast double* %1087 to <2 x double>*
%1089 = load <2 x double>, <2 x double>* %1088
%1090 = getelementptr inbounds double, double* %1087, i64 2
%1091 = bitcast double* %1090 to <2 x double>*
%1092 = load <2 x double>, <2 x double>* %1091
%1093 = getelementptr inbounds double, double* %1043, i64 %1086
%1094 = bitcast double* %1093 to <2 x double>*
store <2 x double> %1089, <2 x double>* %1094
%1095 = getelementptr inbounds double, double* %1093, i64 2
%1096 = bitcast double* %1095 to <2 x double>*
store <2 x double> %1092, <2 x double>* %1096
%1097 = add nuw i64 %1052, 16
%1098 = add nuw i64 %1053, 4
%1099 = icmp eq i64 %1098, %348
br i1 %1099, label %1100, label %1051
1100: ; preds = %1051, %1050
%1101 = phi i64 [ 0, %1050 ], [ %1097, %1051 ]
br i1 %349, label %1118, label %1102
1102: ; preds = %1100, %1102
%1103 = phi i64 [ %1115, %1102 ], [ %1101, %1100 ]
%1104 = phi i64 [ %1116, %1102 ], [ 0, %1100 ]
%1105 = getelementptr inbounds double, double* %14, i64 %1103
%1106 = bitcast double* %1105 to <2 x double>*
%1107 = load <2 x double>, <2 x double>* %1106
%1108 = getelementptr inbounds double, double* %1105, i64 2
%1109 = bitcast double* %1108 to <2 x double>*
%1110 = load <2 x double>, <2 x double>* %1109
%1111 = getelementptr inbounds double, double* %1043, i64 %1103
%1112 = bitcast double* %1111 to <2 x double>*
store <2 x double> %1107, <2 x double>* %1112
%1113 = getelementptr inbounds double, double* %1111, i64 2
%1114 = bitcast double* %1113 to <2 x double>*
store <2 x double> %1110, <2 x double>* %1114
%1115 = add nuw i64 %1103, 4
%1116 = add i64 %1104, 1
%1117 = icmp eq i64 %1116, %346
br i1 %1117, label %1118, label %1102
1118: ; preds = %1102, %1100
br i1 %350, label %1273, label %1119
1119: ; preds = %1044, %1040, %1118
%1120 = phi i64 [ 0, %1044 ], [ 0, %1040 ], [ %345, %1118 ]
%1121 = xor i64 %1120, -1
%1122 = add nsw i64 %1121, %248
br i1 %352, label %1132, label %1123
1123: ; preds = %1119, %1123
%1124 = phi i64 [ %1129, %1123 ], [ %1120, %1119 ]
%1125 = phi i64 [ %1130, %1123 ], [ 0, %1119 ]
%1126 = getelementptr inbounds double, double* %14, i64 %1124
%1127 = load double, double* %1126
%1128 = getelementptr inbounds double, double* %1043, i64 %1124
store double %1127, double* %1128
%1129 = add nuw nsw i64 %1124, 1
%1130 = add i64 %1125, 1
%1131 = icmp eq i64 %1130, %351
br i1 %1131, label %1132, label %1123
1132: ; preds = %1123, %1119
%1133 = phi i64 [ %1120, %1119 ], [ %1129, %1123 ]
%1134 = icmp ult i64 %1122, 3
br i1 %1134, label %1273, label %1254
1135: ; preds = %1028
br i1 %54, label %1140, label %1136
1136: ; preds = %1032, %1135
%1137 = phi double [ %1029, %1135 ], [ %1033, %1032 ]
%1138 = phi i32 [ %1030, %1135 ], [ %1034, %1032 ]
%1139 = sext i32 %583 to i64
br label %1273
1140: ; preds = %1135
%1141 = sext i32 %583 to i64
%1142 = getelementptr inbounds double*, double** %9, i64 %1141
%1143 = load double*, double** %1142
br i1 %353, label %1219, label %1144
1144: ; preds = %1140
%1145 = getelementptr double, double* %1143, i64 %248
%1146 = bitcast double* %1145 to i8*
%1147 = icmp ult double* %1143, %271
%1148 = icmp ult i8* %18, %1146
%1149 = and i1 %1147, %1148
br i1 %1149, label %1219, label %1150
1150: ; preds = %1144
br i1 %356, label %1200, label %1151
1151: ; preds = %1150, %1151
%1152 = phi i64 [ %1197, %1151 ], [ 0, %1150 ]
%1153 = phi i64 [ %1198, %1151 ], [ 0, %1150 ]
%1154 = getelementptr inbounds double, double* %17, i64 %1152
%1155 = bitcast double* %1154 to <2 x double>*
%1156 = load <2 x double>, <2 x double>* %1155
%1157 = getelementptr inbounds double, double* %1154, i64 2
%1158 = bitcast double* %1157 to <2 x double>*
%1159 = load <2 x double>, <2 x double>* %1158
%1160 = getelementptr inbounds double, double* %1143, i64 %1152
%1161 = bitcast double* %1160 to <2 x double>*
store <2 x double> %1156, <2 x double>* %1161
%1162 = getelementptr inbounds double, double* %1160, i64 2
%1163 = bitcast double* %1162 to <2 x double>*
store <2 x double> %1159, <2 x double>* %1163
%1164 = or i64 %1152, 4
%1165 = getelementptr inbounds double, double* %17, i64 %1164
%1166 = bitcast double* %1165 to <2 x double>*
%1167 = load <2 x double>, <2 x double>* %1166
%1168 = getelementptr inbounds double, double* %1165, i64 2
%1169 = bitcast double* %1168 to <2 x double>*
%1170 = load <2 x double>, <2 x double>* %1169
%1171 = getelementptr inbounds double, double* %1143, i64 %1164
%1172 = bitcast double* %1171 to <2 x double>*
store <2 x double> %1167, <2 x double>* %1172
%1173 = getelementptr inbounds double, double* %1171, i64 2
%1174 = bitcast double* %1173 to <2 x double>*
store <2 x double> %1170, <2 x double>* %1174
%1175 = or i64 %1152, 8
%1176 = getelementptr inbounds double, double* %17, i64 %1175
%1177 = bitcast double* %1176 to <2 x double>*
%1178 = load <2 x double>, <2 x double>* %1177
%1179 = getelementptr inbounds double, double* %1176, i64 2
%1180 = bitcast double* %1179 to <2 x double>*
%1181 = load <2 x double>, <2 x double>* %1180
%1182 = getelementptr inbounds double, double* %1143, i64 %1175
%1183 = bitcast double* %1182 to <2 x double>*
store <2 x double> %1178, <2 x double>* %1183
%1184 = getelementptr inbounds double, double* %1182, i64 2
%1185 = bitcast double* %1184 to <2 x double>*
store <2 x double> %1181, <2 x double>* %1185
%1186 = or i64 %1152, 12
%1187 = getelementptr inbounds double, double* %17, i64 %1186
%1188 = bitcast double* %1187 to <2 x double>*
%1189 = load <2 x double>, <2 x double>* %1188
%1190 = getelementptr inbounds double, double* %1187, i64 2
%1191 = bitcast double* %1190 to <2 x double>*
%1192 = load <2 x double>, <2 x double>* %1191
%1193 = getelementptr inbounds double, double* %1143, i64 %1186
%1194 = bitcast double* %1193 to <2 x double>*
store <2 x double> %1189, <2 x double>* %1194
%1195 = getelementptr inbounds double, double* %1193, i64 2
%1196 = bitcast double* %1195 to <2 x double>*
store <2 x double> %1192, <2 x double>* %1196
%1197 = add nuw i64 %1152, 16
%1198 = add nuw i64 %1153, 4
%1199 = icmp eq i64 %1198, %357
br i1 %1199, label %1200, label %1151
1200: ; preds = %1151, %1150
%1201 = phi i64 [ 0, %1150 ], [ %1197, %1151 ]
br i1 %358, label %1218, label %1202
1202: ; preds = %1200, %1202
%1203 = phi i64 [ %1215, %1202 ], [ %1201, %1200 ]
%1204 = phi i64 [ %1216, %1202 ], [ 0, %1200 ]
%1205 = getelementptr inbounds double, double* %17, i64 %1203
%1206 = bitcast double* %1205 to <2 x double>*
%1207 = load <2 x double>, <2 x double>* %1206
%1208 = getelementptr inbounds double, double* %1205, i64 2
%1209 = bitcast double* %1208 to <2 x double>*
%1210 = load <2 x double>, <2 x double>* %1209
%1211 = getelementptr inbounds double, double* %1143, i64 %1203
%1212 = bitcast double* %1211 to <2 x double>*
store <2 x double> %1207, <2 x double>* %1212
%1213 = getelementptr inbounds double, double* %1211, i64 2
%1214 = bitcast double* %1213 to <2 x double>*
store <2 x double> %1210, <2 x double>* %1214
%1215 = add nuw i64 %1203, 4
%1216 = add i64 %1204, 1
%1217 = icmp eq i64 %1216, %355
br i1 %1217, label %1218, label %1202
1218: ; preds = %1202, %1200
br i1 %359, label %1273, label %1219
1219: ; preds = %1144, %1140, %1218
%1220 = phi i64 [ 0, %1144 ], [ 0, %1140 ], [ %354, %1218 ]
%1221 = xor i64 %1220, -1
%1222 = add nsw i64 %1221, %248
br i1 %361, label %1232, label %1223
1223: ; preds = %1219, %1223
%1224 = phi i64 [ %1229, %1223 ], [ %1220, %1219 ]
%1225 = phi i64 [ %1230, %1223 ], [ 0, %1219 ]
%1226 = getelementptr inbounds double, double* %17, i64 %1224
%1227 = load double, double* %1226
%1228 = getelementptr inbounds double, double* %1143, i64 %1224
store double %1227, double* %1228
%1229 = add nuw nsw i64 %1224, 1
%1230 = add i64 %1225, 1
%1231 = icmp eq i64 %1230, %360
br i1 %1231, label %1232, label %1223
1232: ; preds = %1223, %1219
%1233 = phi i64 [ %1220, %1219 ], [ %1229, %1223 ]
%1234 = icmp ult i64 %1222, 3
br i1 %1234, label %1273, label %1235
1235: ; preds = %1232, %1235
%1236 = phi i64 [ %1252, %1235 ], [ %1233, %1232 ]
%1237 = getelementptr inbounds double, double* %17, i64 %1236
%1238 = load double, double* %1237
%1239 = getelementptr inbounds double, double* %1143, i64 %1236
store double %1238, double* %1239
%1240 = add nuw nsw i64 %1236, 1
%1241 = getelementptr inbounds double, double* %17, i64 %1240
%1242 = load double, double* %1241
%1243 = getelementptr inbounds double, double* %1143, i64 %1240
store double %1242, double* %1243
%1244 = add nuw nsw i64 %1236, 2
%1245 = getelementptr inbounds double, double* %17, i64 %1244
%1246 = load double, double* %1245
%1247 = getelementptr inbounds double, double* %1143, i64 %1244
store double %1246, double* %1247
%1248 = add nuw nsw i64 %1236, 3
%1249 = getelementptr inbounds double, double* %17, i64 %1248
%1250 = load double, double* %1249
%1251 = getelementptr inbounds double, double* %1143, i64 %1248
store double %1250, double* %1251
%1252 = add nuw nsw i64 %1236, 4
%1253 = icmp eq i64 %1252, %253
br i1 %1253, label %1273, label %1235
1254: ; preds = %1132, %1254
%1255 = phi i64 [ %1271, %1254 ], [ %1133, %1132 ]
%1256 = getelementptr inbounds double, double* %14, i64 %1255
%1257 = load double, double* %1256
%1258 = getelementptr inbounds double, double* %1043, i64 %1255
store double %1257, double* %1258
%1259 = add nuw nsw i64 %1255, 1
%1260 = getelementptr inbounds double, double* %14, i64 %1259
%1261 = load double, double* %1260
%1262 = getelementptr inbounds double, double* %1043, i64 %1259
store double %1261, double* %1262
%1263 = add nuw nsw i64 %1255, 2
%1264 = getelementptr inbounds double, double* %14, i64 %1263
%1265 = load double, double* %1264
%1266 = getelementptr inbounds double, double* %1043, i64 %1263
store double %1265, double* %1266
%1267 = add nuw nsw i64 %1255, 3
%1268 = getelementptr inbounds double, double* %14, i64 %1267
%1269 = load double, double* %1268
%1270 = getelementptr inbounds double, double* %1043, i64 %1267
store double %1269, double* %1270
%1271 = add nuw nsw i64 %1255, 4
%1272 = icmp eq i64 %1271, %252
br i1 %1272, label %1273, label %1254
1273: ; preds = %1132, %1254, %1232, %1235, %1118, %1218, %1037, %1136
%1274 = phi i64 [ %1139, %1136 ], [ %1039, %1037 ], [ %1141, %1218 ], [ %1041, %1118 ], [ %1141, %1235 ], [ %1141, %1232 ], [ %1041, %1254 ], [ %1041, %1132 ]
%1275 = phi double [ %1137, %1136 ], [ %787, %1037 ], [ %1029, %1218 ], [ %787, %1118 ], [ %1029, %1235 ], [ %1029, %1232 ], [ %787, %1254 ], [ %787, %1132 ]
%1276 = phi i32 [ %1138, %1136 ], [ %1038, %1037 ], [ %1030, %1218 ], [ %1030, %1118 ], [ %1030, %1235 ], [ %1030, %1232 ], [ %1030, %1254 ], [ %1030, %1132 ]
%1277 = getelementptr inbounds double, double* %11, i64 %1274
store double %1275, double* %1277
br label %1278
1278: ; preds = %1273, %915
%1279 = phi i32 [ %788, %915 ], [ %1276, %1273 ]
%1280 = load double, double* %790
%1281 = fcmp ult double %787, %1280
br i1 %1281, label %1768, label %1282
1282: ; preds = %1278
%1283 = sext i32 %583 to i64
%1284 = getelementptr inbounds double, double* %11, i64 %1283
%1285 = load double, double* %1284
%1286 = fcmp olt double %787, %1285
br i1 %1286, label %1385, label %1287
1287: ; preds = %1282
br i1 %54, label %1288, label %1513
1288: ; preds = %1287
%1289 = getelementptr inbounds double*, double** %9, i64 %1283
%1290 = load double*, double** %1289
br i1 %362, label %1370, label %1291
1291: ; preds = %1288
%1292 = getelementptr double, double* %1290, i64 %248
%1293 = bitcast double* %1292 to i8*
%1294 = icmp ult i8* %21, %1293
%1295 = icmp ult double* %1290, %267
%1296 = and i1 %1294, %1295
%1297 = or i1 %365, %1296
br i1 %1297, label %1370, label %1298
1298: ; preds = %1291
br i1 %368, label %1346, label %1299
1299: ; preds = %1298, %1299
%1300 = phi i64 [ %1343, %1299 ], [ 0, %1298 ]
%1301 = phi i64 [ %1344, %1299 ], [ 0, %1298 ]
%1302 = getelementptr inbounds double, double* %23, i64 %1300
%1303 = bitcast double* %1302 to <2 x double>*
%1304 = load <2 x double>, <2 x double>* %1303
%1305 = getelementptr inbounds double, double* %1302, i64 2
%1306 = bitcast double* %1305 to <2 x double>*
%1307 = load <2 x double>, <2 x double>* %1306
%1308 = getelementptr inbounds double, double* %1290, i64 %1300
%1309 = bitcast double* %1308 to <2 x double>*
%1310 = load <2 x double>, <2 x double>* %1309
%1311 = getelementptr inbounds double, double* %1308, i64 2
%1312 = bitcast double* %1311 to <2 x double>*
%1313 = load <2 x double>, <2 x double>* %1312
%1314 = fsub <2 x double> %1304, %1310
%1315 = fsub <2 x double> %1307, %1313
%1316 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1314, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1304)
%1317 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1315, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1307)
%1318 = getelementptr inbounds double, double* %20, i64 %1300
%1319 = bitcast double* %1318 to <2 x double>*
store <2 x double> %1316, <2 x double>* %1319
%1320 = getelementptr inbounds double, double* %1318, i64 2
%1321 = bitcast double* %1320 to <2 x double>*
store <2 x double> %1317, <2 x double>* %1321
%1322 = or i64 %1300, 4
%1323 = getelementptr inbounds double, double* %23, i64 %1322
%1324 = bitcast double* %1323 to <2 x double>*
%1325 = load <2 x double>, <2 x double>* %1324
%1326 = getelementptr inbounds double, double* %1323, i64 2
%1327 = bitcast double* %1326 to <2 x double>*
%1328 = load <2 x double>, <2 x double>* %1327
%1329 = getelementptr inbounds double, double* %1290, i64 %1322
%1330 = bitcast double* %1329 to <2 x double>*
%1331 = load <2 x double>, <2 x double>* %1330
%1332 = getelementptr inbounds double, double* %1329, i64 2
%1333 = bitcast double* %1332 to <2 x double>*
%1334 = load <2 x double>, <2 x double>* %1333
%1335 = fsub <2 x double> %1325, %1331
%1336 = fsub <2 x double> %1328, %1334
%1337 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1335, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1325)
%1338 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1336, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1328)
%1339 = getelementptr inbounds double, double* %20, i64 %1322
%1340 = bitcast double* %1339 to <2 x double>*
store <2 x double> %1337, <2 x double>* %1340
%1341 = getelementptr inbounds double, double* %1339, i64 2
%1342 = bitcast double* %1341 to <2 x double>*
store <2 x double> %1338, <2 x double>* %1342
%1343 = add nuw i64 %1300, 8
%1344 = add i64 %1301, 2
%1345 = icmp eq i64 %1344, %369
br i1 %1345, label %1346, label %1299
1346: ; preds = %1299, %1298
%1347 = phi i64 [ 0, %1298 ], [ %1343, %1299 ]
br i1 %370, label %1369, label %1348
1348: ; preds = %1346
%1349 = getelementptr inbounds double, double* %23, i64 %1347
%1350 = bitcast double* %1349 to <2 x double>*
%1351 = load <2 x double>, <2 x double>* %1350
%1352 = getelementptr inbounds double, double* %1349, i64 2
%1353 = bitcast double* %1352 to <2 x double>*
%1354 = load <2 x double>, <2 x double>* %1353
%1355 = getelementptr inbounds double, double* %1290, i64 %1347
%1356 = bitcast double* %1355 to <2 x double>*
%1357 = load <2 x double>, <2 x double>* %1356
%1358 = getelementptr inbounds double, double* %1355, i64 2
%1359 = bitcast double* %1358 to <2 x double>*
%1360 = load <2 x double>, <2 x double>* %1359
%1361 = fsub <2 x double> %1351, %1357
%1362 = fsub <2 x double> %1354, %1360
%1363 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1361, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1351)
%1364 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1362, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %1354)
%1365 = getelementptr inbounds double, double* %20, i64 %1347
%1366 = bitcast double* %1365 to <2 x double>*
store <2 x double> %1363, <2 x double>* %1366
%1367 = getelementptr inbounds double, double* %1365, i64 2
%1368 = bitcast double* %1367 to <2 x double>*
store <2 x double> %1364, <2 x double>* %1368
br label %1369
1369: ; preds = %1346, %1348
br i1 %371, label %1513, label %1370
1370: ; preds = %1291, %1288, %1369
%1371 = phi i64 [ 0, %1291 ], [ 0, %1288 ], [ %366, %1369 ]
%1372 = xor i64 %1371, -1
br i1 %373, label %1382, label %1373
1373: ; preds = %1370
%1374 = getelementptr inbounds double, double* %23, i64 %1371
%1375 = load double, double* %1374
%1376 = getelementptr inbounds double, double* %1290, i64 %1371
%1377 = load double, double* %1376
%1378 = fsub double %1375, %1377
%1379 = tail call double @llvm.fmuladd.f64(double %1378, double -5.000000e-01, double %1375)
%1380 = getelementptr inbounds double, double* %20, i64 %1371
store double %1379, double* %1380
%1381 = or i64 %1371, 1
br label %1382
1382: ; preds = %1373, %1370
%1383 = phi i64 [ %1371, %1370 ], [ %1381, %1373 ]
%1384 = icmp eq i64 %1372, %374
br i1 %1384, label %1513, label %1494
1385: ; preds = %1282
br i1 %54, label %1386, label %1513
1386: ; preds = %1385
%1387 = select i1 %375, i1 true, i1 %382
br i1 %1387, label %1460, label %1388
1388: ; preds = %1386
br i1 %385, label %1436, label %1389
1389: ; preds = %1388, %1389
%1390 = phi i64 [ %1433, %1389 ], [ 0, %1388 ]
%1391 = phi i64 [ %1434, %1389 ], [ 0, %1388 ]
%1392 = getelementptr inbounds double, double* %23, i64 %1390
%1393 = bitcast double* %1392 to <2 x double>*
%1394 = load <2 x double>, <2 x double>* %1393
%1395 = getelementptr inbounds double, double* %1392, i64 2
%1396 = bitcast double* %1395 to <2 x double>*
%1397 = load <2 x double>, <2 x double>* %1396
%1398 = getelementptr inbounds double, double* %14, i64 %1390
%1399 = bitcast double* %1398 to <2 x double>*
%1400 = load <2 x double>, <2 x double>* %1399
%1401 = getelementptr inbounds double, double* %1398, i64 2
%1402 = bitcast double* %1401 to <2 x double>*
%1403 = load <2 x double>, <2 x double>* %1402
%1404 = fsub <2 x double> %1400, %1394
%1405 = fsub <2 x double> %1403, %1397
%1406 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1404, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1394)
%1407 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1405, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1397)
%1408 = getelementptr inbounds double, double* %20, i64 %1390
%1409 = bitcast double* %1408 to <2 x double>*
store <2 x double> %1406, <2 x double>* %1409
%1410 = getelementptr inbounds double, double* %1408, i64 2
%1411 = bitcast double* %1410 to <2 x double>*
store <2 x double> %1407, <2 x double>* %1411
%1412 = or i64 %1390, 4
%1413 = getelementptr inbounds double, double* %23, i64 %1412
%1414 = bitcast double* %1413 to <2 x double>*
%1415 = load <2 x double>, <2 x double>* %1414
%1416 = getelementptr inbounds double, double* %1413, i64 2
%1417 = bitcast double* %1416 to <2 x double>*
%1418 = load <2 x double>, <2 x double>* %1417
%1419 = getelementptr inbounds double, double* %14, i64 %1412
%1420 = bitcast double* %1419 to <2 x double>*
%1421 = load <2 x double>, <2 x double>* %1420
%1422 = getelementptr inbounds double, double* %1419, i64 2
%1423 = bitcast double* %1422 to <2 x double>*
%1424 = load <2 x double>, <2 x double>* %1423
%1425 = fsub <2 x double> %1421, %1415
%1426 = fsub <2 x double> %1424, %1418
%1427 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1425, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1415)
%1428 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1426, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1418)
%1429 = getelementptr inbounds double, double* %20, i64 %1412
%1430 = bitcast double* %1429 to <2 x double>*
store <2 x double> %1427, <2 x double>* %1430
%1431 = getelementptr inbounds double, double* %1429, i64 2
%1432 = bitcast double* %1431 to <2 x double>*
store <2 x double> %1428, <2 x double>* %1432
%1433 = add nuw i64 %1390, 8
%1434 = add i64 %1391, 2
%1435 = icmp eq i64 %1434, %386
br i1 %1435, label %1436, label %1389
1436: ; preds = %1389, %1388
%1437 = phi i64 [ 0, %1388 ], [ %1433, %1389 ]
br i1 %387, label %1459, label %1438
1438: ; preds = %1436
%1439 = getelementptr inbounds double, double* %23, i64 %1437
%1440 = bitcast double* %1439 to <2 x double>*
%1441 = load <2 x double>, <2 x double>* %1440
%1442 = getelementptr inbounds double, double* %1439, i64 2
%1443 = bitcast double* %1442 to <2 x double>*
%1444 = load <2 x double>, <2 x double>* %1443
%1445 = getelementptr inbounds double, double* %14, i64 %1437
%1446 = bitcast double* %1445 to <2 x double>*
%1447 = load <2 x double>, <2 x double>* %1446
%1448 = getelementptr inbounds double, double* %1445, i64 2
%1449 = bitcast double* %1448 to <2 x double>*
%1450 = load <2 x double>, <2 x double>* %1449
%1451 = fsub <2 x double> %1447, %1441
%1452 = fsub <2 x double> %1450, %1444
%1453 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1451, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1441)
%1454 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1452, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1444)
%1455 = getelementptr inbounds double, double* %20, i64 %1437
%1456 = bitcast double* %1455 to <2 x double>*
store <2 x double> %1453, <2 x double>* %1456
%1457 = getelementptr inbounds double, double* %1455, i64 2
%1458 = bitcast double* %1457 to <2 x double>*
store <2 x double> %1454, <2 x double>* %1458
br label %1459
1459: ; preds = %1436, %1438
br i1 %388, label %1513, label %1460
1460: ; preds = %1386, %1459
%1461 = phi i64 [ 0, %1386 ], [ %383, %1459 ]
%1462 = xor i64 %1461, -1
br i1 %390, label %1472, label %1463
1463: ; preds = %1460
%1464 = getelementptr inbounds double, double* %23, i64 %1461
%1465 = load double, double* %1464
%1466 = getelementptr inbounds double, double* %14, i64 %1461
%1467 = load double, double* %1466
%1468 = fsub double %1467, %1465
%1469 = tail call double @llvm.fmuladd.f64(double %1468, double 5.000000e-01, double %1465)
%1470 = getelementptr inbounds double, double* %20, i64 %1461
store double %1469, double* %1470
%1471 = or i64 %1461, 1
br label %1472
1472: ; preds = %1463, %1460
%1473 = phi i64 [ %1461, %1460 ], [ %1471, %1463 ]
%1474 = icmp eq i64 %1462, %391
br i1 %1474, label %1513, label %1475
1475: ; preds = %1472, %1475
%1476 = phi i64 [ %1492, %1475 ], [ %1473, %1472 ]
%1477 = getelementptr inbounds double, double* %23, i64 %1476
%1478 = load double, double* %1477
%1479 = getelementptr inbounds double, double* %14, i64 %1476
%1480 = load double, double* %1479
%1481 = fsub double %1480, %1478
%1482 = tail call double @llvm.fmuladd.f64(double %1481, double 5.000000e-01, double %1478)
%1483 = getelementptr inbounds double, double* %20, i64 %1476
store double %1482, double* %1483
%1484 = add nuw nsw i64 %1476, 1
%1485 = getelementptr inbounds double, double* %23, i64 %1484
%1486 = load double, double* %1485
%1487 = getelementptr inbounds double, double* %14, i64 %1484
%1488 = load double, double* %1487
%1489 = fsub double %1488, %1486
%1490 = tail call double @llvm.fmuladd.f64(double %1489, double 5.000000e-01, double %1486)
%1491 = getelementptr inbounds double, double* %20, i64 %1484
store double %1490, double* %1491
%1492 = add nuw nsw i64 %1476, 2
%1493 = icmp eq i64 %1492, %255
br i1 %1493, label %1513, label %1475
1494: ; preds = %1382, %1494
%1495 = phi i64 [ %1511, %1494 ], [ %1383, %1382 ]
%1496 = getelementptr inbounds double, double* %23, i64 %1495
%1497 = load double, double* %1496
%1498 = getelementptr inbounds double, double* %1290, i64 %1495
%1499 = load double, double* %1498
%1500 = fsub double %1497, %1499
%1501 = tail call double @llvm.fmuladd.f64(double %1500, double -5.000000e-01, double %1497)
%1502 = getelementptr inbounds double, double* %20, i64 %1495
store double %1501, double* %1502
%1503 = add nuw nsw i64 %1495, 1
%1504 = getelementptr inbounds double, double* %23, i64 %1503
%1505 = load double, double* %1504
%1506 = getelementptr inbounds double, double* %1290, i64 %1503
%1507 = load double, double* %1506
%1508 = fsub double %1505, %1507
%1509 = tail call double @llvm.fmuladd.f64(double %1508, double -5.000000e-01, double %1505)
%1510 = getelementptr inbounds double, double* %20, i64 %1503
store double %1509, double* %1510
%1511 = add nuw nsw i64 %1495, 2
%1512 = icmp eq i64 %1511, %254
br i1 %1512, label %1513, label %1494
1513: ; preds = %1382, %1494, %1472, %1475, %1369, %1459, %1287, %1385
%1514 = tail call double @evaluate(i32 %1, double* %20, i8* %4)
%1515 = add nsw i32 %1279, 1
%1516 = load double, double* %1284
%1517 = fcmp olt double %1514, %1516
br i1 %1517, label %1522, label %1518
1518: ; preds = %1513
br i1 %25, label %1760, label %1519
1519: ; preds = %1518
%1520 = getelementptr inbounds double*, double** %9, i64 %793
%1521 = zext i32 %582 to i64
br label %1637
1522: ; preds = %1513
br i1 %54, label %1523, label %1636
1523: ; preds = %1522
%1524 = getelementptr inbounds double*, double** %9, i64 %1283
%1525 = load double*, double** %1524
br i1 %402, label %1601, label %1526
1526: ; preds = %1523
%1527 = getelementptr double, double* %1525, i64 %248
%1528 = bitcast double* %1527 to i8*
%1529 = icmp ult double* %1525, %260
%1530 = icmp ult i8* %21, %1528
%1531 = and i1 %1529, %1530
br i1 %1531, label %1601, label %1532
1532: ; preds = %1526
br i1 %405, label %1582, label %1533
1533: ; preds = %1532, %1533
%1534 = phi i64 [ %1579, %1533 ], [ 0, %1532 ]
%1535 = phi i64 [ %1580, %1533 ], [ 0, %1532 ]
%1536 = getelementptr inbounds double, double* %20, i64 %1534
%1537 = bitcast double* %1536 to <2 x double>*
%1538 = load <2 x double>, <2 x double>* %1537
%1539 = getelementptr inbounds double, double* %1536, i64 2
%1540 = bitcast double* %1539 to <2 x double>*
%1541 = load <2 x double>, <2 x double>* %1540
%1542 = getelementptr inbounds double, double* %1525, i64 %1534
%1543 = bitcast double* %1542 to <2 x double>*
store <2 x double> %1538, <2 x double>* %1543
%1544 = getelementptr inbounds double, double* %1542, i64 2
%1545 = bitcast double* %1544 to <2 x double>*
store <2 x double> %1541, <2 x double>* %1545
%1546 = or i64 %1534, 4
%1547 = getelementptr inbounds double, double* %20, i64 %1546
%1548 = bitcast double* %1547 to <2 x double>*
%1549 = load <2 x double>, <2 x double>* %1548
%1550 = getelementptr inbounds double, double* %1547, i64 2
%1551 = bitcast double* %1550 to <2 x double>*
%1552 = load <2 x double>, <2 x double>* %1551
%1553 = getelementptr inbounds double, double* %1525, i64 %1546
%1554 = bitcast double* %1553 to <2 x double>*
store <2 x double> %1549, <2 x double>* %1554
%1555 = getelementptr inbounds double, double* %1553, i64 2
%1556 = bitcast double* %1555 to <2 x double>*
store <2 x double> %1552, <2 x double>* %1556
%1557 = or i64 %1534, 8
%1558 = getelementptr inbounds double, double* %20, i64 %1557
%1559 = bitcast double* %1558 to <2 x double>*
%1560 = load <2 x double>, <2 x double>* %1559
%1561 = getelementptr inbounds double, double* %1558, i64 2
%1562 = bitcast double* %1561 to <2 x double>*
%1563 = load <2 x double>, <2 x double>* %1562
%1564 = getelementptr inbounds double, double* %1525, i64 %1557
%1565 = bitcast double* %1564 to <2 x double>*
store <2 x double> %1560, <2 x double>* %1565
%1566 = getelementptr inbounds double, double* %1564, i64 2
%1567 = bitcast double* %1566 to <2 x double>*
store <2 x double> %1563, <2 x double>* %1567
%1568 = or i64 %1534, 12
%1569 = getelementptr inbounds double, double* %20, i64 %1568
%1570 = bitcast double* %1569 to <2 x double>*
%1571 = load <2 x double>, <2 x double>* %1570
%1572 = getelementptr inbounds double, double* %1569, i64 2
%1573 = bitcast double* %1572 to <2 x double>*
%1574 = load <2 x double>, <2 x double>* %1573
%1575 = getelementptr inbounds double, double* %1525, i64 %1568
%1576 = bitcast double* %1575 to <2 x double>*
store <2 x double> %1571, <2 x double>* %1576
%1577 = getelementptr inbounds double, double* %1575, i64 2
%1578 = bitcast double* %1577 to <2 x double>*
store <2 x double> %1574, <2 x double>* %1578
%1579 = add nuw i64 %1534, 16
%1580 = add nuw i64 %1535, 4
%1581 = icmp eq i64 %1580, %406
br i1 %1581, label %1582, label %1533
1582: ; preds = %1533, %1532
%1583 = phi i64 [ 0, %1532 ], [ %1579, %1533 ]
br i1 %407, label %1600, label %1584
1584: ; preds = %1582, %1584
%1585 = phi i64 [ %1597, %1584 ], [ %1583, %1582 ]
%1586 = phi i64 [ %1598, %1584 ], [ 0, %1582 ]
%1587 = getelementptr inbounds double, double* %20, i64 %1585
%1588 = bitcast double* %1587 to <2 x double>*
%1589 = load <2 x double>, <2 x double>* %1588
%1590 = getelementptr inbounds double, double* %1587, i64 2
%1591 = bitcast double* %1590 to <2 x double>*
%1592 = load <2 x double>, <2 x double>* %1591
%1593 = getelementptr inbounds double, double* %1525, i64 %1585
%1594 = bitcast double* %1593 to <2 x double>*
store <2 x double> %1589, <2 x double>* %1594
%1595 = getelementptr inbounds double, double* %1593, i64 2
%1596 = bitcast double* %1595 to <2 x double>*
store <2 x double> %1592, <2 x double>* %1596
%1597 = add nuw i64 %1585, 4
%1598 = add i64 %1586, 1
%1599 = icmp eq i64 %1598, %404
br i1 %1599, label %1600, label %1584
1600: ; preds = %1584, %1582
br i1 %408, label %1636, label %1601
1601: ; preds = %1526, %1523, %1600
%1602 = phi i64 [ 0, %1526 ], [ 0, %1523 ], [ %403, %1600 ]
%1603 = xor i64 %1602, -1
%1604 = add nsw i64 %1603, %248
br i1 %410, label %1614, label %1605
1605: ; preds = %1601, %1605
%1606 = phi i64 [ %1611, %1605 ], [ %1602, %1601 ]
%1607 = phi i64 [ %1612, %1605 ], [ 0, %1601 ]
%1608 = getelementptr inbounds double, double* %20, i64 %1606
%1609 = load double, double* %1608
%1610 = getelementptr inbounds double, double* %1525, i64 %1606
store double %1609, double* %1610
%1611 = add nuw nsw i64 %1606, 1
%1612 = add i64 %1607, 1
%1613 = icmp eq i64 %1612, %409
br i1 %1613, label %1614, label %1605
1614: ; preds = %1605, %1601
%1615 = phi i64 [ %1602, %1601 ], [ %1611, %1605 ]
%1616 = icmp ult i64 %1604, 3
br i1 %1616, label %1636, label %1617
1617: ; preds = %1614, %1617
%1618 = phi i64 [ %1634, %1617 ], [ %1615, %1614 ]
%1619 = getelementptr inbounds double, double* %20, i64 %1618
%1620 = load double, double* %1619
%1621 = getelementptr inbounds double, double* %1525, i64 %1618
store double %1620, double* %1621
%1622 = add nuw nsw i64 %1618, 1
%1623 = getelementptr inbounds double, double* %20, i64 %1622
%1624 = load double, double* %1623
%1625 = getelementptr inbounds double, double* %1525, i64 %1622
store double %1624, double* %1625
%1626 = add nuw nsw i64 %1618, 2
%1627 = getelementptr inbounds double, double* %20, i64 %1626
%1628 = load double, double* %1627
%1629 = getelementptr inbounds double, double* %1525, i64 %1626
store double %1628, double* %1629
%1630 = add nuw nsw i64 %1618, 3
%1631 = getelementptr inbounds double, double* %20, i64 %1630
%1632 = load double, double* %1631
%1633 = getelementptr inbounds double, double* %1525, i64 %1630
store double %1632, double* %1633
%1634 = add nuw nsw i64 %1618, 4
%1635 = icmp eq i64 %1634, %258
br i1 %1635, label %1636, label %1617
1636: ; preds = %1614, %1617, %1600, %1522
store double %1514, double* %1284
br label %1768
1637: ; preds = %1519, %1757
%1638 = phi i64 [ 0, %1519 ], [ %1758, %1757 ]
%1639 = icmp eq i64 %1638, %1521
%1640 = or i1 %1639, %197
br i1 %1640, label %1757, label %1641
1641: ; preds = %1637
%1642 = load double*, double** %1520
%1643 = getelementptr inbounds double*, double** %9, i64 %1638
%1644 = load double*, double** %1643
br i1 %392, label %1723, label %1645
1645: ; preds = %1641
%1646 = getelementptr double, double* %1644, i64 %248
%1647 = getelementptr double, double* %1642, i64 %248
%1648 = icmp ult double* %1644, %1647
%1649 = icmp ult double* %1642, %1646
%1650 = and i1 %1648, %1649
br i1 %1650, label %1723, label %1651
1651: ; preds = %1645
br i1 %395, label %1699, label %1652
1652: ; preds = %1651, %1652
%1653 = phi i64 [ %1696, %1652 ], [ 0, %1651 ]
%1654 = phi i64 [ %1697, %1652 ], [ 0, %1651 ]
%1655 = getelementptr inbounds double, double* %1642, i64 %1653
%1656 = bitcast double* %1655 to <2 x double>*
%1657 = load <2 x double>, <2 x double>* %1656
%1658 = getelementptr inbounds double, double* %1655, i64 2
%1659 = bitcast double* %1658 to <2 x double>*
%1660 = load <2 x double>, <2 x double>* %1659
%1661 = getelementptr inbounds double, double* %1644, i64 %1653
%1662 = bitcast double* %1661 to <2 x double>*
%1663 = load <2 x double>, <2 x double>* %1662
%1664 = getelementptr inbounds double, double* %1661, i64 2
%1665 = bitcast double* %1664 to <2 x double>*
%1666 = load <2 x double>, <2 x double>* %1665
%1667 = fsub <2 x double> %1663, %1657
%1668 = fsub <2 x double> %1666, %1660
%1669 = fmul <2 x double> %1667, <double 5.000000e-01, double 5.000000e-01>
%1670 = fmul <2 x double> %1668, <double 5.000000e-01, double 5.000000e-01>
%1671 = fadd <2 x double> %1657, %1669
%1672 = fadd <2 x double> %1660, %1670
%1673 = bitcast double* %1661 to <2 x double>*
store <2 x double> %1671, <2 x double>* %1673
%1674 = bitcast double* %1664 to <2 x double>*
store <2 x double> %1672, <2 x double>* %1674
%1675 = or i64 %1653, 4
%1676 = getelementptr inbounds double, double* %1642, i64 %1675
%1677 = bitcast double* %1676 to <2 x double>*
%1678 = load <2 x double>, <2 x double>* %1677
%1679 = getelementptr inbounds double, double* %1676, i64 2
%1680 = bitcast double* %1679 to <2 x double>*
%1681 = load <2 x double>, <2 x double>* %1680
%1682 = getelementptr inbounds double, double* %1644, i64 %1675
%1683 = bitcast double* %1682 to <2 x double>*
%1684 = load <2 x double>, <2 x double>* %1683
%1685 = getelementptr inbounds double, double* %1682, i64 2
%1686 = bitcast double* %1685 to <2 x double>*
%1687 = load <2 x double>, <2 x double>* %1686
%1688 = fsub <2 x double> %1684, %1678
%1689 = fsub <2 x double> %1687, %1681
%1690 = fmul <2 x double> %1688, <double 5.000000e-01, double 5.000000e-01>
%1691 = fmul <2 x double> %1689, <double 5.000000e-01, double 5.000000e-01>
%1692 = fadd <2 x double> %1678, %1690
%1693 = fadd <2 x double> %1681, %1691
%1694 = bitcast double* %1682 to <2 x double>*
store <2 x double> %1692, <2 x double>* %1694
%1695 = bitcast double* %1685 to <2 x double>*
store <2 x double> %1693, <2 x double>* %1695
%1696 = add nuw i64 %1653, 8
%1697 = add i64 %1654, 2
%1698 = icmp eq i64 %1697, %396
br i1 %1698, label %1699, label %1652
1699: ; preds = %1652, %1651
%1700 = phi i64 [ 0, %1651 ], [ %1696, %1652 ]
br i1 %397, label %1722, label %1701
1701: ; preds = %1699
%1702 = getelementptr inbounds double, double* %1642, i64 %1700
%1703 = bitcast double* %1702 to <2 x double>*
%1704 = load <2 x double>, <2 x double>* %1703
%1705 = getelementptr inbounds double, double* %1702, i64 2
%1706 = bitcast double* %1705 to <2 x double>*
%1707 = load <2 x double>, <2 x double>* %1706
%1708 = getelementptr inbounds double, double* %1644, i64 %1700
%1709 = bitcast double* %1708 to <2 x double>*
%1710 = load <2 x double>, <2 x double>* %1709
%1711 = getelementptr inbounds double, double* %1708, i64 2
%1712 = bitcast double* %1711 to <2 x double>*
%1713 = load <2 x double>, <2 x double>* %1712
%1714 = fsub <2 x double> %1710, %1704
%1715 = fsub <2 x double> %1713, %1707
%1716 = fmul <2 x double> %1714, <double 5.000000e-01, double 5.000000e-01>
%1717 = fmul <2 x double> %1715, <double 5.000000e-01, double 5.000000e-01>
%1718 = fadd <2 x double> %1704, %1716
%1719 = fadd <2 x double> %1707, %1717
%1720 = bitcast double* %1708 to <2 x double>*
store <2 x double> %1718, <2 x double>* %1720
%1721 = bitcast double* %1711 to <2 x double>*
store <2 x double> %1719, <2 x double>* %1721
br label %1722
1722: ; preds = %1699, %1701
br i1 %398, label %1757, label %1723
1723: ; preds = %1645, %1641, %1722
%1724 = phi i64 [ 0, %1645 ], [ 0, %1641 ], [ %393, %1722 ]
%1725 = xor i64 %1724, -1
br i1 %400, label %1735, label %1726
1726: ; preds = %1723
%1727 = getelementptr inbounds double, double* %1642, i64 %1724
%1728 = load double, double* %1727
%1729 = getelementptr inbounds double, double* %1644, i64 %1724
%1730 = load double, double* %1729
%1731 = fsub double %1730, %1728
%1732 = fmul double %1731, 5.000000e-01
%1733 = fadd double %1728, %1732
store double %1733, double* %1729
%1734 = or i64 %1724, 1
br label %1735
1735: ; preds = %1726, %1723
%1736 = phi i64 [ %1724, %1723 ], [ %1734, %1726 ]
%1737 = icmp eq i64 %1725, %401
br i1 %1737, label %1757, label %1738
1738: ; preds = %1735, %1738
%1739 = phi i64 [ %1755, %1738 ], [ %1736, %1735 ]
%1740 = getelementptr inbounds double, double* %1642, i64 %1739
%1741 = load double, double* %1740
%1742 = getelementptr inbounds double, double* %1644, i64 %1739
%1743 = load double, double* %1742
%1744 = fsub double %1743, %1741
%1745 = fmul double %1744, 5.000000e-01
%1746 = fadd double %1741, %1745
store double %1746, double* %1742
%1747 = add nuw nsw i64 %1739, 1
%1748 = getelementptr inbounds double, double* %1642, i64 %1747
%1749 = load double, double* %1748
%1750 = getelementptr inbounds double, double* %1644, i64 %1747
%1751 = load double, double* %1750
%1752 = fsub double %1751, %1749
%1753 = fmul double %1752, 5.000000e-01
%1754 = fadd double %1749, %1753
store double %1754, double* %1750
%1755 = add nuw nsw i64 %1739, 2
%1756 = icmp eq i64 %1755, %257
br i1 %1756, label %1757, label %1738
1757: ; preds = %1735, %1738, %1722, %1637
%1758 = add nuw nsw i64 %1638, 1
%1759 = icmp eq i64 %1758, %256
br i1 %1759, label %1760, label %1637
1760: ; preds = %1757, %1518
%1761 = getelementptr inbounds double*, double** %9, i64 %1283
%1762 = load double*, double** %1761
%1763 = tail call double @evaluate(i32 %1, double* %1762, i8* %4)
store double %1763, double* %1284
%1764 = getelementptr inbounds double*, double** %9, i64 %789
%1765 = load double*, double** %1764
%1766 = tail call double @evaluate(i32 %1, double* %1765, i8* %4)
store double %1766, double* %790
%1767 = add nsw i32 %1279, 3
br label %1768
1768: ; preds = %1636, %1760, %1278
%1769 = phi i32 [ %1515, %1636 ], [ %1767, %1760 ], [ %1279, %1278 ]
%1770 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), i32 %433)
br i1 %25, label %1875, label %1773
1771: ; preds = %1773
br i1 %25, label %1875, label %1772
1772: ; preds = %1771
br i1 %412, label %1823, label %1785
1773: ; preds = %1768, %1773
%1774 = phi i64 [ %1783, %1773 ], [ 0, %1768 ]
%1775 = getelementptr inbounds double*, double** %9, i64 %1774
%1776 = load double*, double** %1775
%1777 = load double, double* %1776
%1778 = getelementptr inbounds double, double* %1776, i64 1
%1779 = load double, double* %1778
%1780 = getelementptr inbounds double, double* %11, i64 %1774
%1781 = load double, double* %1780
%1782 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), double %1777, double %1779, double %1781)
%1783 = add nuw nsw i64 %1774, 1
%1784 = icmp eq i64 %1783, %259
br i1 %1784, label %1771, label %1773
1785: ; preds = %1772, %1785
%1786 = phi i64 [ %1820, %1785 ], [ 0, %1772 ]
%1787 = phi double [ %1819, %1785 ], [ 0.000000e+00, %1772 ]
%1788 = phi i64 [ %1821, %1785 ], [ 0, %1772 ]
%1789 = getelementptr inbounds double, double* %11, i64 %1786
%1790 = load double, double* %1789
%1791 = fadd double %1787, %1790
%1792 = or i64 %1786, 1
%1793 = getelementptr inbounds double, double* %11, i64 %1792
%1794 = load double, double* %1793
%1795 = fadd double %1791, %1794
%1796 = or i64 %1786, 2
%1797 = getelementptr inbounds double, double* %11, i64 %1796
%1798 = load double, double* %1797
%1799 = fadd double %1795, %1798
%1800 = or i64 %1786, 3
%1801 = getelementptr inbounds double, double* %11, i64 %1800
%1802 = load double, double* %1801
%1803 = fadd double %1799, %1802
%1804 = or i64 %1786, 4
%1805 = getelementptr inbounds double, double* %11, i64 %1804
%1806 = load double, double* %1805
%1807 = fadd double %1803, %1806
%1808 = or i64 %1786, 5
%1809 = getelementptr inbounds double, double* %11, i64 %1808
%1810 = load double, double* %1809
%1811 = fadd double %1807, %1810
%1812 = or i64 %1786, 6
%1813 = getelementptr inbounds double, double* %11, i64 %1812
%1814 = load double, double* %1813
%1815 = fadd double %1811, %1814
%1816 = or i64 %1786, 7
%1817 = getelementptr inbounds double, double* %11, i64 %1816
%1818 = load double, double* %1817
%1819 = fadd double %1815, %1818
%1820 = add nuw nsw i64 %1786, 8
%1821 = add i64 %1788, 8
%1822 = icmp eq i64 %1821, %413
br i1 %1822, label %1823, label %1785
1823: ; preds = %1785, %1772
%1824 = phi double [ undef, %1772 ], [ %1819, %1785 ]
%1825 = phi i64 [ 0, %1772 ], [ %1820, %1785 ]
%1826 = phi double [ 0.000000e+00, %1772 ], [ %1819, %1785 ]
br i1 %414, label %1837, label %1827
1827: ; preds = %1823, %1827
%1828 = phi i64 [ %1834, %1827 ], [ %1825, %1823 ]
%1829 = phi double [ %1833, %1827 ], [ %1826, %1823 ]
%1830 = phi i64 [ %1835, %1827 ], [ 0, %1823 ]
%1831 = getelementptr inbounds double, double* %11, i64 %1828
%1832 = load double, double* %1831
%1833 = fadd double %1829, %1832
%1834 = add nuw nsw i64 %1828, 1
%1835 = add i64 %1830, 1
%1836 = icmp eq i64 %1835, %411
br i1 %1836, label %1837, label %1827
1837: ; preds = %1827, %1823
%1838 = phi double [ %1824, %1823 ], [ %1833, %1827 ]
%1839 = fdiv double %1838, %36
br i1 %25, label %1875, label %1840
1840: ; preds = %1837
br i1 %416, label %1863, label %1841
1841: ; preds = %1840, %1841
%1842 = phi i64 [ %1860, %1841 ], [ 0, %1840 ]
%1843 = phi double [ %1859, %1841 ], [ 0.000000e+00, %1840 ]
%1844 = phi i64 [ %1861, %1841 ], [ 0, %1840 ]
%1845 = getelementptr inbounds double, double* %11, i64 %1842
%1846 = load double, double* %1845
%1847 = fsub double %1846, %1839
%1848 = tail call i32 @pow(double %1847, double 2.000000e+00)
%1849 = sdiv i32 %1848, %1
%1850 = sitofp i32 %1849 to double
%1851 = fadd double %1843, %1850
%1852 = or i64 %1842, 1
%1853 = getelementptr inbounds double, double* %11, i64 %1852
%1854 = load double, double* %1853
%1855 = fsub double %1854, %1839
%1856 = tail call i32 @pow(double %1855, double 2.000000e+00)
%1857 = sdiv i32 %1856, %1
%1858 = sitofp i32 %1857 to double
%1859 = fadd double %1851, %1858
%1860 = add nuw nsw i64 %1842, 2
%1861 = add i64 %1844, 2
%1862 = icmp eq i64 %1861, %417
br i1 %1862, label %1863, label %1841
1863: ; preds = %1841, %1840
%1864 = phi double [ undef, %1840 ], [ %1859, %1841 ]
%1865 = phi i64 [ 0, %1840 ], [ %1860, %1841 ]
%1866 = phi double [ 0.000000e+00, %1840 ], [ %1859, %1841 ]
br i1 %418, label %1875, label %1867
1867: ; preds = %1863
%1868 = getelementptr inbounds double, double* %11, i64 %1865
%1869 = load double, double* %1868
%1870 = fsub double %1869, %1839
%1871 = tail call i32 @pow(double %1870, double 2.000000e+00)
%1872 = sdiv i32 %1871, %1
%1873 = sitofp i32 %1872 to double
%1874 = fadd double %1866, %1873
br label %1875
1875: ; preds = %1867, %1863, %1768, %1771, %1837
%1876 = phi double [ 0.000000e+00, %1837 ], [ 0.000000e+00, %1771 ], [ 0.000000e+00, %1768 ], [ %1864, %1863 ], [ %1874, %1867 ]
%1877 = tail call i32 @sqrt(double %1876)
%1878 = sitofp i32 %1877 to double
%1879 = fcmp olt double %1878, %2
br i1 %1879, label %1883, label %1880
1880: ; preds = %1875
%1881 = add nuw nsw i32 %433, 1
%1882 = icmp eq i32 %1881, 1001
br i1 %1882, label %1883, label %431
1883: ; preds = %1875, %1880
%1884 = phi i32 [ %433, %1875 ], [ 1001, %1880 ]
br i1 %25, label %1956, label %1885
1885: ; preds = %1883
%1886 = zext i32 %6 to i64
%1887 = and i64 %1886, 3
%1888 = icmp ult i64 %284, 3
br i1 %1888, label %1933, label %1889
1889: ; preds = %1885
%1890 = and i64 %1886, 4294967292
br label %1891
1891: ; preds = %1891, %1889
%1892 = phi i64 [ 0, %1889 ], [ %1930, %1891 ]
%1893 = phi i32 [ 0, %1889 ], [ %1929, %1891 ]
%1894 = phi i64 [ 0, %1889 ], [ %1931, %1891 ]
%1895 = getelementptr inbounds double, double* %11, i64 %1892
%1896 = load double, double* %1895
%1897 = sext i32 %1893 to i64
%1898 = getelementptr inbounds double, double* %11, i64 %1897
%1899 = load double, double* %1898
%1900 = fcmp olt double %1896, %1899
%1901 = trunc i64 %1892 to i32
%1902 = select i1 %1900, i32 %1901, i32 %1893
%1903 = or i64 %1892, 1
%1904 = getelementptr inbounds double, double* %11, i64 %1903
%1905 = load double, double* %1904
%1906 = sext i32 %1902 to i64
%1907 = getelementptr inbounds double, double* %11, i64 %1906
%1908 = load double, double* %1907
%1909 = fcmp olt double %1905, %1908
%1910 = trunc i64 %1903 to i32
%1911 = select i1 %1909, i32 %1910, i32 %1902
%1912 = or i64 %1892, 2
%1913 = getelementptr inbounds double, double* %11, i64 %1912
%1914 = load double, double* %1913
%1915 = sext i32 %1911 to i64
%1916 = getelementptr inbounds double, double* %11, i64 %1915
%1917 = load double, double* %1916
%1918 = fcmp olt double %1914, %1917
%1919 = trunc i64 %1912 to i32
%1920 = select i1 %1918, i32 %1919, i32 %1911
%1921 = or i64 %1892, 3
%1922 = getelementptr inbounds double, double* %11, i64 %1921
%1923 = load double, double* %1922
%1924 = sext i32 %1920 to i64
%1925 = getelementptr inbounds double, double* %11, i64 %1924
%1926 = load double, double* %1925
%1927 = fcmp olt double %1923, %1926
%1928 = trunc i64 %1921 to i32
%1929 = select i1 %1927, i32 %1928, i32 %1920
%1930 = add nuw nsw i64 %1892, 4
%1931 = add i64 %1894, 4
%1932 = icmp eq i64 %1931, %1890
br i1 %1932, label %1933, label %1891
1933: ; preds = %1891, %1885
%1934 = phi i32 [ undef, %1885 ], [ %1929, %1891 ]
%1935 = phi i64 [ 0, %1885 ], [ %1930, %1891 ]
%1936 = phi i32 [ 0, %1885 ], [ %1929, %1891 ]
%1937 = icmp eq i64 %1887, 0
br i1 %1937, label %1953, label %1938
1938: ; preds = %1933, %1938
%1939 = phi i64 [ %1950, %1938 ], [ %1935, %1933 ]
%1940 = phi i32 [ %1949, %1938 ], [ %1936, %1933 ]
%1941 = phi i64 [ %1951, %1938 ], [ 0, %1933 ]
%1942 = getelementptr inbounds double, double* %11, i64 %1939
%1943 = load double, double* %1942
%1944 = sext i32 %1940 to i64
%1945 = getelementptr inbounds double, double* %11, i64 %1944
%1946 = load double, double* %1945
%1947 = fcmp olt double %1943, %1946
%1948 = trunc i64 %1939 to i32
%1949 = select i1 %1947, i32 %1948, i32 %1940
%1950 = add nuw nsw i64 %1939, 1
%1951 = add i64 %1941, 1
%1952 = icmp eq i64 %1951, %1887
br i1 %1952, label %1953, label %1938
1953: ; preds = %1938, %1933
%1954 = phi i32 [ %1934, %1933 ], [ %1949, %1938 ]
%1955 = sext i32 %1954 to i64
br label %1956
1956: ; preds = %1953, %1883
%1957 = phi i64 [ 0, %1883 ], [ %1955, %1953 ]
%1958 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.7, i64 0, i64 0))
%1959 = getelementptr inbounds double*, double** %9, i64 %1957
br i1 %54, label %1962, label %1960
1960: ; preds = %1956
%1961 = load double*, double** %1959
br label %1977
1962: ; preds = %1956
%1963 = zext i32 %1 to i64
%1964 = load double*, double** %1959
br label %1965
1965: ; preds = %1962, %1965
%1966 = phi double* [ %1964, %1962 ], [ %1971, %1965 ]
%1967 = phi i64 [ 0, %1962 ], [ %1975, %1965 ]
%1968 = getelementptr inbounds double, double* %1966, i64 %1967
%1969 = load double, double* %1968
%1970 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %1969)
%1971 = load double*, double** %1959
%1972 = getelementptr inbounds double, double* %1971, i64 %1967
%1973 = load double, double* %1972
%1974 = getelementptr inbounds double, double* %0, i64 %1967
store double %1973, double* %1974
%1975 = add nuw nsw i64 %1967, 1
%1976 = icmp eq i64 %1975, %1963
br i1 %1976, label %1977, label %1965
1977: ; preds = %1965, %1960
%1978 = phi double* [ %1961, %1960 ], [ %1971, %1965 ]
%1979 = tail call double @evaluate(i32 %1, double* %1978, i8* %4)
%1980 = add nsw i32 %1769, 1
%1981 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0), i32 %1980)
%1982 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i32 %1884)
%1983 = tail call i32 @free(double* %11)
%1984 = tail call i32 @free(double* %14)
%1985 = tail call i32 @free(double* %17)
%1986 = tail call i32 @free(double* %20)
%1987 = tail call i32 @free(double* %23)
%1988 = load double*, double** %9
%1989 = tail call i32 @free(double* %1988)
ret double %1979
}