double amoeba_nmsimplex_d(double (*objfunc)(double[]), double start[],
                          double dx[], int n, double EPSILON, int *nfunc,
                          double *reachedEpsilon, int verbose) {
  int vs;
  int vh;
  int vg;
  int i, j, m, row;
  int k;
  double **v;
  double *f;
  double fr;
  double fe;
  double fc;
  double *vr;
  double *ve;
  double *vc;
  double *vm;
  double min;
  double 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));
  }
  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] = start[j] + dx[j];
      } else {
        v[i][j] = start[j];
      }
    }
  }
  for (j = 0; j <= n; j++) {
    f[j] = objfunc(v[j]);
  }
  k = n + 1;
  if (verbose) {
    printf("Initial Values\n");
    for (j = 0; j <= n; j++) {
      printf("Vertex %d:", j + 1);
      for (i = 0; i < n; i++) {
        printf(" %lf", v[j][i]);
      }
      printf(": %lf\n", f[j]);
    }
  }
  int nritterations;
  for (nritterations = 1; nritterations <= 5000; (nritterations)++) {
    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 = objfunc(vr);
    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 = objfunc(ve);
      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 = objfunc(vc);
        k++;
      } else {
        for (j = 0; j <= n - 1; j++) {
          vc[j] = vm[j] - 0.5 * (vm[j] - v[vg][j]);
        }
        fc = objfunc(vc);
        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] = objfunc(v[vg]);
        k++;
        f[vh] = objfunc(v[vh]);
        k++;
      }
    }
    if (verbose) {
      printf("Iteration %d\n", nritterations);
      for (j = 0; j <= n; j++) {
        printf("Vertex %d:", j + 1);
        for (i = 0; i < n; i++) {
          printf(" %lf", v[j][i]);
        }
        printf(": %lf\n", f[j]);
      }
    }
    double yhi, ylo;
    yhi = ylo = f[0];
    for (j = 0; j <= n; j++) {
      if (f[j] > yhi)
        yhi = f[j];
      if (f[j] < ylo)
        ylo = f[j];
    }
    s = 2 * fabs(yhi - ylo) / (fabs(yhi) + fabs(ylo));
    if (s < EPSILON)
      break;
  }
  *reachedEpsilon = s;
  vs = 0;
  for (j = 0; j <= n; j++) {
    if (f[j] < f[vs]) {
      vs = j;
    }
  }
  if (verbose) {
    printf("The minimum was found at epsilon=%e:\n  ", *reachedEpsilon);
    for (j = 0; j < n; j++) {
      printf(" %e", v[vs][j]);
    }
    printf("\n");
  }
  for (j = 0; j < n; j++) {
    start[j] = v[vs][j];
  }
  min = objfunc(v[vs]);
  k++;
  if (verbose) {
    printf("%d Function Evaluations\n", k);
    printf("%d Iterations through program\n", nritterations);
  }
  *nfunc = k;
  free(f);
  free(vr);
  free(ve);
  free(vc);
  free(vm);
  for (i = 0; i <= n; i++) {
    free(v[i]);
  }
  free(v);
  return min;
}


x86 assembly (clang, -O0):
<amoeba_nmsimplex_d>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1213 <amoeba_nmsimplex_d+0xe3>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11dd <amoeba_nmsimplex_d+0xad>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1251 <amoeba_nmsimplex_d+0x121>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    121a <amoeba_nmsimplex_d+0xea>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1302 <amoeba_nmsimplex_d+0x1d2>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12ef <amoeba_nmsimplex_d+0x1bf>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cmp    -0x4c(%rbp),%eax
jne    12ba <amoeba_nmsimplex_d+0x18a>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12dc <amoeba_nmsimplex_d+0x1ac>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12e1 <amoeba_nmsimplex_d+0x1b1>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    126b <amoeba_nmsimplex_d+0x13b>
jmp    12f4 <amoeba_nmsimplex_d+0x1c4>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1258 <amoeba_nmsimplex_d+0x128>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1342 <amoeba_nmsimplex_d+0x212>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
call   *%rax
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1309 <amoeba_nmsimplex_d+0x1d9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,0x10(%rbp)
je     13fc <amoeba_nmsimplex_d+0x2cc>
lea    0xcd4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13f7 <amoeba_nmsimplex_d+0x2c7>
mov    -0x4c(%rbp),%esi
add    $0x1,%esi
lea    0xcbd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13ce <amoeba_nmsimplex_d+0x29e>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc92(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1391 <amoeba_nmsimplex_d+0x261>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc6e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    136a <amoeba_nmsimplex_d+0x23a>
jmp    13fc <amoeba_nmsimplex_d+0x2cc>
movl   $0x1,-0xbc(%rbp)
cmpl   $0x1388,-0xbc(%rbp)
jg     1d6e <amoeba_nmsimplex_d+0xc3e>
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1469 <amoeba_nmsimplex_d+0x339>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1456 <amoeba_nmsimplex_d+0x326>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    145b <amoeba_nmsimplex_d+0x32b>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1424 <amoeba_nmsimplex_d+0x2f4>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14c0 <amoeba_nmsimplex_d+0x390>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    14ad <amoeba_nmsimplex_d+0x37d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    14b2 <amoeba_nmsimplex_d+0x382>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1477 <amoeba_nmsimplex_d+0x347>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1536 <amoeba_nmsimplex_d+0x406>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1523 <amoeba_nmsimplex_d+0x3f3>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1523 <amoeba_nmsimplex_d+0x3f3>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1528 <amoeba_nmsimplex_d+0x3f8>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14cd <amoeba_nmsimplex_d+0x39d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     15df <amoeba_nmsimplex_d+0x4af>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15b0 <amoeba_nmsimplex_d+0x480>
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     159d <amoeba_nmsimplex_d+0x46d>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    15a2 <amoeba_nmsimplex_d+0x472>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1560 <amoeba_nmsimplex_d+0x430>
movsd  -0xb8(%rbp),%xmm0
ff
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    153d <amoeba_nmsimplex_d+0x40d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     164e <amoeba_nmsimplex_d+0x51e>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15e6 <amoeba_nmsimplex_d+0x4b6>
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16fa <amoeba_nmsimplex_d+0x5ca>
movsd  -0x70(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     16fa <amoeba_nmsimplex_d+0x5ca>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16e8 <amoeba_nmsimplex_d+0x5b8>
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16a4 <amoeba_nmsimplex_d+0x574>
movsd  -0x70(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1877 <amoeba_nmsimplex_d+0x747>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1784 <amoeba_nmsimplex_d+0x654>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    171d <amoeba_nmsimplex_d+0x5ed>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x78(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1815 <amoeba_nmsimplex_d+0x6e5>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17fe <amoeba_nmsimplex_d+0x6ce>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    17ba <amoeba_nmsimplex_d+0x68a>
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1872 <amoeba_nmsimplex_d+0x742>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1860 <amoeba_nmsimplex_d+0x730>
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    181c <amoeba_nmsimplex_d+0x6ec>
movsd  -0x70(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1877 <amoeba_nmsimplex_d+0x747>
movsd  -0x70(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1b83 <amoeba_nmsimplex_d+0xa53>
movsd  -0x70(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1959 <amoeba_nmsimplex_d+0x829>
movsd  -0x70(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1959 <amoeba_nmsimplex_d+0x829>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1939 <amoeba_nmsimplex_d+0x809>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x6fd(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    18ca <amoeba_nmsimplex_d+0x79a>
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x80(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    19ef <amoeba_nmsimplex_d+0x8bf>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     19d4 <amoeba_nmsimplex_d+0x8a4>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x652(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1960 <amoeba_nmsimplex_d+0x830>
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x80(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a6d <amoeba_nmsimplex_d+0x93d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1a56 <amoeba_nmsimplex_d+0x926>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a12 <amoeba_nmsimplex_d+0x8e2>
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b7e <amoeba_nmsimplex_d+0xa4e>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1b2e <amoeba_nmsimplex_d+0x9fe>
mov    -0x54(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1b1b <amoeba_nmsimplex_d+0x9eb>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1b16 <amoeba_nmsimplex_d+0x9e6>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0x51d(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a93 <amoeba_nmsimplex_d+0x963>
jmp    1b1b <amoeba_nmsimplex_d+0x9eb>
jmp    1b20 <amoeba_nmsimplex_d+0x9f0>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1a74 <amoeba_nmsimplex_d+0x944>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq -0x44(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
call   *%rax
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
call   *%rax
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1b83 <amoeba_nmsimplex_d+0xa53>
cmpl   $0x0,0x10(%rbp)
je     1c3a <amoeba_nmsimplex_d+0xb0a>
mov    -0xbc(%rbp),%esi
lea    0x4bd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1c35 <amoeba_nmsimplex_d+0xb05>
mov    -0x4c(%rbp),%esi
add    $0x1,%esi
lea    0x47f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c0c <amoeba_nmsimplex_d+0xadc>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x454(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1bcf <amoeba_nmsimplex_d+0xa9f>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x430(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1ba8 <amoeba_nmsimplex_d+0xa78>
jmp    1c3a <amoeba_nmsimplex_d+0xb0a>
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1cdc <amoeba_nmsimplex_d+0xbac>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jbe    1c95 <amoeba_nmsimplex_d+0xb65>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1cc9 <amoeba_nmsimplex_d+0xb99>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1cce <amoeba_nmsimplex_d+0xb9e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c59 <amoeba_nmsimplex_d+0xb29>
movsd  -0xc8(%rbp),%xmm1
ff
subsd  -0xd0(%rbp),%xmm1
ff
movaps 0x32d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x309(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
movaps 0x30e(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0xd0(%rbp),%xmm2
ff
movaps 0x2fb(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1d55 <amoeba_nmsimplex_d+0xc25>
jmp    1d6e <amoeba_nmsimplex_d+0xc3e>
jmp    1d5a <amoeba_nmsimplex_d+0xc2a>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1406 <amoeba_nmsimplex_d+0x2d6>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1dd5 <amoeba_nmsimplex_d+0xca5>
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1dc2 <amoeba_nmsimplex_d+0xc92>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1dc7 <amoeba_nmsimplex_d+0xc97>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d8c <amoeba_nmsimplex_d+0xc5c>
cmpl   $0x0,0x10(%rbp)
je     1e47 <amoeba_nmsimplex_d+0xd17>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
lea    0x277(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e39 <amoeba_nmsimplex_d+0xd09>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x269(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1dfc <amoeba_nmsimplex_d+0xccc>
lea    0x223(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e8a <amoeba_nmsimplex_d+0xd5a>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e4e <amoeba_nmsimplex_d+0xd1e>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
call   *%rax
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1edc <amoeba_nmsimplex_d+0xdac>
mov    -0x58(%rbp),%esi
lea    0x1d0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xbc(%rbp),%esi
lea    0x1d5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%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>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1f50 <amoeba_nmsimplex_d+0xe20>
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1f25 <amoeba_nmsimplex_d+0xdf5>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movsd  -0xa8(%rbp),%xmm0
ff
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<amoeba_nmsimplex_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0xe0(%rsp)
mov    %r8,0x88(%rsp)
movsd  %xmm0,0x148(%rsp)
mov    %ecx,%r13d
mov    %rdx,%r14
mov    %rsi,0x80(%rsp)
mov    %rdi,0x50(%rsp)
lea    0x1(%r13),%eax
mov    %eax,0x44(%rsp)
movslq %eax,%rbx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
movslq %r13d,%rbp
lea    0x0(,%rbp,8),%r12
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %ebx,%eax
mov    %rax,0x58(%rsp)
mov    %r13d,%eax
mov    %rax,0x8(%rsp)
test   %ebp,%ebp
mov    %r9,0x18(%rsp)
mov    %r13,0x28(%rsp)
js     1275 <amoeba_nmsimplex_d+0x125>
movb   $0x1,0x17(%rsp)
xor    %ebp,%ebp
mov    0x58(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1230 <amoeba_nmsimplex_d+0xe0>
mov    0x28(%rsp),%r13
test   %r13d,%r13d
setg   %r10b
jle    1282 <amoeba_nmsimplex_d+0x132>
mov    (%r15),%rax
cmp    $0x4,%r13d
jae    1294 <amoeba_nmsimplex_d+0x144>
xor    %ecx,%ecx
mov    0x18(%rsp),%r9
mov    0x80(%rsp),%rbx
mov    0x8(%rsp),%rsi
jmp    13a9 <amoeba_nmsimplex_d+0x259>
movb   $0x1,0x17(%rsp)
xor    %r10d,%r10d
jmp    14fe <amoeba_nmsimplex_d+0x3ae>
xor    %r10d,%r10d
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r9
jmp    151c <amoeba_nmsimplex_d+0x3cc>
mov    0x80(%rsp),%rbx
mov    0x8(%rsp),%rsi
lea    (%rbx,%rsi,8),%rcx
cmp    %rcx,%rax
jae    12bf <amoeba_nmsimplex_d+0x16f>
lea    (%rax,%rsi,8),%rcx
cmp    %rbx,%rcx
jbe    12bf <amoeba_nmsimplex_d+0x16f>
xor    %ecx,%ecx
mov    0x18(%rsp),%r9
jmp    13a9 <amoeba_nmsimplex_d+0x259>
mov    %esi,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    12e2 <amoeba_nmsimplex_d+0x192>
xor    %edi,%edi
jmp    135c <amoeba_nmsimplex_d+0x20c>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movups %xmm0,0x20(%rax,%rdi,8)
movups %xmm1,0x30(%rax,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm0
movups 0x50(%rbx,%rdi,8),%xmm1
movups %xmm0,0x40(%rax,%rdi,8)
movups %xmm1,0x50(%rax,%rdi,8)
movupd 0x60(%rbx,%rdi,8),%xmm0
movupd 0x70(%rbx,%rdi,8),%xmm1
movupd %xmm0,0x60(%rax,%rdi,8)
movupd %xmm1,0x70(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1300 <amoeba_nmsimplex_d+0x1b0>
test   %rdx,%rdx
mov    0x18(%rsp),%r9
je     139f <amoeba_nmsimplex_d+0x24f>
lea    (%rax,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1380 <amoeba_nmsimplex_d+0x230>
mov    0x8(%rsp),%rsi
cmp    %rsi,%rcx
je     1417 <amoeba_nmsimplex_d+0x2c7>
mov    %rcx,%rdx
not    %rdx
add    %rsi,%rdx
and    $0x3,%rsi
je     13d4 <amoeba_nmsimplex_d+0x284>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13c0 <amoeba_nmsimplex_d+0x270>
cmp    $0x3,%rdx
mov    0x8(%rsp),%rdx
jb     1417 <amoeba_nmsimplex_d+0x2c7>
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    13e0 <amoeba_nmsimplex_d+0x290>
test   %r13d,%r13d
setle  %r8b
jle    14fe <amoeba_nmsimplex_d+0x3ae>
mov    %r10d,%r12d
mov    0x8(%rsp),%r9
and    $0xfffffffe,%r9d
mov    $0x1,%edx
xor    %r10d,%r10d
jmp    146c <amoeba_nmsimplex_d+0x31c>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rdx,8),%xmm0
addsd  -0x8(%r14,%rdx,8),%xmm0
mov    %r11,%rdi
mov    (%r15,%rdx,8),%rax
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdx
add    $0x1,%r10
cmp    0x58(%rsp),%rdx
je     1505 <amoeba_nmsimplex_d+0x3b5>
lea    -0x1(%rdx),%r11
cmpl   $0x1,0x28(%rsp)
jne    1490 <amoeba_nmsimplex_d+0x340>
xor    %edi,%edi
testb  $0x1,0x8(%rsp)
je     1459 <amoeba_nmsimplex_d+0x309>
cmp    %rdi,%r11
je     1440 <amoeba_nmsimplex_d+0x2f0>
movsd  (%rbx,%rdi,8),%xmm0
jmp    1450 <amoeba_nmsimplex_d+0x300>
nopl   0x0(%rax)
mov    (%r15,%rdx,8),%rax
lea    -0x1(%r10),%rcx
xor    %edi,%edi
jmp    14be <amoeba_nmsimplex_d+0x36e>
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdx,8),%xmm0
addsd  -0x8(%r14,%rdx,8),%xmm0
mov    %r11,%rbp
movsd  %xmm0,(%rax,%rbp,8)
add    $0x2,%rdi
cmp    %rdi,%r9
je     1479 <amoeba_nmsimplex_d+0x329>
cmp    %rdi,%r10
jne    14e0 <amoeba_nmsimplex_d+0x390>
movsd  -0x8(%rbx,%rdx,8),%xmm0
addsd  -0x8(%r14,%rdx,8),%xmm0
mov    %r11,%rsi
jmp    14e8 <amoeba_nmsimplex_d+0x398>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rdi,8),%xmm0
mov    %rdi,%rsi
movsd  %xmm0,(%rax,%rsi,8)
cmp    %rdi,%rcx
je     14a0 <amoeba_nmsimplex_d+0x350>
lea    0x1(%rdi),%rbp
movsd  0x8(%rbx,%rdi,8),%xmm0
jmp    14b0 <amoeba_nmsimplex_d+0x360>
mov    0x20(%rsp),%rbx
jmp    151c <amoeba_nmsimplex_d+0x3cc>
mov    %r8b,0x17(%rsp)
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r13
mov    %r12d,%r10d
mov    0x190(%rsp),%eax
test   %r13d,%r13d
mov    %r10d,0x10(%rsp)
js     160f <amoeba_nmsimplex_d+0x4bf>
mov    %eax,%r13d
xor    %ebp,%ebp
mov    0x58(%rsp),%r12
mov    0x50(%rsp),%r14
mov    0x20(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rbp,8),%rdi
call   *%r14
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1550 <amoeba_nmsimplex_d+0x400>
test   %r13d,%r13d
je     1655 <amoeba_nmsimplex_d+0x505>
lea    0x2b54(%rip),%rdi
call   1050 <puts@plt>
mov    0x28(%rsp),%r13
test   %r13d,%r13d
js     1676 <amoeba_nmsimplex_d+0x526>
lea    0x2abc(%rip),%r14
xor    %ebp,%ebp
mov    0x8(%rsp),%rbx
jmp    15c2 <amoeba_nmsimplex_d+0x472>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
lea    0x2a9f(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    %r13,%rbp
cmp    0x58(%rsp),%r13
je     1641 <amoeba_nmsimplex_d+0x4f1>
lea    0x1(%rbp),%rsi
lea    0x2a73(%rip),%rdi
mov    %rsi,%r13
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,0x28(%rsp)
je     15a0 <amoeba_nmsimplex_d+0x450>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%r12,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%r12
cmp    %r12,%rbx
jne    15f0 <amoeba_nmsimplex_d+0x4a0>
jmp    15a0 <amoeba_nmsimplex_d+0x450>
test   %eax,%eax
je     169e <amoeba_nmsimplex_d+0x54e>
lea    0x2aab(%rip),%rdi
call   1050 <puts@plt>
mov    0x10(%rsp),%r10d
mov    0x28(%rsp),%r13
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%rbx
movl   $0x0,0x40(%rsp)
jmp    16a4 <amoeba_nmsimplex_d+0x554>
movl   $0x0,0x40(%rsp)
mov    0x58(%rsp),%r14
mov    0x20(%rsp),%rbx
jmp    1660 <amoeba_nmsimplex_d+0x510>
mov    $0x1,%al
mov    %eax,0x40(%rsp)
mov    0x58(%rsp),%r14
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rax
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r13
jmp    1697 <amoeba_nmsimplex_d+0x547>
movl   $0x0,0x40(%rsp)
mov    0x58(%rsp),%r14
mov    0x20(%rsp),%rbx
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rax
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10d
jmp    16b3 <amoeba_nmsimplex_d+0x563>
mov    $0x1,%al
mov    %eax,0x40(%rsp)
mov    0x58(%rsp),%r14
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rax
cvtsi2sd %r13d,%xmm5
mov    0x8(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    %rax,0xe8(%rsp)
lea    -0x1(%r14),%r11
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x78(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r14d,%esi
and    $0x3,%esi
mov    %rsi,0xf8(%rsp)
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
lea    0x2(%rsi),%rbp
and    %rax,%rbp
mov    %rbp,0x98(%rsp)
mov    %rdx,%rbp
neg    %rbp
mov    %rbp,0xc8(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rax,%rbp
mov    %rax,0x68(%rsp)
and    %rsi,%rax
mov    %rax,0xb0(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0xa0(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x100(%rsp)
mov    %rcx,0x140(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x90(%rsp)
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x138(%rsp)
lea    (%rdi,%rdx,8),%rax
mov    %rax,0xc0(%rsp)
lea    -0x2(%r14),%rax
mov    %rax,0xf0(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0xd8(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x128(%rsp)
mov    0x48(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x130(%rsp)
movl   $0x1,0x64(%rsp)
mov    %r12,0xd0(%rsp)
mov    %r11,0x120(%rsp)
movsd  %xmm5,0x118(%rsp)
mov    %r8,0x110(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x0,%esi
movl   $0x0,0x30(%rsp)
mov    $0x0,%ebp
test   %r13d,%r13d
js     1a50 <amoeba_nmsimplex_d+0x900>
xor    %eax,%eax
xor    %ecx,%ecx
cmp    $0x3,%r11
jae    19d0 <amoeba_nmsimplex_d+0x880>
mov    0xf8(%rsp),%rbp
mov    %ecx,%esi
test   %rbp,%rbp
je     1870 <amoeba_nmsimplex_d+0x720>
mov    %rbp,%rdx
jmp    184c <amoeba_nmsimplex_d+0x6fc>
nopl   (%rax)
add    $0x1,%rax
mov    %esi,%ecx
add    $0xffffffffffffffff,%rdx
je     1870 <amoeba_nmsimplex_d+0x720>
movsd  (%rbx,%rax,8),%xmm0
movslq %ecx,%rsi
ucomisd (%rbx,%rsi,8),%xmm0
mov    %eax,%esi
ja     1840 <amoeba_nmsimplex_d+0x6f0>
mov    %ecx,%esi
jmp    1840 <amoeba_nmsimplex_d+0x6f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r13d,%r13d
mov    %esi,0x30(%rsp)
js     1a40 <amoeba_nmsimplex_d+0x8f0>
xor    %eax,%eax
xor    %ecx,%ecx
cmp    $0x3,%r11
jae    18db <amoeba_nmsimplex_d+0x78b>
mov    %ecx,%esi
test   $0x3,%r14b
je     1930 <amoeba_nmsimplex_d+0x7e0>
mov    %rbp,%rdx
jmp    18b0 <amoeba_nmsimplex_d+0x760>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %esi,%ecx
add    $0xffffffffffffffff,%rdx
je     1930 <amoeba_nmsimplex_d+0x7e0>
movslq %ecx,%rsi
movsd  (%rbx,%rsi,8),%xmm0
ucomisd (%rbx,%rax,8),%xmm0
mov    %eax,%esi
ja     18a0 <amoeba_nmsimplex_d+0x750>
mov    %ecx,%esi
jmp    18a0 <amoeba_nmsimplex_d+0x750>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,%ecx
add    $0x4,%rax
cmp    %r8,%rax
je     1887 <amoeba_nmsimplex_d+0x737>
movslq %ecx,%rdx
movsd  (%rbx,%rdx,8),%xmm0
ucomisd (%rbx,%rax,8),%xmm0
mov    %eax,%edx
ja     18ee <amoeba_nmsimplex_d+0x79e>
mov    %ecx,%edx
movslq %edx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
ucomisd 0x8(%rbx,%rax,8),%xmm0
jbe    1901 <amoeba_nmsimplex_d+0x7b1>
lea    0x1(%rax),%edx
movslq %edx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
ucomisd 0x10(%rbx,%rax,8),%xmm0
jbe    1914 <amoeba_nmsimplex_d+0x7c4>
lea    0x2(%rax),%edx
movslq %edx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
ucomisd 0x18(%rbx,%rax,8),%xmm0
jbe    18d0 <amoeba_nmsimplex_d+0x780>
lea    0x3(%rax),%ecx
jmp    18d2 <amoeba_nmsimplex_d+0x782>
nopl   0x0(%rax)
test   %r13d,%r13d
js     1a46 <amoeba_nmsimplex_d+0x8f6>
movslq 0x30(%rsp),%rax
xor    %ecx,%ecx
mov    %esi,%ebp
test   %r11,%r11
jne    1989 <amoeba_nmsimplex_d+0x839>
test   $0x1,%r14b
je     1a50 <amoeba_nmsimplex_d+0x900>
movsd  (%rbx,%rcx,8),%xmm0
movslq %ebp,%rdx
ucomisd (%rbx,%rdx,8),%xmm0
jbe    1a50 <amoeba_nmsimplex_d+0x900>
movsd  (%rbx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1a50 <amoeba_nmsimplex_d+0x900>
mov    %ecx,%ebp
jmp    1a50 <amoeba_nmsimplex_d+0x900>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    %rcx,%r12
je     1947 <amoeba_nmsimplex_d+0x7f7>
movsd  (%rbx,%rcx,8),%xmm0
movslq %ebp,%rdx
ucomisd (%rbx,%rdx,8),%xmm0
jbe    19a5 <amoeba_nmsimplex_d+0x855>
movsd  (%rbx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    19a5 <amoeba_nmsimplex_d+0x855>
mov    %ecx,%ebp
movsd  0x8(%rbx,%rcx,8),%xmm0
movslq %ebp,%rdx
ucomisd (%rbx,%rdx,8),%xmm0
jbe    1980 <amoeba_nmsimplex_d+0x830>
movsd  (%rbx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1980 <amoeba_nmsimplex_d+0x830>
lea    0x1(%rcx),%ebp
jmp    1980 <amoeba_nmsimplex_d+0x830>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xf8(%rsp),%rbp
jmp    19ef <amoeba_nmsimplex_d+0x89f>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ecx
add    $0x4,%rax
cmp    %r8,%rax
je     1831 <amoeba_nmsimplex_d+0x6e1>
movslq %ecx,%rdx
movsd  (%rbx,%rax,8),%xmm0
ucomisd (%rbx,%rdx,8),%xmm0
mov    %eax,%edx
ja     1a02 <amoeba_nmsimplex_d+0x8b2>
mov    %ecx,%edx
movsd  0x8(%rbx,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%rbx,%rcx,8),%xmm0
jbe    1a15 <amoeba_nmsimplex_d+0x8c5>
lea    0x1(%rax),%edx
movsd  0x10(%rbx,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%rbx,%rcx,8),%xmm0
jbe    1a28 <amoeba_nmsimplex_d+0x8d8>
lea    0x2(%rax),%edx
movsd  0x18(%rbx,%rax,8),%xmm0
movslq %edx,%rcx
ucomisd (%rbx,%rcx,8),%xmm0
jbe    19e0 <amoeba_nmsimplex_d+0x890>
lea    0x3(%rax),%ecx
jmp    19e2 <amoeba_nmsimplex_d+0x892>
nopl   (%rax)
xor    %esi,%esi
xor    %ebp,%ebp
jmp    1a50 <amoeba_nmsimplex_d+0x900>
mov    %esi,%ebp
nopl   0x0(%rax,%rax,1)
mov    %esi,0xac(%rsp)
test   %r10b,%r10b
mov    0x8(%rsp),%rbx
je     1cd0 <amoeba_nmsimplex_d+0xb80>
mov    0x30(%rsp),%eax
xor    %ecx,%ecx
jmp    1a87 <amoeba_nmsimplex_d+0x937>
nopl   (%rax)
divsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rbx,%rcx
je     1b20 <amoeba_nmsimplex_d+0x9d0>
xorpd  %xmm0,%xmm0
test   %r13d,%r13d
js     1a70 <amoeba_nmsimplex_d+0x920>
test   %r11,%r11
je     1af0 <amoeba_nmsimplex_d+0x9a0>
xor    %esi,%esi
jmp    1aa9 <amoeba_nmsimplex_d+0x959>
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %r12,%rsi
je     1ae0 <amoeba_nmsimplex_d+0x990>
mov    %rsi,%rdx
cmp    %rsi,%rax
je     1aba <amoeba_nmsimplex_d+0x96a>
mov    (%r15,%rdx,8),%rsi
addsd  (%rsi,%rcx,8),%xmm0
lea    0x1(%rdx),%rsi
cmp    %rax,%rsi
je     1aa0 <amoeba_nmsimplex_d+0x950>
mov    0x8(%r15,%rdx,8),%rbx
addsd  (%rbx,%rcx,8),%xmm0
mov    0x8(%rsp),%rbx
jmp    1aa0 <amoeba_nmsimplex_d+0x950>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rdx
test   $0x1,%r14b
jne    1afc <amoeba_nmsimplex_d+0x9ac>
jmp    1a70 <amoeba_nmsimplex_d+0x920>
nopl   0x0(%rax)
xor    %edx,%edx
test   $0x1,%r14b
je     1a70 <amoeba_nmsimplex_d+0x920>
cmp    %rax,%rdx
je     1a70 <amoeba_nmsimplex_d+0x920>
mov    (%r15,%rdx,8),%rdx
addsd  (%rdx,%rcx,8),%xmm0
jmp    1a70 <amoeba_nmsimplex_d+0x920>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r10b,%r10b
je     1cd0 <amoeba_nmsimplex_d+0xb80>
movslq 0x30(%rsp),%rax
mov    (%r15,%rax,8),%rax
cmp    $0x4,%r13d
jb     1b53 <amoeba_nmsimplex_d+0xa03>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rdi
jae    1bd1 <amoeba_nmsimplex_d+0xa81>
cmp    %rax,0xc0(%rsp)
jbe    1bd1 <amoeba_nmsimplex_d+0xa81>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     1b7c <amoeba_nmsimplex_d+0xa2c>
movsd  (%r9,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xc8(%rsp),%rdx
je     1cd0 <amoeba_nmsimplex_d+0xb80>
nopl   (%rax)
movsd  (%r9,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1b90 <amoeba_nmsimplex_d+0xa40>
jmp    1cd0 <amoeba_nmsimplex_d+0xb80>
cmpq   $0x0,0x70(%rsp)
mov    0x68(%rsp),%rsi
je     1dfb <amoeba_nmsimplex_d+0xcab>
mov    0x98(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%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,(%rdi,%rcx,8)
movupd %xmm2,0x10(%rdi,%rcx,8)
movupd 0x20(%r9,%rcx,8),%xmm0
movupd 0x30(%r9,%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(%rdi,%rcx,8)
movupd %xmm2,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1bf0 <amoeba_nmsimplex_d+0xaa0>
test   $0x1,%sil
je     1cb8 <amoeba_nmsimplex_d+0xb68>
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%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,(%rdi,%rcx,8)
movupd %xmm2,0x10(%rdi,%rcx,8)
mov    0x78(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
jne    1b55 <amoeba_nmsimplex_d+0xa05>
nopl   0x0(%rax)
call   *0x50(%rsp)
mov    0x10(%rsp),%r11d
mov    0xb8(%rsp),%rdi
movapd %xmm0,%xmm3
movslq %ebp,%r12
mov    0x20(%rsp),%r8
movsd  (%r8,%r12,8),%xmm0
ucomisd %xmm3,%xmm0
movslq 0xac(%rsp),%r10
mov    0x30(%rsp),%esi
jbe    1ef9 <amoeba_nmsimplex_d+0xda9>
ucomisd (%r8,%r10,8),%xmm3
jb     1ef9 <amoeba_nmsimplex_d+0xda9>
movslq %esi,%r9
test   %r11b,%r11b
mov    %rbx,%rax
mov    0x38(%rsp),%rbx
je     1ef0 <amoeba_nmsimplex_d+0xda0>
mov    (%r15,%r9,8),%rcx
cmpl   $0x4,0x28(%rsp)
jb     1d54 <amoeba_nmsimplex_d+0xc04>
cmp    %rcx,0xc0(%rsp)
jbe    1dec <amoeba_nmsimplex_d+0xc9c>
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rdx
cmp    %rdx,%rbx
jae    1dec <amoeba_nmsimplex_d+0xc9c>
xor    %edx,%edx
mov    0x8(%rsp),%rax
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
mov    0xa0(%rsp),%rax
test   %rax,%rax
je     1d94 <amoeba_nmsimplex_d+0xc44>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1d80 <amoeba_nmsimplex_d+0xc30>
cmp    $0x3,%rsi
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%esi
jb     1ef0 <amoeba_nmsimplex_d+0xda0>
nopw   0x0(%rax,%rax,1)
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,%rax
jne    1db0 <amoeba_nmsimplex_d+0xc60>
jmp    1ef0 <amoeba_nmsimplex_d+0xda0>
cmpq   $0xc,0x70(%rsp)
jae    1e0c <amoeba_nmsimplex_d+0xcbc>
xor    %edx,%edx
jmp    1e7c <amoeba_nmsimplex_d+0xd2c>
xor    %ecx,%ecx
test   $0x1,%sil
jne    1c7d <amoeba_nmsimplex_d+0xb2d>
jmp    1cb8 <amoeba_nmsimplex_d+0xb68>
mov    0xb0(%rsp),%rsi
xor    %edx,%edx
cs 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    1e20 <amoeba_nmsimplex_d+0xcd0>
cmpq   $0x0,0x140(%rsp)
mov    0x90(%rsp),%rbp
je     1ecf <amoeba_nmsimplex_d+0xd7f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd8(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
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,%rbp
jne    1eb0 <amoeba_nmsimplex_d+0xd60>
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
mov    0x8(%rsp),%rax
cmp    %rax,%rsi
mov    0x30(%rsp),%esi
jne    1d5b <amoeba_nmsimplex_d+0xc0b>
nopl   0x0(%rax)
movsd  %xmm3,(%r8,%r9,8)
mov    %rax,%rbx
mov    %r10,0x150(%rsp)
movsd  (%r8,%r10,8),%xmm0
ucomisd %xmm3,%xmm0
jbe    1f40 <amoeba_nmsimplex_d+0xdf0>
test   %r11b,%r11b
movsd  %xmm3,0x108(%rsp)
je     1fb0 <amoeba_nmsimplex_d+0xe60>
cmpl   $0x4,0x28(%rsp)
mov    0x38(%rsp),%rdx
mov    0x18(%rsp),%rsi
jae    2028 <amoeba_nmsimplex_d+0xed8>
xor    %eax,%eax
jmp    2120 <amoeba_nmsimplex_d+0xfd0>
nopl   0x0(%rax,%rax,1)
addl   $0x1,0x44(%rsp)
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r10
movsd  0x20dc(%rip),%xmm4
movapd 0x20ac(%rip),%xmm5
ucomisd (%r8,%r12,8),%xmm3
jb     2d0c <amoeba_nmsimplex_d+0x1bbc>
movslq %esi,%r13
movsd  (%r8,%r13,8),%xmm0
ucomisd %xmm3,%xmm0
jbe    2000 <amoeba_nmsimplex_d+0xeb0>
test   %r11b,%r11b
mov    0x48(%rsp),%rbp
je     26d0 <amoeba_nmsimplex_d+0x1580>
cmp    $0x4,%r10d
jae    234c <amoeba_nmsimplex_d+0x11fc>
xor    %eax,%eax
mov    0x8(%rsp),%rcx
jmp    2450 <amoeba_nmsimplex_d+0x1300>
nopw   0x0(%rax,%rax,1)
call   *0x50(%rsp)
movsd  0x108(%rsp),%xmm3
mov    0x30(%rsp),%esi
mov    0x10(%rsp),%r11d
mov    0x20(%rsp),%r8
addl   $0x2,0x44(%rsp)
ucomisd %xmm0,%xmm3
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r10
movsd  0x204d(%rip),%xmm4
movapd 0x201d(%rip),%xmm5
ja     24c6 <amoeba_nmsimplex_d+0x1376>
jmp    24f6 <amoeba_nmsimplex_d+0x13a6>
xchg   %ax,%ax
test   %r11b,%r11b
mov    0x48(%rsp),%rbp
je     26d0 <amoeba_nmsimplex_d+0x1580>
mov    (%r15,%r13,8),%rax
cmp    $0x4,%r10d
jae    247b <amoeba_nmsimplex_d+0x132b>
xor    %edx,%edx
mov    0x8(%rsp),%rsi
jmp    2633 <amoeba_nmsimplex_d+0x14e3>
cmpq   $0x0,0x70(%rsp)
mov    0x68(%rsp),%rbp
je     2502 <amoeba_nmsimplex_d+0x13b2>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%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,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm0
movupd 0x30(%rsi,%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(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2050 <amoeba_nmsimplex_d+0xf00>
test   $0x1,%bpl
je     210e <amoeba_nmsimplex_d+0xfbe>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%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,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
mov    0x78(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     2144 <amoeba_nmsimplex_d+0xff4>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    2120 <amoeba_nmsimplex_d+0xfd0>
call   *0x50(%rsp)
mov    0x44(%rsp),%eax
add    $0x2,%eax
movsd  0x108(%rsp),%xmm3
ucomisd %xmm0,%xmm3
mov    %eax,0x44(%rsp)
jbe    225c <amoeba_nmsimplex_d+0x110c>
mov    0x10(%rsp),%r11d
test   %r11b,%r11b
je     249e <amoeba_nmsimplex_d+0x134e>
movslq 0x30(%rsp),%r13
mov    (%r15,%r13,8),%rcx
mov    0x28(%rsp),%r10
cmp    $0x4,%r10d
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%rbx
mov    0xb8(%rsp),%rax
mov    0x18(%rsp),%r9
movsd  0x1e93(%rip),%xmm4
movapd 0x1e63(%rip),%xmm5
jb     21cf <amoeba_nmsimplex_d+0x107f>
cmp    %rcx,0x138(%rsp)
jbe    2a20 <amoeba_nmsimplex_d+0x18d0>
mov    0x8(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
cmp    %rdx,%rax
jae    2a20 <amoeba_nmsimplex_d+0x18d0>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
mov    0x8(%rsp),%rdi
add    %rdi,%rsi
test   $0x3,%dil
je     2204 <amoeba_nmsimplex_d+0x10b4>
mov    0xa0(%rsp),%rdi
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    21f0 <amoeba_nmsimplex_d+0x10a0>
cmp    $0x3,%rsi
jb     2cf6 <amoeba_nmsimplex_d+0x1ba6>
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdx,8)
movsd  0x10(%rax,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rdx,8)
movsd  0x18(%rax,%rdx,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    2220 <amoeba_nmsimplex_d+0x10d0>
jmp    2cf6 <amoeba_nmsimplex_d+0x1ba6>
mov    0x10(%rsp),%r11d
test   %r11b,%r11b
je     24ce <amoeba_nmsimplex_d+0x137e>
movslq 0x30(%rsp),%r13
mov    (%r15,%r13,8),%rcx
mov    0x28(%rsp),%r10
cmp    $0x4,%r10d
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%r9
movsd  0x1da5(%rip),%xmm4
movapd 0x1d75(%rip),%xmm5
jb     22bd <amoeba_nmsimplex_d+0x116d>
cmp    %rcx,0xc0(%rsp)
jbe    2a33 <amoeba_nmsimplex_d+0x18e3>
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rdx
cmp    %rdx,%rbx
jae    2a33 <amoeba_nmsimplex_d+0x18e3>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
mov    0x8(%rsp),%rax
add    %rax,%rsi
test   $0x3,%al
je     22f4 <amoeba_nmsimplex_d+0x11a4>
mov    0xa0(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    22e0 <amoeba_nmsimplex_d+0x1190>
cmp    $0x3,%rsi
mov    0x8(%rsp),%rax
jb     2cf2 <amoeba_nmsimplex_d+0x1ba2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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,%rax
jne    2310 <amoeba_nmsimplex_d+0x11c0>
jmp    2cf2 <amoeba_nmsimplex_d+0x1ba2>
cmpq   $0x0,0x70(%rsp)
mov    0x68(%rsp),%rdx
je     2a10 <amoeba_nmsimplex_d+0x18c0>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%r9,%rax,8),%xmm0
movupd 0x10(%r9,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
movupd 0x20(%r9,%rax,8),%xmm0
movupd 0x30(%r9,%rax,8),%xmm1
movupd 0x20(%rbx,%rax,8),%xmm2
movupd 0x30(%rbx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rbp,%rax,8)
movupd %xmm3,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2370 <amoeba_nmsimplex_d+0x1220>
test   $0x1,%dl
je     2439 <amoeba_nmsimplex_d+0x12e9>
movupd (%r9,%rax,8),%xmm0
movupd 0x10(%r9,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
mov    0x78(%rsp),%rdx
mov    %rdx,%rax
mov    0x8(%rsp),%rcx
cmp    %rcx,%rdx
je     26d0 <amoeba_nmsimplex_d+0x1580>
nop
movsd  (%r9,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    2450 <amoeba_nmsimplex_d+0x1300>
jmp    26d0 <amoeba_nmsimplex_d+0x1580>
mov    0x8(%rsp),%rsi
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%rbp
jae    2513 <amoeba_nmsimplex_d+0x13c3>
cmp    %rax,0xe8(%rsp)
jbe    2513 <amoeba_nmsimplex_d+0x13c3>
xor    %edx,%edx
jmp    2633 <amoeba_nmsimplex_d+0x14e3>
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r10
movsd  0x1b7e(%rip),%xmm4
movapd 0x1b4e(%rip),%xmm5
mov    0x30(%rsp),%esi
movslq %esi,%r13
jmp    2cfa <amoeba_nmsimplex_d+0x1baa>
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r10
movsd  0x1b4e(%rip),%xmm4
movapd 0x1b1e(%rip),%xmm5
mov    0x30(%rsp),%esi
movslq %esi,%r13
movapd %xmm3,%xmm0
jmp    2cfa <amoeba_nmsimplex_d+0x1baa>
xor    %eax,%eax
test   $0x1,%bpl
jne    20d5 <amoeba_nmsimplex_d+0xf85>
jmp    210e <amoeba_nmsimplex_d+0xfbe>
cmpq   $0x0,0x70(%rsp)
mov    0x68(%rsp),%rdi
movapd 0x1ada(%rip),%xmm5
je     2b2b <amoeba_nmsimplex_d+0x19db>
mov    0x98(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%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,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
movupd 0x20(%r9,%rcx,8),%xmm0
movupd 0x30(%r9,%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(%rbp,%rcx,8)
movupd %xmm2,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2540 <amoeba_nmsimplex_d+0x13f0>
test   $0x1,%dil
je     2622 <amoeba_nmsimplex_d+0x14d2>
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%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,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
mov    0x78(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
je     26d0 <amoeba_nmsimplex_d+0x1580>
mov    %rdx,%rcx
test   $0x1,%sil
je     2664 <amoeba_nmsimplex_d+0x1514>
movsd  (%r9,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
mulsd  0x19dd(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xc8(%rsp),%rdx
mov    0x8(%rsp),%rdx
je     26d0 <amoeba_nmsimplex_d+0x1580>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r9,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0x1999(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    2680 <amoeba_nmsimplex_d+0x1530>
nopl   (%rax)
mov    %rbp,%rdi
call   *0x50(%rsp)
mov    0x20(%rsp),%r8
movsd  (%r8,%r13,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    27a0 <amoeba_nmsimplex_d+0x1650>
cmpb   $0x0,0x10(%rsp)
mov    0x8(%rsp),%rbx
je     2b10 <amoeba_nmsimplex_d+0x19c0>
mov    (%r15,%r13,8),%rax
cmpl   $0x4,0x28(%rsp)
jb     2722 <amoeba_nmsimplex_d+0x15d2>
cmp    %rax,0xe8(%rsp)
jbe    29f4 <amoeba_nmsimplex_d+0x18a4>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%rbp
jae    29f4 <amoeba_nmsimplex_d+0x18a4>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     2755 <amoeba_nmsimplex_d+0x1605>
mov    0xa0(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2740 <amoeba_nmsimplex_d+0x15f0>
cmp    $0x3,%rdx
jb     2b10 <amoeba_nmsimplex_d+0x19c0>
nop
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    2760 <amoeba_nmsimplex_d+0x1610>
jmp    2b10 <amoeba_nmsimplex_d+0x19c0>
nopl   (%rax)
mov    %r13,0x30(%rsp)
mov    0x28(%rsp),%r13
test   %r13d,%r13d
mov    0x8(%rsp),%rbx
mov    0x17(%rsp),%al
mov    0x68(%rsp),%r9
mov    0xc8(%rsp),%r10
movsd  0x186d(%rip),%xmm6
movapd 0x183d(%rip),%xmm7
mov    0x150(%rsp),%r11
js     29b0 <amoeba_nmsimplex_d+0x1860>
mov    0xac(%rsp),%r8d
xor    %ecx,%ecx
jmp    27fd <amoeba_nmsimplex_d+0x16ad>
nopl   (%rax)
add    $0x1,%rcx
cmp    %r14,%rcx
je     29b0 <amoeba_nmsimplex_d+0x1860>
cmp    %r8,%rcx
sete   %dl
or     %al,%dl
jne    27f0 <amoeba_nmsimplex_d+0x16a0>
mov    (%r15,%r11,8),%rdx
mov    (%r15,%rcx,8),%rsi
cmp    $0x4,%r13d
jb     282f <amoeba_nmsimplex_d+0x16df>
lea    (%rdx,%rbx,8),%rdi
cmp    %rdi,%rsi
jae    28b7 <amoeba_nmsimplex_d+0x1767>
lea    (%rsi,%rbx,8),%rdi
cmp    %rdi,%rdx
jae    28b7 <amoeba_nmsimplex_d+0x1767>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%bl
je     285b <amoeba_nmsimplex_d+0x170b>
movsd  (%rdx,%rbp,8),%xmm0
movsd  (%rsi,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    %r10,%rbp
je     27f0 <amoeba_nmsimplex_d+0x16a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rdi,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  0x8(%rsi,%rdi,8),%xmm2
subsd  %xmm0,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
subsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbx
jne    2870 <amoeba_nmsimplex_d+0x1720>
jmp    27f0 <amoeba_nmsimplex_d+0x16a0>
cmpq   $0x0,0x70(%rsp)
je     29a4 <amoeba_nmsimplex_d+0x1854>
mov    0x98(%rsp),%rbp
xor    %edi,%edi
nopl   (%rax)
movupd (%rdx,%rdi,8),%xmm0
movupd 0x10(%rdx,%rdi,8),%xmm1
movupd (%rsi,%rdi,8),%xmm2
movupd 0x10(%rsi,%rdi,8),%xmm3
movupd 0x20(%rsi,%rdi,8),%xmm4
movupd 0x30(%rsi,%rdi,8),%xmm5
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm0,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
movupd 0x20(%rdx,%rdi,8),%xmm0
movupd 0x30(%rdx,%rdi,8),%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm1,%xmm5
mulpd  %xmm7,%xmm4
mulpd  %xmm7,%xmm5
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm5
movupd %xmm4,0x20(%rsi,%rdi,8)
movupd %xmm5,0x30(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    28d0 <amoeba_nmsimplex_d+0x1780>
test   $0x1,%r9b
je     298e <amoeba_nmsimplex_d+0x183e>
movupd (%rdx,%rdi,8),%xmm0
movupd 0x10(%rdx,%rdi,8),%xmm1
movupd (%rsi,%rdi,8),%xmm2
movupd 0x10(%rsi,%rdi,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm0,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
mov    0x78(%rsp),%rdi
mov    %rdi,%rbp
cmp    %rbx,%rdi
je     27f0 <amoeba_nmsimplex_d+0x16a0>
jmp    2831 <amoeba_nmsimplex_d+0x16e1>
xor    %edi,%edi
test   $0x1,%r9b
jne    2955 <amoeba_nmsimplex_d+0x1805>
jmp    298e <amoeba_nmsimplex_d+0x183e>
xchg   %ax,%ax
mov    0x30(%rsp),%rbx
mov    (%r15,%rbx,8),%rdi
mov    0x50(%rsp),%r13
call   *%r13
mov    0x20(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%rbx,8)
mov    (%r15,%r12,8),%rdi
call   *%r13
mov    0x8(%rsp),%rbx
movsd  %xmm0,0x0(%rbp,%r12,8)
addl   $0x3,0x44(%rsp)
cmpb   $0x0,0x40(%rsp)
jne    2d18 <amoeba_nmsimplex_d+0x1bc8>
jmp    2d90 <amoeba_nmsimplex_d+0x1c40>
cmpq   $0xc,0x70(%rsp)
jae    2a46 <amoeba_nmsimplex_d+0x18f6>
xor    %ecx,%ecx
mov    0x68(%rsp),%rsi
mov    0x90(%rsp),%rdi
jmp    2abd <amoeba_nmsimplex_d+0x196d>
xor    %eax,%eax
test   $0x1,%dl
jne    23fd <amoeba_nmsimplex_d+0x12ad>
jmp    2439 <amoeba_nmsimplex_d+0x12e9>
cmpq   $0xc,0x70(%rsp)
jae    2b3c <amoeba_nmsimplex_d+0x19ec>
xor    %edx,%edx
jmp    2bac <amoeba_nmsimplex_d+0x1a5c>
cmpq   $0xc,0x70(%rsp)
jae    2c17 <amoeba_nmsimplex_d+0x1ac7>
xor    %edx,%edx
jmp    2c8c <amoeba_nmsimplex_d+0x1b3c>
mov    0xb0(%rsp),%rdx
xor    %ecx,%ecx
mov    0x68(%rsp),%rsi
mov    0x90(%rsp),%rdi
nopl   (%rax)
movups 0x0(%rbp,%rcx,8),%xmm1
movups 0x10(%rbp,%rcx,8),%xmm2
movups %xmm1,(%rax,%rcx,8)
movups %xmm2,0x10(%rax,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm1
movups 0x30(%rbp,%rcx,8),%xmm2
movups %xmm1,0x20(%rax,%rcx,8)
movups %xmm2,0x30(%rax,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm1
movups 0x50(%rbp,%rcx,8),%xmm2
movups %xmm1,0x40(%rax,%rcx,8)
movups %xmm2,0x50(%rax,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm1
movupd 0x70(%rbp,%rcx,8),%xmm2
movupd %xmm1,0x60(%rax,%rcx,8)
movupd %xmm2,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2a60 <amoeba_nmsimplex_d+0x1910>
test   $0x3,%sil
je     2aff <amoeba_nmsimplex_d+0x19af>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0x130(%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,%rdi
jne    2ae0 <amoeba_nmsimplex_d+0x1990>
mov    0x78(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
jne    2724 <amoeba_nmsimplex_d+0x15d4>
addl   $0x1,0x44(%rsp)
movsd  %xmm0,(%r8,%r13,8)
cmpb   $0x0,0x40(%rsp)
jne    2d18 <amoeba_nmsimplex_d+0x1bc8>
jmp    2d90 <amoeba_nmsimplex_d+0x1c40>
xor    %ecx,%ecx
test   $0x1,%dil
jne    25de <amoeba_nmsimplex_d+0x148e>
jmp    2622 <amoeba_nmsimplex_d+0x14d2>
mov    0xb0(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rdx,8),%xmm1
movups 0x10(%rax,%rdx,8),%xmm2
movups %xmm1,(%rcx,%rdx,8)
movups %xmm2,0x10(%rcx,%rdx,8)
movups 0x20(%rax,%rdx,8),%xmm1
movups 0x30(%rax,%rdx,8),%xmm2
movups %xmm1,0x20(%rcx,%rdx,8)
movups %xmm2,0x30(%rcx,%rdx,8)
movups 0x40(%rax,%rdx,8),%xmm1
movups 0x50(%rax,%rdx,8),%xmm2
movups %xmm1,0x40(%rcx,%rdx,8)
movups %xmm2,0x50(%rcx,%rdx,8)
movupd 0x60(%rax,%rdx,8),%xmm1
movupd 0x70(%rax,%rdx,8),%xmm2
movupd %xmm1,0x60(%rcx,%rdx,8)
movupd %xmm2,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    2b50 <amoeba_nmsimplex_d+0x1a00>
testb  $0x3,0x68(%rsp)
mov    0x90(%rsp),%rbp
je     2bff <amoeba_nmsimplex_d+0x1aaf>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0x128(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm1
movupd (%rdx,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rdi,1)
movupd %xmm2,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    2be0 <amoeba_nmsimplex_d+0x1a90>
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
cmp    0x8(%rsp),%rsi
je     2cf6 <amoeba_nmsimplex_d+0x1ba6>
jmp    21d1 <amoeba_nmsimplex_d+0x1081>
mov    0xb0(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   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    2c30 <amoeba_nmsimplex_d+0x1ae0>
testb  $0x3,0x68(%rsp)
mov    0x90(%rsp),%rax
je     2cdf <amoeba_nmsimplex_d+0x1b8f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    2cc0 <amoeba_nmsimplex_d+0x1b70>
mov    0x78(%rsp),%rax
mov    %rax,%rdx
cmp    0x8(%rsp),%rax
jne    22bf <amoeba_nmsimplex_d+0x116f>
movapd %xmm3,%xmm0
mov    0x30(%rsp),%esi
movsd  %xmm0,(%r8,%r13,8)
ucomisd (%r8,%r12,8),%xmm3
jae    1f70 <amoeba_nmsimplex_d+0xe20>
mov    0x8(%rsp),%rbx
cmpb   $0x0,0x40(%rsp)
je     2d90 <amoeba_nmsimplex_d+0x1c40>
mov    0x20(%rsp),%rbx
movsd  (%rbx),%xmm0
mov    0x28(%rsp),%r13
test   %r13d,%r13d
mov    0x120(%rsp),%r11
movsd  0x118(%rsp),%xmm5
mov    0x110(%rsp),%r8
mov    0xa0(%rsp),%rdx
jle    2e40 <amoeba_nmsimplex_d+0x1cf0>
mov    $0x1,%eax
cmpq   $0x3,0xf0(%rsp)
mov    0x38(%rsp),%rdi
mov    0x10(%rsp),%r10d
mov    0xd0(%rsp),%r12
movapd %xmm0,%xmm1
jae    2e70 <amoeba_nmsimplex_d+0x1d20>
mov    0x48(%rsp),%rbp
mov    0x18(%rsp),%r9
jmp    2ee5 <amoeba_nmsimplex_d+0x1d95>
nopl   0x0(%rax)
lea    0x12c0(%rip),%rdi
mov    0x64(%rsp),%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x28(%rsp),%r13
test   %r13d,%r13d
js     2f24 <amoeba_nmsimplex_d+0x1dd4>
xor    %ebp,%ebp
jmp    2dec <amoeba_nmsimplex_d+0x1c9c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
lea    0x127f(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    %r14,%rbp
mov    0x58(%rsp),%rax
cmp    %rax,%r14
mov    %rax,%r14
je     2d18 <amoeba_nmsimplex_d+0x1bc8>
lea    0x1(%rbp),%r14
lea    0x1249(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmpb   $0x0,0x10(%rsp)
lea    0x123e(%rip),%r12
je     2dc0 <amoeba_nmsimplex_d+0x1c70>
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%r13,8),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%r13
cmp    %r13,%rbx
jne    2e20 <amoeba_nmsimplex_d+0x1cd0>
jmp    2dc0 <amoeba_nmsimplex_d+0x1c70>
nop
movapd %xmm0,%xmm2
movapd %xmm0,%xmm3
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rbp
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10d
jmp    2f5e <amoeba_nmsimplex_d+0x1e0e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x48(%rsp),%rbp
mov    0x18(%rsp),%r9
mov    0x100(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x8(%rbx,%rax,8),%xmm2
movsd  0x10(%rbx,%rax,8),%xmm3
movapd %xmm2,%xmm4
maxsd  %xmm1,%xmm4
minsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
maxsd  %xmm4,%xmm0
minsd  %xmm2,%xmm3
movsd  0x18(%rbx,%rax,8),%xmm2
movapd %xmm2,%xmm4
maxsd  %xmm0,%xmm4
minsd  %xmm3,%xmm2
movsd  0x20(%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
maxsd  %xmm4,%xmm1
minsd  %xmm2,%xmm0
add    $0x4,%rax
cmp    %rax,%rcx
jne    2e90 <amoeba_nmsimplex_d+0x1d40>
add    $0x1,%rax
movapd %xmm1,%xmm2
movapd %xmm0,%xmm3
test   $0x3,%r11b
je     2f66 <amoeba_nmsimplex_d+0x1e16>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm3
movapd %xmm3,%xmm2
maxsd  %xmm1,%xmm2
minsd  %xmm0,%xmm3
add    $0x1,%rcx
movapd %xmm3,%xmm0
movapd %xmm2,%xmm1
cmp    %rcx,%rdx
jne    2f00 <amoeba_nmsimplex_d+0x1db0>
jmp    2f66 <amoeba_nmsimplex_d+0x1e16>
mov    0x20(%rsp),%rbx
movsd  (%rbx),%xmm2
movapd %xmm2,%xmm3
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rbp
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10d
mov    0x120(%rsp),%r11
movsd  0x118(%rsp),%xmm5
mov    0x110(%rsp),%r8
mov    0xd0(%rsp),%r12
movapd %xmm2,%xmm0
subsd  %xmm3,%xmm0
movapd 0x10aa(%rip),%xmm1
andpd  %xmm1,%xmm0
addsd  %xmm0,%xmm0
andpd  %xmm1,%xmm2
andpd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
divsd  %xmm3,%xmm0
movsd  0x148(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     2fbb <amoeba_nmsimplex_d+0x1e6b>
mov    0x64(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x64(%rsp)
cmp    $0x1389,%eax
jne    1800 <amoeba_nmsimplex_d+0x6b0>
movl   $0x1389,0x64(%rsp)
mov    0xe0(%rsp),%rax
movsd  %xmm0,(%rax)
xor    %r12d,%r12d
test   %r13d,%r13d
jle    2ff2 <amoeba_nmsimplex_d+0x1ea2>
and    $0x3,%r11d
cmpq   $0x3,0xf0(%rsp)
jae    3123 <amoeba_nmsimplex_d+0x1fd3>
mov    $0x1,%eax
mov    %r12d,%ecx
test   %r11,%r11
jne    301d <amoeba_nmsimplex_d+0x1ecd>
movslq %ecx,%r12
cmpb   $0x0,0x40(%rsp)
mov    0x8(%rsp),%rbx
je     3033 <amoeba_nmsimplex_d+0x1ee3>
test   %r10b,%r10b
jne    3096 <amoeba_nmsimplex_d+0x1f46>
jmp    31a6 <amoeba_nmsimplex_d+0x2056>
nopl   0x0(%rax)
add    $0x1,%rax
mov    %ecx,%r12d
add    $0xffffffffffffffff,%r11
je     2fef <amoeba_nmsimplex_d+0x1e9f>
movslq %r12d,%rcx
movsd  (%rbx,%rcx,8),%xmm1
ucomisd (%rbx,%rax,8),%xmm1
mov    %eax,%ecx
ja     3010 <amoeba_nmsimplex_d+0x1ec0>
mov    %r12d,%ecx
jmp    3010 <amoeba_nmsimplex_d+0x1ec0>
lea    0x102b(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
cmpb   $0x0,0x10(%rsp)
je     319c <amoeba_nmsimplex_d+0x204c>
xor    %ebp,%ebp
lea    0x1038(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%r12,8),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    3060 <amoeba_nmsimplex_d+0x1f10>
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpb   $0x0,0x10(%rsp)
mov    0x48(%rsp),%rbp
je     31a6 <amoeba_nmsimplex_d+0x2056>
mov    (%r15,%r12,8),%rdi
mov    %r13,%rax
cmp    $0x4,%eax
jb     30c4 <amoeba_nmsimplex_d+0x1f74>
lea    (%rdi,%rbx,8),%rax
mov    0x80(%rsp),%rsi
cmp    %rsi,%rax
jbe    321c <amoeba_nmsimplex_d+0x20cc>
lea    (%rsi,%rbx,8),%rax
cmp    %rax,%rdi
jae    321c <amoeba_nmsimplex_d+0x20cc>
xor    %eax,%eax
mov    0x88(%rsp),%r14
mov    0x50(%rsp),%r8
mov    %rax,%rcx
not    %rcx
mov    0x8(%rsp),%rdx
add    %rdx,%rcx
and    $0x3,%rdx
je     31bc <amoeba_nmsimplex_d+0x206c>
mov    0x80(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    3100 <amoeba_nmsimplex_d+0x1fb0>
cmp    $0x3,%rcx
jae    31ce <amoeba_nmsimplex_d+0x207e>
jmp    330f <amoeba_nmsimplex_d+0x21bf>
xor    %edx,%edx
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    3149 <amoeba_nmsimplex_d+0x1ff9>
xchg   %ax,%ax
add    $0x4,%rax
add    $0x4,%rcx
mov    %r12d,%edx
cmp    0x100(%rsp),%rcx
je     2fe7 <amoeba_nmsimplex_d+0x1e97>
movslq %edx,%rsi
movsd  (%rbx,%rsi,8),%xmm1
ucomisd (%rbx,%rax,8),%xmm1
mov    %eax,%r12d
ja     315e <amoeba_nmsimplex_d+0x200e>
mov    %edx,%r12d
movslq %r12d,%rdx
movsd  (%rbx,%rdx,8),%xmm1
ucomisd 0x8(%rbx,%rax,8),%xmm1
jbe    3172 <amoeba_nmsimplex_d+0x2022>
lea    0x1(%rax),%r12d
movslq %r12d,%rdx
movsd  (%rbx,%rdx,8),%xmm1
ucomisd 0x10(%rbx,%rax,8),%xmm1
jbe    3186 <amoeba_nmsimplex_d+0x2036>
lea    0x2(%rax),%r12d
movslq %r12d,%rdx
movsd  (%rbx,%rdx,8),%xmm1
ucomisd 0x18(%rbx,%rax,8),%xmm1
jbe    3130 <amoeba_nmsimplex_d+0x1fe0>
lea    0x3(%rax),%r12d
jmp    3130 <amoeba_nmsimplex_d+0x1fe0>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    (%r15,%r12,8),%rdi
mov    0x88(%rsp),%r14
mov    0x50(%rsp),%r8
jmp    330f <amoeba_nmsimplex_d+0x21bf>
mov    0x80(%rsp),%rsi
cmp    $0x3,%rcx
jb     330f <amoeba_nmsimplex_d+0x21bf>
mov    0x8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rax,8)
movsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    31e0 <amoeba_nmsimplex_d+0x2090>
jmp    330f <amoeba_nmsimplex_d+0x21bf>
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    0x68(%rsp),%rcx
mov    %ecx,%ebx
and    $0x3,%ebx
cmpq   $0xc,0x70(%rsp)
jae    3244 <amoeba_nmsimplex_d+0x20f4>
xor    %edx,%edx
mov    0x88(%rsp),%r14
mov    0x50(%rsp),%r8
jmp    32bc <amoeba_nmsimplex_d+0x216c>
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
and    %rdx,%rcx
xor    %edx,%edx
mov    0x88(%rsp),%r14
mov    0x50(%rsp),%r8
movups (%rdi,%rdx,8),%xmm0
movups 0x10(%rdi,%rdx,8),%xmm1
movups %xmm0,(%rsi,%rdx,8)
movups %xmm1,0x10(%rsi,%rdx,8)
movups 0x20(%rdi,%rdx,8),%xmm0
movups 0x30(%rdi,%rdx,8),%xmm1
movups %xmm0,0x20(%rsi,%rdx,8)
movups %xmm1,0x30(%rsi,%rdx,8)
movups 0x40(%rdi,%rdx,8),%xmm0
movups 0x50(%rdi,%rdx,8),%xmm1
movups %xmm0,0x40(%rsi,%rdx,8)
movups %xmm1,0x50(%rsi,%rdx,8)
movupd 0x60(%rdi,%rdx,8),%xmm0
movupd 0x70(%rdi,%rdx,8),%xmm1
movupd %xmm0,0x60(%rsi,%rdx,8)
movupd %xmm1,0x70(%rsi,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rcx
jne    3260 <amoeba_nmsimplex_d+0x2110>
test   %rbx,%rbx
je     32ff <amoeba_nmsimplex_d+0x21af>
lea    (%rsi,%rdx,8),%rsi
add    $0x10,%rsi
lea    (%rdi,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbp,1),%xmm0
movupd (%rdx,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    32e0 <amoeba_nmsimplex_d+0x2190>
cmp    0x8(%rsp),%rax
mov    0x48(%rsp),%rbp
jne    30d3 <amoeba_nmsimplex_d+0x1f83>
call   *%r8
movsd  %xmm0,0x8(%rsp)
mov    0x44(%rsp),%ebx
add    $0x1,%ebx
cmpb   $0x0,0x40(%rsp)
jne    3348 <amoeba_nmsimplex_d+0x21f8>
lea    0xd64(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd6d(%rip),%rdi
mov    0x64(%rsp),%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %ebx,(%r14)
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
test   %r13d,%r13d
mov    0x58(%rsp),%r14
js     33a2 <amoeba_nmsimplex_d+0x2252>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%r14
jne    3390 <amoeba_nmsimplex_d+0x2240>
mov    %r15,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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