int simplx(double *p, double *y, int ndim, double *pr, int na, double ftol,
           double atol, int *lista, double (*funk)(), int itmax, int *iter,
           int *ilo, int *ihi) {
  static double alpha = 1.0, beta = 0.5, gamma = 2.0;
  double *pbar, *prr;
  double yprr, ypr;
  int inhi, mpts;
  int i, j;
  if (!(pbar = (double *)malloc(na * sizeof(double))) ||
      !(prr = (double *)malloc(na * sizeof(double)))) {
    printf("SIMPLX: Error - not enough memory\n");
    return (0);
  }
  mpts = ndim + 1;
  *iter = 0;
  while (1) {
    *ilo = 0;
    if (y[0] > y[1]) {
      *ihi = 0;
      inhi = 1;
    } else {
      *ihi = 1;
      inhi = 0;
    }
    for (i = 0; i < mpts; i++) {
      if (y[i] < y[*ilo]) {
        *ilo = i;
      }
      if (y[i] > y[*ihi]) {
        inhi = *ihi;
        *ihi = i;
      } else if (y[i] > y[inhi]) {
        if (i != *ihi) {
          inhi = i;
        }
      }
    }
    if (fabs(y[*ihi] - y[*ilo]) * (double)2.0 <=
        ftol * (fabs(y[*ihi]) + fabs(y[*ilo]))) {
      free(pbar);
      free(prr);
      return (1);
    }
    if (y[*ilo] < atol) {
      free(pbar);
      free(prr);
      return (2);
    }
    if (*iter == itmax) {
      free(pbar);
      free(prr);
      return (3);
    }
    ++(*iter);
    for (j = 0; j < ndim; j++) {
      *(pbar + j) = (double)0.0;
    }
    for (i = 0; i < mpts; i++) {
      if (i != *ihi) {
        for (j = 0; j < ndim; j++) {
          *(pbar + j) += p[i * ndim + j];
        }
      }
    }
    for (j = 0; j < ndim; j++) {
      pbar[j] /= (double)ndim;
      pr[lista[j]] =
          *(pbar + j) * ((double)1.0 + alpha) - alpha * p[*ihi * ndim + j];
    }
    for (j = 0; j < na; j++) {
      *(prr + j) = pr[j];
    }
    ypr = (*funk)(pr);
    if (ypr < y[*ilo]) {
      for (j = 0; j < ndim; j++) {
        *(prr + lista[j]) =
            pr[lista[j]] * gamma + *(pbar + j) * ((double)1.0 - gamma);
      }
      yprr = (*funk)(prr);
      if (yprr < y[*ilo]) {
        for (j = 0; j < ndim; j++) {
          p[*ihi * ndim + j] = *(prr + lista[j]);
        }
        y[*ihi] = yprr;
      } else {
        for (j = 0; j < ndim; j++) {
          p[*ihi * ndim + j] = pr[lista[j]];
        }
        y[*ihi] = ypr;
      }
    } else if (ypr >= y[inhi]) {
      if (ypr < y[*ihi]) {
        for (j = 0; j < ndim; j++) {
          p[*ihi * ndim + j] = pr[lista[j]];
        }
        y[*ihi] = ypr;
      }
      for (j = 0; j < ndim; j++) {
        *(prr + lista[j]) =
            p[*ihi * ndim + j] * beta + *(pbar + j) * ((double)1.0 - beta);
      }
      yprr = (*funk)(prr);
      if (yprr < y[*ihi]) {
        for (j = 0; j < ndim; j++) {
          p[*ihi * ndim + j] = *(prr + lista[j]);
        }
        y[*ihi] = yprr;
      } else {
        for (i = 0; i < mpts; i++) {
          if (i != *ilo) {
            for (j = 0; j < ndim; j++) {
              pr[lista[j]] =
                  (p[i * ndim + j] + p[*ilo * ndim + j]) * (double)0.5;
              p[i * ndim + j] = pr[lista[j]];
            }
            y[i] = (*funk)(pr);
          }
        }
      }
    } else {
      for (j = 0; j < ndim; j++) {
        p[*ihi * ndim + j] = pr[lista[j]];
      }
      y[*ihi] = ypr;
    }
  }
}


x86 assembly (clang, -O0):
<simplx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
je     11a5 <simplx+0x75>
movslq -0x2c(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    11bf <simplx+0x8f>
lea    0xe7c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a61 <simplx+0x931>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    1209 <simplx+0xd9>
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x6c(%rbp)
jmp    121a <simplx+0xea>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    12e9 <simplx+0x1b9>
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    125d <simplx+0x12d>
mov    -0x74(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1297 <simplx+0x167>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x74(%rbp),%ecx
mov    0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    12d6 <simplx+0x1a6>
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    12d1 <simplx+0x1a1>
mov    -0x74(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
je     12cc <simplx+0x19c>
mov    -0x74(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    12d1 <simplx+0x1a1>
jmp    12d6 <simplx+0x1a6>
jmp    12db <simplx+0x1ab>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1221 <simplx+0xf1>
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0xcf0(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xcf4(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0xcc4(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm3
movaps 0xca9(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     138b <simplx+0x25b>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    1a61 <simplx+0x931>
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    13c8 <simplx+0x298>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x4(%rbp)
jmp    1a61 <simplx+0x931>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
cmp    0x18(%rbp),%eax
jne    13f5 <simplx+0x2c5>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x3,-0x4(%rbp)
jmp    1a61 <simplx+0x931>
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1431 <simplx+0x301>
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1407 <simplx+0x2d7>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    14b4 <simplx+0x384>
mov    -0x74(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
je     14a1 <simplx+0x371>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    149c <simplx+0x36c>
mov    -0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    145a <simplx+0x32a>
jmp    14a1 <simplx+0x371>
jmp    14a6 <simplx+0x376>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1438 <simplx+0x308>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1562 <simplx+0x432>
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb29(%rip),%xmm2
addsd  0x2b39(%rip),%xmm2
movsd  0x2b31(%rip),%xmm1
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14bb <simplx+0x38b>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    159d <simplx+0x46d>
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1569 <simplx+0x439>
mov    0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    174b <simplx+0x61b>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1649 <simplx+0x519>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x2a4b(%rip),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xa0e(%rip),%xmm3
subsd  0x2a2e(%rip),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    15d4 <simplx+0x4a4>
mov    0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16e2 <simplx+0x5b2>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16c8 <simplx+0x598>
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1680 <simplx+0x550>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1746 <simplx+0x616>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1731 <simplx+0x601>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16e9 <simplx+0x5b9>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a5c <simplx+0x92c>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     19f3 <simplx+0x8c3>
movsd  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    17e6 <simplx+0x6b6>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17d1 <simplx+0x6a1>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1789 <simplx+0x659>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1866 <simplx+0x736>
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x2826(%rip),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x7f1(%rip),%xmm3
subsd  0x2809(%rip),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    17ed <simplx+0x6bd>
mov    0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18ff <simplx+0x7cf>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18e5 <simplx+0x7b5>
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    189d <simplx+0x76d>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19ee <simplx+0x8be>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    19e9 <simplx+0x8b9>
mov    -0x74(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
je     19d6 <simplx+0x8a6>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19bd <simplx+0x88d>
mov    -0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x6ad(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1928 <simplx+0x7f8>
mov    0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19db <simplx+0x8ab>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1906 <simplx+0x7d6>
jmp    19ee <simplx+0x8be>
jmp    1a57 <simplx+0x927>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a42 <simplx+0x912>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    19fa <simplx+0x8ca>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a5c <simplx+0x92c>
jmp    11d2 <simplx+0xa2>
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r13
movsd  %xmm1,0xb8(%rsp)
movsd  %xmm0,0xc0(%rsp)
mov    %rcx,0x10(%rsp)
mov    %edx,%ebx
mov    %rsi,0x40(%rsp)
mov    %rdi,0x18(%rsp)
mov    %r8d,0x4c(%rsp)
movslq %r8d,%r12
shl    $0x3,%r12
mov    %r12,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     1e13 <simplx+0xcc3>
mov    %rax,%r14
mov    %r12,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     1e13 <simplx+0xcc3>
mov    %rax,%r12
mov    0x130(%rsp),%r10
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rax
movl   $0x0,(%rax)
cvtsi2sd %ebx,%xmm4
lea    0x1(%rbx),%eax
mov    %ebx,%r15d
lea    0x0(,%r15,8),%rcx
mov    %rcx,0xa0(%rsp)
mov    0x4c(%rsp),%ecx
shl    $0x3,%rcx
mov    %rcx,0x98(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x80(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xb0(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0xd0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xc8(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x60(%rsp)
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x70(%rsp)
mov    %rbx,0x8(%rsp)
movslq %ebx,%rcx
lea    -0x1(%r15),%rdx
mov    %rdx,0x20(%rsp)
mov    %rax,0x78(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0xa8(%rsp)
mov    0x18(%rsp),%rax
lea    0x30(%rax),%rdx
mov    %rdx,0x90(%rsp)
mov    %rcx,0x58(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x88(%rsp)
lea    0x18(%rax),%rcx
mov    %rcx,0x38(%rsp)
add    $0x8,%rax
mov    %rax,0x68(%rsp)
mov    0x10(%rsp),%r8
mov    0x40(%rsp),%r9
movsd  %xmm4,0x28(%rsp)
mov    %r12,0x30(%rsp)
jmp    12db <simplx+0x18b>
cs nopw 0x0(%rax,%rax,1)
mov    0x50(%rsp),%rax
movsd  %xmm1,(%r9,%rax,8)
movl   $0x0,(%r11)
movsd  (%r9),%xmm0
xor    %r12d,%r12d
xor    %ecx,%ecx
ucomisd 0x8(%r9),%xmm0
seta   %r12b
setbe  %cl
mov    %ecx,(%r10)
mov    0x8(%rsp),%rbx
test   %ebx,%ebx
js     1383 <simplx+0x233>
xor    %eax,%eax
mov    0xa8(%rsp),%rdi
nop
movslq (%r11),%rdx
movsd  (%r9,%rdx,8),%xmm1
ucomisd %xmm0,%xmm1
mov    %ecx,%edx
jbe    1327 <simplx+0x1d7>
mov    %eax,(%r11)
mov    (%r10),%edx
movslq %edx,%rcx
ucomisd (%r9,%rcx,8),%xmm0
jbe    1340 <simplx+0x1f0>
mov    %eax,(%r10)
mov    %eax,%ecx
cmp    %rax,%rdi
jne    1362 <simplx+0x212>
jmp    1380 <simplx+0x230>
xchg   %ax,%ax
movslq %r12d,%rsi
mov    %edx,%ecx
cmp    %rcx,%rax
mov    %esi,%ecx
cmovne %eax,%ecx
ucomisd (%r9,%rsi,8),%xmm0
jbe    1358 <simplx+0x208>
mov    %ecx,%r12d
mov    %edx,%ecx
mov    %r12d,%edx
cmp    %rax,%rdi
je     1380 <simplx+0x230>
movsd  0x8(%r9,%rax,8),%xmm0
add    $0x1,%rax
mov    %edx,%r12d
jmp    1310 <simplx+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%r12d
movslq %ecx,%rax
movsd  (%r9,%rax,8),%xmm1
movslq (%r11),%rax
movsd  (%r9,%rax,8),%xmm0
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
movapd 0xc5b(%rip),%xmm5
andpd  %xmm5,%xmm2
addsd  %xmm2,%xmm2
andpd  %xmm5,%xmm1
movapd %xmm0,%xmm3
andpd  %xmm5,%xmm3
addsd  %xmm1,%xmm3
mulsd  0xc0(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jae    1e33 <simplx+0xce3>
movsd  0xb8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     1e4c <simplx+0xcfc>
mov    0x120(%rsp),%rcx
mov    (%rcx),%eax
cmp    0x118(%rsp),%eax
je     1e65 <simplx+0xd15>
add    $0x1,%eax
mov    %eax,(%rcx)
test   %ebx,%ebx
jle    1428 <simplx+0x2d8>
mov    %r14,%rdi
xor    %esi,%esi
mov    0xa0(%rsp),%rdx
call   1050 <memset@plt>
movsd  0x28(%rsp),%xmm4
mov    0x130(%rsp),%r10
mov    0x10(%rsp),%r8
test   %ebx,%ebx
mov    0x18(%rsp),%r9
mov    0x78(%rsp),%rbx
mov    0xb0(%rsp),%r11
mov    0x60(%rsp),%rbp
js     15d0 <simplx+0x480>
mov    (%r10),%eax
mov    %r9,%rcx
mov    0x90(%rsp),%rdx
xor    %esi,%esi
jmp    147b <simplx+0x32b>
nopl   0x0(%rax)
add    $0x1,%rsi
mov    0x88(%rsp),%rdi
add    %rdi,%rdx
add    %rdi,%rcx
cmp    %rbx,%rsi
je     15d0 <simplx+0x480>
cmp    %rax,%rsi
je     1460 <simplx+0x310>
cmpl   $0x0,0x8(%rsp)
jle    1460 <simplx+0x310>
cmpl   $0x4,0x8(%rsp)
jae    14a0 <simplx+0x350>
xor    %edi,%edi
jmp    1590 <simplx+0x440>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r11,%r11
je     15af <simplx+0x45f>
mov    0xc8(%rsp),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd (%r14,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%r14,%rdi,8),%xmm1
movupd 0x30(%r14,%rdi,8),%xmm3
movupd %xmm2,(%r14,%rdi,8)
movupd %xmm0,0x10(%r14,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%rdi,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rdi,8)
movupd %xmm1,0x30(%r14,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14c0 <simplx+0x370>
testb  $0x1,0xd0(%rsp)
01
je     156c <simplx+0x41c>
mov    %rsi,%rbp
imul   0x58(%rsp),%rbp
add    %rdi,%rbp
movupd (%r9,%rbp,8),%xmm0
movupd 0x10(%r9,%rbp,8),%xmm1
movupd (%r14,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdi,8)
movupd %xmm0,0x10(%r14,%rdi,8)
mov    0x80(%rsp),%rbp
mov    %rbp,%rdi
cmp    %r15,%rbp
mov    0x60(%rsp),%rbp
je     1460 <simplx+0x310>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdi,8),%xmm0
addsd  (%r14,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r15
jne    1590 <simplx+0x440>
jmp    1460 <simplx+0x310>
xor    %edi,%edi
testb  $0x1,0xd0(%rsp)
01
jne    1531 <simplx+0x3e1>
jmp    156c <simplx+0x41c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0x8(%rsp)
jle    161d <simplx+0x4cd>
movslq (%r10),%rax
imul   0x58(%rsp),%rax
lea    (%r9,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
addsd  %xmm0,%xmm0
subsd  (%rax,%rcx,8),%xmm0
movslq 0x0(%r13,%rcx,4),%rdx
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    15f0 <simplx+0x4a0>
cmpl   $0x0,0x4c(%rsp)
mov    0x80(%rsp),%rbx
jle    1646 <simplx+0x4f6>
mov    0x30(%rsp),%rdi
mov    %r8,%rsi
mov    0x98(%rsp),%rdx
call   1060 <memcpy@plt>
mov    0x10(%rsp),%r8
mov    %r8,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
movapd %xmm0,%xmm1
mov    0x128(%rsp),%r11
movslq (%r11),%rax
mov    0x40(%rsp),%r9
movsd  (%r9,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1780 <simplx+0x630>
cmpl   $0x0,0x8(%rsp)
mov    0x30(%rsp),%r12
jle    1703 <simplx+0x5b3>
cmpq   $0x0,0x20(%rsp)
je     186b <simplx+0x71b>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
mov    0x70(%rsp),%rsi
xchg   %ax,%ax
movslq 0x0(%r13,%rax,4),%rcx
movsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movslq 0x4(%r13,%rax,4),%rcx
movsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    16a0 <simplx+0x550>
test   $0x1,%r15b
je     1703 <simplx+0x5b3>
movslq 0x0(%r13,%rax,4),%rcx
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  %xmm1,0x50(%rsp)
mov    %r12,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x128(%rsp),%r11
movslq (%r11),%rax
mov    0x40(%rsp),%r9
movsd  (%r9,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
mov    0x130(%rsp),%r10
movslq (%r10),%rax
jbe    17e0 <simplx+0x690>
mov    0x8(%rsp),%rdx
test   %edx,%edx
mov    0x10(%rsp),%r8
movsd  0x28(%rsp),%xmm4
jle    1918 <simplx+0x7c8>
mov    %eax,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x20(%rsp)
jae    187c <simplx+0x72c>
xor    %edx,%edx
jmp    18dc <simplx+0x78c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r12d,%rax
ucomisd (%r9,%rax,8),%xmm1
mov    0x130(%rsp),%r10
movslq (%r10),%r8
jae    1820 <simplx+0x6d0>
mov    %r8,0x50(%rsp)
mov    0x8(%rsp),%rax
test   %eax,%eax
mov    0x10(%rsp),%r8
movsd  0x28(%rsp),%xmm4
jle    12d0 <simplx+0x180>
mov    0x50(%rsp),%rcx
imul   %eax,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x20(%rsp)
jae    1923 <simplx+0x7d3>
xor    %edx,%edx
jmp    197c <simplx+0x82c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rdx
test   %edx,%edx
mov    0x10(%rsp),%r8
movsd  0x28(%rsp),%xmm4
movsd  0x50(%rsp),%xmm1
jle    1a58 <simplx+0x908>
mov    %eax,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x20(%rsp)
jae    19bd <simplx+0x86d>
xor    %edx,%edx
jmp    1a1c <simplx+0x8cc>
nopl   0x0(%rax)
movsd  (%r9,%r8,8),%xmm0
ucomisd %xmm1,%xmm0
mov    0x10(%rsp),%rbp
mov    0x30(%rsp),%r12
movsd  0x7d4(%rip),%xmm2
jbe    1afe <simplx+0x9ae>
cmpl   $0x0,0x8(%rsp)
jle    1af8 <simplx+0x9a8>
mov    %r8d,%ecx
imul   0x8(%rsp),%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x20(%rsp)
jae    1a63 <simplx+0x913>
xor    %edx,%edx
jmp    1abc <simplx+0x96c>
xor    %eax,%eax
test   $0x1,%r15b
jne    16e4 <simplx+0x594>
jmp    1703 <simplx+0x5b3>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq 0x0(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x18(%rsi,%rdx,8)
movslq 0x4(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x10(%rsi,%rdx,8)
movslq 0x8(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
movslq 0xc(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1890 <simplx+0x740>
test   $0x3,%r15b
je     1918 <simplx+0x7c8>
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1900 <simplx+0x7b0>
movsd  %xmm0,(%r9,%rax,8)
jmp    12db <simplx+0x18b>
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
xor    %edx,%edx
xchg   %ax,%ax
movslq 0x0(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x18(%rsi,%rdx,8)
movslq 0x4(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%rdx,8)
movslq 0x8(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movslq 0xc(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1930 <simplx+0x7e0>
test   $0x3,%r15b
je     12d0 <simplx+0x180>
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nop
movslq (%rdx,%rsi,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    19a0 <simplx+0x850>
jmp    12d0 <simplx+0x180>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq 0x0(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x18(%rsi,%rdx,8)
movslq 0x4(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%rdx,8)
movslq 0x8(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movslq 0xc(%r13,%rdx,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    19d0 <simplx+0x880>
test   $0x3,%r15b
je     1a58 <simplx+0x908>
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1a40 <simplx+0x8f0>
movsd  %xmm1,(%r9,%rax,8)
jmp    12db <simplx+0x18b>
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
xor    %edx,%edx
xchg   %ax,%ax
movslq 0x0(%r13,%rdx,4),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,-0x18(%rsi,%rdx,8)
movslq 0x4(%r13,%rdx,4),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%rdx,8)
movslq 0x8(%r13,%rdx,4),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movslq 0xc(%r13,%rdx,4),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1a70 <simplx+0x920>
mov    0x60(%rsp),%rax
test   %rax,%rax
je     1af8 <simplx+0x9a8>
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nop
movslq (%rdx,%rsi,4),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1ae0 <simplx+0x990>
movsd  %xmm1,(%r9,%r8,8)
mov    0x8(%rsp),%rbp
test   %ebp,%ebp
jle    1baf <simplx+0xa5f>
imul   %ebp,%r8d
movslq %r8d,%rax
cmpq   $0x0,0x20(%rsp)
je     1d5d <simplx+0xc0d>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
xor    %ecx,%ecx
mov    0x70(%rsp),%rdi
xchg   %ax,%ax
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  -0x8(%rdx,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq 0x0(%r13,%rcx,4),%rsi
movsd  %xmm1,(%r12,%rsi,8)
movsd  0x8(%r14,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq 0x4(%r13,%rcx,4),%rsi
movsd  %xmm1,(%r12,%rsi,8)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    1b30 <simplx+0x9e0>
test   $0x1,%r15b
je     1baf <simplx+0xa5f>
add    %rcx,%rax
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
mov    0x18(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq 0x0(%r13,%rcx,4),%rax
movsd  %xmm1,(%r12,%rax,8)
mov    %r12,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x130(%rsp),%r10
movslq (%r10),%rax
mov    0x40(%rsp),%r9
movsd  (%r9,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1c13 <simplx+0xac3>
test   %ebp,%ebp
mov    0x10(%rsp),%r8
mov    0x128(%rsp),%r11
movsd  0x28(%rsp),%xmm4
mov    0x60(%rsp),%rbp
jle    1e08 <simplx+0xcb8>
mov    %rax,%rcx
imul   0x58(%rsp),%rcx
cmpq   $0x3,0x20(%rsp)
jae    1d6e <simplx+0xc1e>
xor    %edx,%edx
jmp    1dcc <simplx+0xc7c>
test   %ebp,%ebp
mov    0x10(%rsp),%r8
mov    0x128(%rsp),%r11
movsd  0x28(%rsp),%xmm4
js     12db <simplx+0x18b>
mov    0x68(%rsp),%rbp
xor    %ebx,%ebx
jmp    1c89 <simplx+0xb39>
nopw   0x0(%rax,%rax,1)
mov    %r8,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x10(%rsp),%r8
mov    0x40(%rsp),%r9
movsd  %xmm0,(%r9,%rbx,8)
mov    0x130(%rsp),%r10
mov    0x128(%rsp),%r11
movsd  0x28(%rsp),%xmm4
add    $0x1,%rbx
add    0x88(%rsp),%rbp
cmp    0x78(%rsp),%rbx
je     12db <simplx+0x18b>
mov    (%r11),%eax
cmp    %rax,%rbx
je     1c72 <simplx+0xb22>
cmpl   $0x0,0x8(%rsp)
mov    0x70(%rsp),%rdi
jle    1c40 <simplx+0xaf0>
imul   0x8(%rsp),%eax
cltq
cmpq   $0x0,0x20(%rsp)
je     1d16 <simplx+0xbc6>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
xor    %ecx,%ecx
movsd  0x351(%rip),%xmm1
nop
movsd  -0x8(%rbp,%rcx,8),%xmm0
addsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movslq 0x0(%r13,%rcx,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
movsd  %xmm0,-0x8(%rbp,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
addsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movslq 0x4(%r13,%rcx,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    1cc0 <simplx+0xb70>
test   $0x1,%r15b
je     1c40 <simplx+0xaf0>
jmp    1d22 <simplx+0xbd2>
xor    %ecx,%ecx
test   $0x1,%r15b
je     1c40 <simplx+0xaf0>
mov    %rbx,%rdx
imul   0x58(%rsp),%rdx
add    %rcx,%rdx
mov    0x18(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
add    %rcx,%rax
addsd  (%rsi,%rax,8),%xmm0
mulsd  0x2c8(%rip),%xmm0
movslq 0x0(%r13,%rcx,4),%rax
movsd  %xmm0,(%r8,%rax,8)
movsd  %xmm0,(%rsi,%rdx,8)
jmp    1c40 <simplx+0xaf0>
xor    %ecx,%ecx
test   $0x1,%r15b
jne    1b85 <simplx+0xa35>
jmp    1baf <simplx+0xa5f>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movslq 0x0(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x18(%rsi,%rdx,8)
movslq 0x4(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x10(%rsi,%rdx,8)
movslq 0x8(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
movslq 0xc(%r13,%rdx,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1d80 <simplx+0xc30>
test   $0x3,%r15b
je     1e08 <simplx+0xcb8>
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1df0 <simplx+0xca0>
movsd  %xmm0,(%r9,%rax,8)
jmp    12db <simplx+0x18b>
lea    0x1fe(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
jmp    1e21 <simplx+0xcd1>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0x2,%eax
jmp    1e21 <simplx+0xcd1>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0x3,%eax
jmp    1e21 <simplx+0xcd1>

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

LLVM IR (-O2):
@str = [34 x i8] c"SIMPLX: Error - not enough memory\00"
define i32 @simplx(double* nocapture %0, double* nocapture %1, i32 %2, double* %3, i32 %4, double %5, double %6, i32* nocapture %7, double (...)* nocapture %8, i32 %9, i32* nocapture %10, i32* nocapture %11, i32* nocapture %12) {
%14 = bitcast double* %3 to i8*
%15 = sext i32 %4 to i64
%16 = shl nsw i64 %15, 3
%17 = tail call i8* @malloc(i64 %16)
%18 = bitcast i8* %17 to double*
%19 = icmp eq i8* %17, null
br i1 %19, label %24, label %20
20: ; preds = %13
%21 = tail call i8* @malloc(i64 %16)
%22 = bitcast i8* %21 to double*
%23 = icmp eq i8* %21, null
br i1 %23, label %24, label %26
24: ; preds = %20, %13
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str, i64 0, i64 0))
br label %750
26: ; preds = %20
store i32 0, i32* %10
%27 = getelementptr inbounds double, double* %1, i64 1
%28 = icmp slt i32 %2, 0
%29 = icmp sgt i32 %2, 0
%30 = icmp slt i32 %2, 1
%31 = sitofp i32 %2 to double
%32 = icmp sgt i32 %4, 0
%33 = bitcast double (...)* %8 to double (double*, ...)*
%34 = add i32 %2, 1
%35 = zext i32 %2 to i64
%36 = shl nuw nsw i64 %35, 3
%37 = sext i32 %2 to i64
%38 = zext i32 %4 to i64
%39 = shl nuw nsw i64 %38, 3
%40 = zext i32 %34 to i64
%41 = zext i32 %34 to i64
%42 = zext i32 %34 to i64
%43 = and i64 %35, 4294967292
%44 = add nsw i64 %43, -4
%45 = lshr exact i64 %44, 2
%46 = add nuw nsw i64 %45, 1
%47 = add nsw i64 %35, -1
%48 = icmp ult i32 %2, 4
%49 = and i64 %35, 4294967292
%50 = and i64 %46, 1
%51 = icmp eq i64 %44, 0
%52 = and i64 %46, 9223372036854775806
%53 = icmp eq i64 %50, 0
%54 = icmp eq i64 %49, %35
%55 = and i64 %35, 3
%56 = icmp ult i64 %47, 3
%57 = and i64 %35, 4294967292
%58 = icmp eq i64 %55, 0
%59 = and i64 %35, 1
%60 = icmp eq i64 %47, 0
%61 = and i64 %35, 4294967294
%62 = icmp eq i64 %59, 0
%63 = and i64 %35, 1
%64 = icmp eq i64 %47, 0
%65 = and i64 %35, 4294967294
%66 = icmp eq i64 %63, 0
%67 = and i64 %35, 3
%68 = icmp ult i64 %47, 3
%69 = and i64 %35, 4294967292
%70 = icmp eq i64 %67, 0
%71 = and i64 %35, 3
%72 = icmp ult i64 %47, 3
%73 = and i64 %35, 4294967292
%74 = icmp eq i64 %71, 0
%75 = and i64 %35, 1
%76 = icmp eq i64 %47, 0
%77 = and i64 %35, 4294967294
%78 = icmp eq i64 %75, 0
%79 = and i64 %35, 3
%80 = icmp ult i64 %47, 3
%81 = and i64 %35, 4294967292
%82 = icmp eq i64 %79, 0
%83 = and i64 %35, 3
%84 = icmp ult i64 %47, 3
%85 = and i64 %35, 4294967292
%86 = icmp eq i64 %83, 0
br label %87
87: ; preds = %575, %26
store i32 0, i32* %11
%88 = load double, double* %1
%89 = load double, double* %27
%90 = fcmp ogt double %88, %89
%91 = xor i1 %90, true
%92 = zext i1 %91 to i32
%93 = zext i1 %90 to i32
store i32 %92, i32* %12
br i1 %28, label %133, label %94
94: ; preds = %87, %130
%95 = phi i32 [ %126, %130 ], [ %92, %87 ]
%96 = phi double [ %132, %130 ], [ %88, %87 ]
%97 = phi i64 [ %128, %130 ], [ 0, %87 ]
%98 = phi i32 [ %127, %130 ], [ %93, %87 ]
%99 = load i32, i32* %11
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %1, i64 %100
%102 = load double, double* %101
%103 = fcmp olt double %96, %102
br i1 %103, label %104, label %107
104: ; preds = %94
%105 = trunc i64 %97 to i32
store i32 %105, i32* %11
%106 = load i32, i32* %12
br label %107
107: ; preds = %104, %94
%108 = phi i32 [ %106, %104 ], [ %95, %94 ]
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %1, i64 %109
%111 = load double, double* %110
%112 = fcmp ogt double %96, %111
br i1 %112, label %113, label %115
113: ; preds = %107
%114 = trunc i64 %97 to i32
store i32 %114, i32* %12
br label %125
115: ; preds = %107
%116 = sext i32 %98 to i64
%117 = getelementptr inbounds double, double* %1, i64 %116
%118 = load double, double* %117
%119 = fcmp ule double %96, %118
%120 = zext i32 %108 to i64
%121 = icmp eq i64 %97, %120
%122 = select i1 %119, i1 true, i1 %121
%123 = trunc i64 %97 to i32
%124 = select i1 %122, i32 %98, i32 %123
br label %125
125: ; preds = %115, %113
%126 = phi i32 [ %114, %113 ], [ %108, %115 ]
%127 = phi i32 [ %108, %113 ], [ %124, %115 ]
%128 = add nuw nsw i64 %97, 1
%129 = icmp eq i64 %128, %40
br i1 %129, label %133, label %130
130: ; preds = %125
%131 = getelementptr inbounds double, double* %1, i64 %128
%132 = load double, double* %131
br label %94
133: ; preds = %125, %87
%134 = phi i32 [ %92, %87 ], [ %126, %125 ]
%135 = phi i32 [ %93, %87 ], [ %127, %125 ]
%136 = sext i32 %134 to i64
%137 = getelementptr inbounds double, double* %1, i64 %136
%138 = load double, double* %137
%139 = load i32, i32* %11
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %1, i64 %140
%142 = load double, double* %141
%143 = fsub double %138, %142
%144 = tail call double @llvm.fabs.f64(double %143)
%145 = fmul double %144, 2.000000e+00
%146 = tail call double @llvm.fabs.f64(double %138)
%147 = tail call double @llvm.fabs.f64(double %142)
%148 = fadd double %146, %147
%149 = fmul double %148, %5
%150 = fcmp ugt double %145, %149
br i1 %150, label %152, label %151
151: ; preds = %133
tail call void @free(i8* %17)
tail call void @free(i8* %21)
br label %750
152: ; preds = %133
%153 = fcmp olt double %142, %6
br i1 %153, label %154, label %155
154: ; preds = %152
tail call void @free(i8* %17)
tail call void @free(i8* %21)
br label %750
155: ; preds = %152
%156 = load i32, i32* %10
%157 = icmp eq i32 %156, %9
br i1 %157, label %158, label %159
158: ; preds = %155
tail call void @free(i8* %17)
tail call void @free(i8* %21)
br label %750
159: ; preds = %155
%160 = add nsw i32 %156, 1
store i32 %160, i32* %10
br i1 %29, label %161, label %162
161: ; preds = %159
br label %162
162: ; preds = %161, %159
br i1 %28, label %166, label %163
163: ; preds = %162
%164 = load i32, i32* %12
%165 = zext i32 %164 to i64
br label %171
166: ; preds = %252, %162
br i1 %29, label %167, label %255
167: ; preds = %166
%168 = load i32, i32* %12
%169 = mul nsw i32 %168, %2
%170 = sext i32 %169 to i64
br label %257
171: ; preds = %163, %252
%172 = phi i64 [ 0, %163 ], [ %253, %252 ]
%173 = icmp eq i64 %172, %165
%174 = or i1 %173, %30
br i1 %174, label %252, label %175
175: ; preds = %171
%176 = mul nsw i64 %172, %37
br i1 %48, label %240, label %177
177: ; preds = %175
br i1 %51, label %219, label %178
178: ; preds = %177, %178
%179 = phi i64 [ %216, %178 ], [ 0, %177 ]
%180 = phi i64 [ %217, %178 ], [ 0, %177 ]
%181 = add nsw i64 %179, %176
%182 = getelementptr inbounds double, double* %0, i64 %181
%183 = bitcast double* %182 to <2 x double>*
%184 = load <2 x double>, <2 x double>* %183
%185 = getelementptr inbounds double, double* %182, i64 2
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = getelementptr inbounds double, double* %18, i64 %179
%189 = bitcast double* %188 to <2 x double>*
%190 = load <2 x double>, <2 x double>* %189
%191 = getelementptr inbounds double, double* %188, i64 2
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = fadd <2 x double> %184, %190
%195 = fadd <2 x double> %187, %193
%196 = bitcast double* %188 to <2 x double>*
store <2 x double> %194, <2 x double>* %196
%197 = bitcast double* %191 to <2 x double>*
store <2 x double> %195, <2 x double>* %197
%198 = or i64 %179, 4
%199 = add nsw i64 %198, %176
%200 = getelementptr inbounds double, double* %0, i64 %199
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = getelementptr inbounds double, double* %200, i64 2
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = getelementptr inbounds double, double* %18, i64 %198
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = getelementptr inbounds double, double* %206, i64 2
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = fadd <2 x double> %202, %208
%213 = fadd <2 x double> %205, %211
%214 = bitcast double* %206 to <2 x double>*
store <2 x double> %212, <2 x double>* %214
%215 = bitcast double* %209 to <2 x double>*
store <2 x double> %213, <2 x double>* %215
%216 = add nuw i64 %179, 8
%217 = add i64 %180, 2
%218 = icmp eq i64 %217, %52
br i1 %218, label %219, label %178
219: ; preds = %178, %177
%220 = phi i64 [ 0, %177 ], [ %216, %178 ]
br i1 %53, label %239, label %221
221: ; preds = %219
%222 = add nsw i64 %220, %176
%223 = getelementptr inbounds double, double* %0, i64 %222
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = getelementptr inbounds double, double* %223, i64 2
%227 = bitcast double* %226 to <2 x double>*
%228 = load <2 x double>, <2 x double>* %227
%229 = getelementptr inbounds double, double* %18, i64 %220
%230 = bitcast double* %229 to <2 x double>*
%231 = load <2 x double>, <2 x double>* %230
%232 = getelementptr inbounds double, double* %229, i64 2
%233 = bitcast double* %232 to <2 x double>*
%234 = load <2 x double>, <2 x double>* %233
%235 = fadd <2 x double> %225, %231
%236 = fadd <2 x double> %228, %234
%237 = bitcast double* %229 to <2 x double>*
store <2 x double> %235, <2 x double>* %237
%238 = bitcast double* %232 to <2 x double>*
store <2 x double> %236, <2 x double>* %238
br label %239
239: ; preds = %219, %221
br i1 %54, label %252, label %240
240: ; preds = %175, %239
%241 = phi i64 [ 0, %175 ], [ %49, %239 ]
br label %242
242: ; preds = %240, %242
%243 = phi i64 [ %250, %242 ], [ %241, %240 ]
%244 = add nsw i64 %243, %176
%245 = getelementptr inbounds double, double* %0, i64 %244
%246 = load double, double* %245
%247 = getelementptr inbounds double, double* %18, i64 %243
%248 = load double, double* %247
%249 = fadd double %246, %248
store double %249, double* %247
%250 = add nuw nsw i64 %243, 1
%251 = icmp eq i64 %250, %35
br i1 %251, label %252, label %242
252: ; preds = %242, %239, %171
%253 = add nuw nsw i64 %172, 1
%254 = icmp eq i64 %253, %41
br i1 %254, label %166, label %171
255: ; preds = %257, %166
br i1 %32, label %256, label %273
256: ; preds = %255
br label %273
257: ; preds = %167, %257
%258 = phi i64 [ 0, %167 ], [ %271, %257 ]
%259 = getelementptr inbounds double, double* %18, i64 %258
%260 = load double, double* %259
%261 = fdiv double %260, %31
store double %261, double* %259
%262 = add nsw i64 %258, %170
%263 = getelementptr inbounds double, double* %0, i64 %262
%264 = load double, double* %263
%265 = fneg double %264
%266 = tail call double @llvm.fmuladd.f64(double %261, double 2.000000e+00, double %265)
%267 = getelementptr inbounds i32, i32* %7, i64 %258
%268 = load i32, i32* %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %3, i64 %269
store double %266, double* %270
%271 = add nuw nsw i64 %258, 1
%272 = icmp eq i64 %271, %35
br i1 %272, label %255, label %257
273: ; preds = %256, %255
%274 = tail call double (double*, ...) %33(double* %3)
%275 = load i32, i32* %11
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %1, i64 %276
%278 = load double, double* %277
%279 = fcmp olt double %274, %278
br i1 %279, label %280, label %448
280: ; preds = %273
br i1 %29, label %281, label %322
281: ; preds = %280
br i1 %76, label %309, label %282
282: ; preds = %281, %282
%283 = phi i64 [ %306, %282 ], [ 0, %281 ]
%284 = phi i64 [ %307, %282 ], [ 0, %281 ]
%285 = getelementptr inbounds i32, i32* %7, i64 %283
%286 = load i32, i32* %285
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double, double* %3, i64 %287
%289 = load double, double* %288
%290 = getelementptr inbounds double, double* %18, i64 %283
%291 = load double, double* %290
%292 = fneg double %291
%293 = tail call double @llvm.fmuladd.f64(double %289, double 2.000000e+00, double %292)
%294 = getelementptr inbounds double, double* %22, i64 %287
store double %293, double* %294
%295 = or i64 %283, 1
%296 = getelementptr inbounds i32, i32* %7, i64 %295
%297 = load i32, i32* %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %3, i64 %298
%300 = load double, double* %299
%301 = getelementptr inbounds double, double* %18, i64 %295
%302 = load double, double* %301
%303 = fneg double %302
%304 = tail call double @llvm.fmuladd.f64(double %300, double 2.000000e+00, double %303)
%305 = getelementptr inbounds double, double* %22, i64 %298
store double %304, double* %305
%306 = add nuw nsw i64 %283, 2
%307 = add i64 %284, 2
%308 = icmp eq i64 %307, %77
br i1 %308, label %309, label %282
309: ; preds = %282, %281
%310 = phi i64 [ 0, %281 ], [ %306, %282 ]
br i1 %78, label %322, label %311
311: ; preds = %309
%312 = getelementptr inbounds i32, i32* %7, i64 %310
%313 = load i32, i32* %312
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %3, i64 %314
%316 = load double, double* %315
%317 = getelementptr inbounds double, double* %18, i64 %310
%318 = load double, double* %317
%319 = fneg double %318
%320 = tail call double @llvm.fmuladd.f64(double %316, double 2.000000e+00, double %319)
%321 = getelementptr inbounds double, double* %22, i64 %314
store double %320, double* %321
br label %322
322: ; preds = %311, %309, %280
%323 = tail call double (double*, ...) %33(double* %22)
%324 = load i32, i32* %11
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %1, i64 %325
%327 = load double, double* %326
%328 = fcmp olt double %323, %327
%329 = load i32, i32* %12
br i1 %328, label %334, label %330
330: ; preds = %322
br i1 %29, label %331, label %445
331: ; preds = %330
%332 = mul nsw i32 %329, %2
%333 = sext i32 %332 to i64
br i1 %80, label %430, label %393
334: ; preds = %322
br i1 %29, label %335, label %390
335: ; preds = %334
%336 = mul nsw i32 %329, %2
%337 = sext i32 %336 to i64
br i1 %84, label %375, label %338
338: ; preds = %335, %338
%339 = phi i64 [ %372, %338 ], [ 0, %335 ]
%340 = phi i64 [ %373, %338 ], [ 0, %335 ]
%341 = getelementptr inbounds i32, i32* %7, i64 %339
%342 = load i32, i32* %341
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %22, i64 %343
%345 = load double, double* %344
%346 = add nsw i64 %339, %337
%347 = getelementptr inbounds double, double* %0, i64 %346
store double %345, double* %347
%348 = or i64 %339, 1
%349 = getelementptr inbounds i32, i32* %7, i64 %348
%350 = load i32, i32* %349
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %22, i64 %351
%353 = load double, double* %352
%354 = add nsw i64 %348, %337
%355 = getelementptr inbounds double, double* %0, i64 %354
store double %353, double* %355
%356 = or i64 %339, 2
%357 = getelementptr inbounds i32, i32* %7, i64 %356
%358 = load i32, i32* %357
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %22, i64 %359
%361 = load double, double* %360
%362 = add nsw i64 %356, %337
%363 = getelementptr inbounds double, double* %0, i64 %362
store double %361, double* %363
%364 = or i64 %339, 3
%365 = getelementptr inbounds i32, i32* %7, i64 %364
%366 = load i32, i32* %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %22, i64 %367
%369 = load double, double* %368
%370 = add nsw i64 %364, %337
%371 = getelementptr inbounds double, double* %0, i64 %370
store double %369, double* %371
%372 = add nuw nsw i64 %339, 4
%373 = add i64 %340, 4
%374 = icmp eq i64 %373, %85
br i1 %374, label %375, label %338
375: ; preds = %338, %335
%376 = phi i64 [ 0, %335 ], [ %372, %338 ]
br i1 %86, label %390, label %377
377: ; preds = %375, %377
%378 = phi i64 [ %387, %377 ], [ %376, %375 ]
%379 = phi i64 [ %388, %377 ], [ 0, %375 ]
%380 = getelementptr inbounds i32, i32* %7, i64 %378
%381 = load i32, i32* %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %22, i64 %382
%384 = load double, double* %383
%385 = add nsw i64 %378, %337
%386 = getelementptr inbounds double, double* %0, i64 %385
store double %384, double* %386
%387 = add nuw nsw i64 %378, 1
%388 = add i64 %379, 1
%389 = icmp eq i64 %388, %83
br i1 %389, label %390, label %377
390: ; preds = %375, %377, %334
%391 = sext i32 %329 to i64
%392 = getelementptr inbounds double, double* %1, i64 %391
store double %323, double* %392
br label %575
393: ; preds = %331, %393
%394 = phi i64 [ %427, %393 ], [ 0, %331 ]
%395 = phi i64 [ %428, %393 ], [ 0, %331 ]
%396 = getelementptr inbounds i32, i32* %7, i64 %394
%397 = load i32, i32* %396
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double, double* %3, i64 %398
%400 = load double, double* %399
%401 = add nsw i64 %394, %333
%402 = getelementptr inbounds double, double* %0, i64 %401
store double %400, double* %402
%403 = or i64 %394, 1
%404 = getelementptr inbounds i32, i32* %7, i64 %403
%405 = load i32, i32* %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %3, i64 %406
%408 = load double, double* %407
%409 = add nsw i64 %403, %333
%410 = getelementptr inbounds double, double* %0, i64 %409
store double %408, double* %410
%411 = or i64 %394, 2
%412 = getelementptr inbounds i32, i32* %7, i64 %411
%413 = load i32, i32* %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %3, i64 %414
%416 = load double, double* %415
%417 = add nsw i64 %411, %333
%418 = getelementptr inbounds double, double* %0, i64 %417
store double %416, double* %418
%419 = or i64 %394, 3
%420 = getelementptr inbounds i32, i32* %7, i64 %419
%421 = load i32, i32* %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %3, i64 %422
%424 = load double, double* %423
%425 = add nsw i64 %419, %333
%426 = getelementptr inbounds double, double* %0, i64 %425
store double %424, double* %426
%427 = add nuw nsw i64 %394, 4
%428 = add i64 %395, 4
%429 = icmp eq i64 %428, %81
br i1 %429, label %430, label %393
430: ; preds = %393, %331
%431 = phi i64 [ 0, %331 ], [ %427, %393 ]
br i1 %82, label %445, label %432
432: ; preds = %430, %432
%433 = phi i64 [ %442, %432 ], [ %431, %430 ]
%434 = phi i64 [ %443, %432 ], [ 0, %430 ]
%435 = getelementptr inbounds i32, i32* %7, i64 %433
%436 = load i32, i32* %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double, double* %3, i64 %437
%439 = load double, double* %438
%440 = add nsw i64 %433, %333
%441 = getelementptr inbounds double, double* %0, i64 %440
store double %439, double* %441
%442 = add nuw nsw i64 %433, 1
%443 = add i64 %434, 1
%444 = icmp eq i64 %443, %79
br i1 %444, label %445, label %432
445: ; preds = %430, %432, %330
%446 = sext i32 %329 to i64
%447 = getelementptr inbounds double, double* %1, i64 %446
store double %274, double* %447
br label %575
448: ; preds = %273
%449 = sext i32 %135 to i64
%450 = getelementptr inbounds double, double* %1, i64 %449
%451 = load double, double* %450
%452 = fcmp ult double %274, %451
%453 = load i32, i32* %12
br i1 %452, label %454, label %458
454: ; preds = %448
br i1 %29, label %455, label %747
455: ; preds = %454
%456 = mul nsw i32 %453, %2
%457 = sext i32 %456 to i64
br i1 %72, label %732, label %695
458: ; preds = %448
%459 = sext i32 %453 to i64
%460 = getelementptr inbounds double, double* %1, i64 %459
%461 = load double, double* %460
%462 = fcmp olt double %274, %461
br i1 %462, label %463, label %520
463: ; preds = %458
br i1 %29, label %464, label %519
464: ; preds = %463
%465 = mul nsw i32 %453, %2
%466 = sext i32 %465 to i64
br i1 %56, label %504, label %467
467: ; preds = %464, %467
%468 = phi i64 [ %501, %467 ], [ 0, %464 ]
%469 = phi i64 [ %502, %467 ], [ 0, %464 ]
%470 = getelementptr inbounds i32, i32* %7, i64 %468
%471 = load i32, i32* %470
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %3, i64 %472
%474 = load double, double* %473
%475 = add nsw i64 %468, %466
%476 = getelementptr inbounds double, double* %0, i64 %475
store double %474, double* %476
%477 = or i64 %468, 1
%478 = getelementptr inbounds i32, i32* %7, i64 %477
%479 = load i32, i32* %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %3, i64 %480
%482 = load double, double* %481
%483 = add nsw i64 %477, %466
%484 = getelementptr inbounds double, double* %0, i64 %483
store double %482, double* %484
%485 = or i64 %468, 2
%486 = getelementptr inbounds i32, i32* %7, i64 %485
%487 = load i32, i32* %486
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double, double* %3, i64 %488
%490 = load double, double* %489
%491 = add nsw i64 %485, %466
%492 = getelementptr inbounds double, double* %0, i64 %491
store double %490, double* %492
%493 = or i64 %468, 3
%494 = getelementptr inbounds i32, i32* %7, i64 %493
%495 = load i32, i32* %494
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %3, i64 %496
%498 = load double, double* %497
%499 = add nsw i64 %493, %466
%500 = getelementptr inbounds double, double* %0, i64 %499
store double %498, double* %500
%501 = add nuw nsw i64 %468, 4
%502 = add i64 %469, 4
%503 = icmp eq i64 %502, %57
br i1 %503, label %504, label %467
504: ; preds = %467, %464
%505 = phi i64 [ 0, %464 ], [ %501, %467 ]
br i1 %58, label %519, label %506
506: ; preds = %504, %506
%507 = phi i64 [ %516, %506 ], [ %505, %504 ]
%508 = phi i64 [ %517, %506 ], [ 0, %504 ]
%509 = getelementptr inbounds i32, i32* %7, i64 %507
%510 = load i32, i32* %509
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %3, i64 %511
%513 = load double, double* %512
%514 = add nsw i64 %507, %466
%515 = getelementptr inbounds double, double* %0, i64 %514
store double %513, double* %515
%516 = add nuw nsw i64 %507, 1
%517 = add i64 %508, 1
%518 = icmp eq i64 %517, %55
br i1 %518, label %519, label %506
519: ; preds = %504, %506, %463
store double %274, double* %460
br label %520
520: ; preds = %519, %458
br i1 %29, label %521, label %567
521: ; preds = %520
%522 = mul nsw i32 %453, %2
%523 = sext i32 %522 to i64
br i1 %60, label %553, label %524
524: ; preds = %521, %524
%525 = phi i64 [ %550, %524 ], [ 0, %521 ]
%526 = phi i64 [ %551, %524 ], [ 0, %521 ]
%527 = add nsw i64 %525, %523
%528 = getelementptr inbounds double, double* %0, i64 %527
%529 = load double, double* %528
%530 = getelementptr inbounds double, double* %18, i64 %525
%531 = load double, double* %530
%532 = fmul double %531, 5.000000e-01
%533 = tail call double @llvm.fmuladd.f64(double %529, double 5.000000e-01, double %532)
%534 = getelementptr inbounds i32, i32* %7, i64 %525
%535 = load i32, i32* %534
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double, double* %22, i64 %536
store double %533, double* %537
%538 = or i64 %525, 1
%539 = add nsw i64 %538, %523
%540 = getelementptr inbounds double, double* %0, i64 %539
%541 = load double, double* %540
%542 = getelementptr inbounds double, double* %18, i64 %538
%543 = load double, double* %542
%544 = fmul double %543, 5.000000e-01
%545 = tail call double @llvm.fmuladd.f64(double %541, double 5.000000e-01, double %544)
%546 = getelementptr inbounds i32, i32* %7, i64 %538
%547 = load i32, i32* %546
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double, double* %22, i64 %548
store double %545, double* %549
%550 = add nuw nsw i64 %525, 2
%551 = add i64 %526, 2
%552 = icmp eq i64 %551, %61
br i1 %552, label %553, label %524
553: ; preds = %524, %521
%554 = phi i64 [ 0, %521 ], [ %550, %524 ]
br i1 %62, label %567, label %555
555: ; preds = %553
%556 = add nsw i64 %554, %523
%557 = getelementptr inbounds double, double* %0, i64 %556
%558 = load double, double* %557
%559 = getelementptr inbounds double, double* %18, i64 %554
%560 = load double, double* %559
%561 = fmul double %560, 5.000000e-01
%562 = tail call double @llvm.fmuladd.f64(double %558, double 5.000000e-01, double %561)
%563 = getelementptr inbounds i32, i32* %7, i64 %554
%564 = load i32, i32* %563
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %22, i64 %565
store double %562, double* %566
br label %567
567: ; preds = %555, %553, %520
%568 = tail call double (double*, ...) %33(double* %22)
%569 = load i32, i32* %12
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds double, double* %1, i64 %570
%572 = load double, double* %571
%573 = fcmp olt double %568, %572
br i1 %573, label %576, label %574
574: ; preds = %567
br i1 %28, label %575, label %633
575: ; preds = %692, %574, %747, %632, %390, %445
br label %87
576: ; preds = %567
br i1 %29, label %577, label %632
577: ; preds = %576
%578 = mul nsw i32 %569, %2
%579 = sext i32 %578 to i64
br i1 %68, label %617, label %580
580: ; preds = %577, %580
%581 = phi i64 [ %614, %580 ], [ 0, %577 ]
%582 = phi i64 [ %615, %580 ], [ 0, %577 ]
%583 = getelementptr inbounds i32, i32* %7, i64 %581
%584 = load i32, i32* %583
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %22, i64 %585
%587 = load double, double* %586
%588 = add nsw i64 %581, %579
%589 = getelementptr inbounds double, double* %0, i64 %588
store double %587, double* %589
%590 = or i64 %581, 1
%591 = getelementptr inbounds i32, i32* %7, i64 %590
%592 = load i32, i32* %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %22, i64 %593
%595 = load double, double* %594
%596 = add nsw i64 %590, %579
%597 = getelementptr inbounds double, double* %0, i64 %596
store double %595, double* %597
%598 = or i64 %581, 2
%599 = getelementptr inbounds i32, i32* %7, i64 %598
%600 = load i32, i32* %599
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %22, i64 %601
%603 = load double, double* %602
%604 = add nsw i64 %598, %579
%605 = getelementptr inbounds double, double* %0, i64 %604
store double %603, double* %605
%606 = or i64 %581, 3
%607 = getelementptr inbounds i32, i32* %7, i64 %606
%608 = load i32, i32* %607
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds double, double* %22, i64 %609
%611 = load double, double* %610
%612 = add nsw i64 %606, %579
%613 = getelementptr inbounds double, double* %0, i64 %612
store double %611, double* %613
%614 = add nuw nsw i64 %581, 4
%615 = add i64 %582, 4
%616 = icmp eq i64 %615, %69
br i1 %616, label %617, label %580
617: ; preds = %580, %577
%618 = phi i64 [ 0, %577 ], [ %614, %580 ]
br i1 %70, label %632, label %619
619: ; preds = %617, %619
%620 = phi i64 [ %629, %619 ], [ %618, %617 ]
%621 = phi i64 [ %630, %619 ], [ 0, %617 ]
%622 = getelementptr inbounds i32, i32* %7, i64 %620
%623 = load i32, i32* %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %22, i64 %624
%626 = load double, double* %625
%627 = add nsw i64 %620, %579
%628 = getelementptr inbounds double, double* %0, i64 %627
store double %626, double* %628
%629 = add nuw nsw i64 %620, 1
%630 = add i64 %621, 1
%631 = icmp eq i64 %630, %67
br i1 %631, label %632, label %619
632: ; preds = %617, %619, %576
store double %568, double* %571
br label %575
633: ; preds = %574, %692
%634 = phi i64 [ %693, %692 ], [ 0, %574 ]
%635 = load i32, i32* %11
%636 = zext i32 %635 to i64
%637 = icmp eq i64 %634, %636
br i1 %637, label %692, label %638
638: ; preds = %633
br i1 %29, label %639, label %689
639: ; preds = %638
%640 = mul nsw i64 %634, %37
%641 = mul nsw i32 %635, %2
%642 = sext i32 %641 to i64
br i1 %64, label %674, label %643
643: ; preds = %639, %643
%644 = phi i64 [ %671, %643 ], [ 0, %639 ]
%645 = phi i64 [ %672, %643 ], [ 0, %639 ]
%646 = add nsw i64 %644, %640
%647 = getelementptr inbounds double, double* %0, i64 %646
%648 = load double, double* %647
%649 = add nsw i64 %644, %642
%650 = getelementptr inbounds double, double* %0, i64 %649
%651 = load double, double* %650
%652 = fadd double %648, %651
%653 = fmul double %652, 5.000000e-01
%654 = getelementptr inbounds i32, i32* %7, i64 %644
%655 = load i32, i32* %654
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds double, double* %3, i64 %656
store double %653, double* %657
store double %653, double* %647
%658 = or i64 %644, 1
%659 = add nsw i64 %658, %640
%660 = getelementptr inbounds double, double* %0, i64 %659
%661 = load double, double* %660
%662 = add nsw i64 %658, %642
%663 = getelementptr inbounds double, double* %0, i64 %662
%664 = load double, double* %663
%665 = fadd double %661, %664
%666 = fmul double %665, 5.000000e-01
%667 = getelementptr inbounds i32, i32* %7, i64 %658
%668 = load i32, i32* %667
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds double, double* %3, i64 %669
store double %666, double* %670
store double %666, double* %660
%671 = add nuw nsw i64 %644, 2
%672 = add i64 %645, 2
%673 = icmp eq i64 %672, %65
br i1 %673, label %674, label %643
674: ; preds = %643, %639
%675 = phi i64 [ 0, %639 ], [ %671, %643 ]
br i1 %66, label %689, label %676
676: ; preds = %674
%677 = add nsw i64 %675, %640
%678 = getelementptr inbounds double, double* %0, i64 %677
%679 = load double, double* %678
%680 = add nsw i64 %675, %642
%681 = getelementptr inbounds double, double* %0, i64 %680
%682 = load double, double* %681
%683 = fadd double %679, %682
%684 = fmul double %683, 5.000000e-01
%685 = getelementptr inbounds i32, i32* %7, i64 %675
%686 = load i32, i32* %685
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds double, double* %3, i64 %687
store double %684, double* %688
store double %684, double* %678
br label %689
689: ; preds = %676, %674, %638
%690 = tail call double (double*, ...) %33(double* %3)
%691 = getelementptr inbounds double, double* %1, i64 %634
store double %690, double* %691
br label %692
692: ; preds = %633, %689
%693 = add nuw nsw i64 %634, 1
%694 = icmp eq i64 %693, %42
br i1 %694, label %575, label %633
695: ; preds = %455, %695
%696 = phi i64 [ %729, %695 ], [ 0, %455 ]
%697 = phi i64 [ %730, %695 ], [ 0, %455 ]
%698 = getelementptr inbounds i32, i32* %7, i64 %696
%699 = load i32, i32* %698
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %3, i64 %700
%702 = load double, double* %701
%703 = add nsw i64 %696, %457
%704 = getelementptr inbounds double, double* %0, i64 %703
store double %702, double* %704
%705 = or i64 %696, 1
%706 = getelementptr inbounds i32, i32* %7, i64 %705
%707 = load i32, i32* %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %3, i64 %708
%710 = load double, double* %709
%711 = add nsw i64 %705, %457
%712 = getelementptr inbounds double, double* %0, i64 %711
store double %710, double* %712
%713 = or i64 %696, 2
%714 = getelementptr inbounds i32, i32* %7, i64 %713
%715 = load i32, i32* %714
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %3, i64 %716
%718 = load double, double* %717
%719 = add nsw i64 %713, %457
%720 = getelementptr inbounds double, double* %0, i64 %719
store double %718, double* %720
%721 = or i64 %696, 3
%722 = getelementptr inbounds i32, i32* %7, i64 %721
%723 = load i32, i32* %722
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds double, double* %3, i64 %724
%726 = load double, double* %725
%727 = add nsw i64 %721, %457
%728 = getelementptr inbounds double, double* %0, i64 %727
store double %726, double* %728
%729 = add nuw nsw i64 %696, 4
%730 = add i64 %697, 4
%731 = icmp eq i64 %730, %73
br i1 %731, label %732, label %695
732: ; preds = %695, %455
%733 = phi i64 [ 0, %455 ], [ %729, %695 ]
br i1 %74, label %747, label %734
734: ; preds = %732, %734
%735 = phi i64 [ %744, %734 ], [ %733, %732 ]
%736 = phi i64 [ %745, %734 ], [ 0, %732 ]
%737 = getelementptr inbounds i32, i32* %7, i64 %735
%738 = load i32, i32* %737
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds double, double* %3, i64 %739
%741 = load double, double* %740
%742 = add nsw i64 %735, %457
%743 = getelementptr inbounds double, double* %0, i64 %742
store double %741, double* %743
%744 = add nuw nsw i64 %735, 1
%745 = add i64 %736, 1
%746 = icmp eq i64 %745, %71
br i1 %746, label %747, label %734
747: ; preds = %732, %734, %454
%748 = sext i32 %453 to i64
%749 = getelementptr inbounds double, double* %1, i64 %748
store double %274, double* %749
br label %575
750: ; preds = %158, %154, %151, %24
%751 = phi i32 [ 1, %151 ], [ 2, %154 ], [ 3, %158 ], [ 0, %24 ]
ret i32 %751
}