int fsimplex(float *const p, float *const y, int ndim, float *const pr, int na,
             float ftol, float atol, int *const lista, float (*const funk)(),
             int itmax, int *const iter, int *const ilo, int *const ihi) {
  static float alpha = 1.0, beta = 0.5, gamma = 2.0;
  float *pbar, *prr;
  float yprr, ypr;
  int inhi, mpts;
  int i, j;
  if (!(pbar = (float *)malloc(na * sizeof(float))) ||
      !(prr = (float *)malloc(na * sizeof(float)))) {
    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]) * (float)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) = (float)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] /= (float)ndim;
      pr[lista[j]] =
          *(pbar + j) * ((float)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) * ((float)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) * ((float)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]) * (float)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):
<fsimplex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%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)
movss  %xmm0,-0x30(%rbp)
movss  %xmm1,-0x34(%rbp)
mov    %r9,-0x40(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     11a2 <fsimplex+0x72>
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    11bc <fsimplex+0x8c>
lea    0xe77(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a5a <fsimplex+0x92a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
jbe    1205 <fsimplex+0xd5>
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x5c(%rbp)
jmp    1216 <fsimplex+0xe6>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    12e2 <fsimplex+0x1b2>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1258 <fsimplex+0x128>
mov    -0x64(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1291 <fsimplex+0x161>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%ecx
mov    0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    12cf <fsimplex+0x19f>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    12ca <fsimplex+0x19a>
mov    -0x64(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
je     12c5 <fsimplex+0x195>
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    12ca <fsimplex+0x19a>
jmp    12cf <fsimplex+0x19f>
jmp    12d4 <fsimplex+0x1a4>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    121d <fsimplex+0xed>
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xcf3(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xcf7(%rip),%xmm0
mulsd  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xcbf(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
movaps 0xca0(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1394 <fsimplex+0x264>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    1a5a <fsimplex+0x92a>
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13d0 <fsimplex+0x2a0>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x4(%rbp)
jmp    1a5a <fsimplex+0x92a>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
cmp    0x18(%rbp),%eax
jne    13fd <fsimplex+0x2cd>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x3,-0x4(%rbp)
jmp    1a5a <fsimplex+0x92a>
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1439 <fsimplex+0x309>
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    140f <fsimplex+0x2df>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    14bc <fsimplex+0x38c>
mov    -0x64(%rbp),%eax
mov    0x30(%rbp),%rcx
cmp    (%rcx),%eax
je     14a9 <fsimplex+0x379>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14a4 <fsimplex+0x374>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1462 <fsimplex+0x332>
jmp    14a9 <fsimplex+0x379>
jmp    14ae <fsimplex+0x37e>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1440 <fsimplex+0x310>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1560 <fsimplex+0x430>
cvtsi2ssl -0x1c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xb1d(%rip),%xmm2
addss  0x2b31(%rip),%xmm2
movss  0x2b29(%rip),%xmm1
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14c3 <fsimplex+0x393>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    159b <fsimplex+0x46b>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1567 <fsimplex+0x437>
mov    0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1747 <fsimplex+0x617>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1646 <fsimplex+0x516>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x2a46(%rip),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xa0d(%rip),%xmm3
subss  0x2a29(%rip),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    15d1 <fsimplex+0x4a1>
mov    0x10(%rbp),%rcx
mov    -0x50(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    16de <fsimplex+0x5ae>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16c4 <fsimplex+0x594>
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    167c <fsimplex+0x54c>
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1742 <fsimplex+0x612>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    172d <fsimplex+0x5fd>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16e5 <fsimplex+0x5b5>
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1a55 <fsimplex+0x925>
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     19ec <fsimplex+0x8bc>
movss  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    17e0 <fsimplex+0x6b0>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17cb <fsimplex+0x69b>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1783 <fsimplex+0x653>
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1860 <fsimplex+0x730>
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x2828(%rip),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x7f3(%rip),%xmm3
subss  0x280b(%rip),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    17e7 <fsimplex+0x6b7>
mov    0x10(%rbp),%rcx
mov    -0x50(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    18f8 <fsimplex+0x7c8>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18de <fsimplex+0x7ae>
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1896 <fsimplex+0x766>
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19e7 <fsimplex+0x8b7>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    19e2 <fsimplex+0x8b2>
mov    -0x64(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
je     19cf <fsimplex+0x89f>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19b6 <fsimplex+0x886>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0x6b4(%rip),%xmm1
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1921 <fsimplex+0x7f1>
mov    0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19d4 <fsimplex+0x8a4>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18ff <fsimplex+0x7cf>
jmp    19e7 <fsimplex+0x8b7>
jmp    1a50 <fsimplex+0x920>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a3b <fsimplex+0x90b>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    19f3 <fsimplex+0x8c3>
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1a55 <fsimplex+0x925>
jmp    11cf <fsimplex+0x9f>
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fsimplex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r13
movss  %xmm1,0x7c(%rsp)
movss  %xmm0,0x10(%rsp)
mov    %rcx,0x18(%rsp)
mov    %edx,%ebx
mov    %rsi,0x48(%rsp)
mov    %rdi,0x20(%rsp)
mov    %r8d,0x54(%rsp)
movslq %r8d,%r12
shl    $0x2,%r12
mov    %r12,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     1e13 <fsimplex+0xcc3>
mov    %rax,%r14
mov    %r12,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     1e13 <fsimplex+0xcc3>
mov    %rax,%r12
mov    0x130(%rsp),%r10
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rax
cvtsi2ss %ebx,%xmm4
movl   $0x0,(%rax)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xb8(%rsp)
lea    0x1(%rbx),%eax
mov    %ebx,%r15d
mov    0x54(%rsp),%ecx
shl    $0x2,%rcx
mov    %rcx,0x98(%rsp)
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0xb0(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0xc8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xc0(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0xa8(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x40(%rsp)
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x70(%rsp)
lea    0x0(,%r15,4),%rcx
mov    %rcx,0x90(%rsp)
mov    %rbx,0x10(%rsp)
movslq %ebx,%rcx
lea    -0x1(%r15),%rdx
mov    %rdx,0x28(%rsp)
mov    %rax,0x80(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0xa0(%rsp)
mov    0x20(%rsp),%rax
lea    0x30(%rax),%rdx
mov    %rdx,0x88(%rsp)
mov    %rcx,0x58(%rsp)
lea    0x0(,%rcx,4),%rcx
mov    %rcx,0x60(%rsp)
lea    0xc(%rax),%rcx
mov    %rcx,0x38(%rsp)
add    $0x4,%rax
mov    %rax,0x68(%rsp)
mov    0x18(%rsp),%r8
mov    0x48(%rsp),%r9
movss  %xmm4,0xc(%rsp)
mov    %r12,0x30(%rsp)
jmp    12f6 <fsimplex+0x1a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm1,(%r9,%rax,4)
movl   $0x0,(%r11)
movss  (%r9),%xmm0
xor    %r12d,%r12d
xor    %ecx,%ecx
ucomiss 0x4(%r9),%xmm0
seta   %r12b
setbe  %cl
mov    %ecx,(%r10)
cmpl   $0x0,0x10(%rsp)
js     13b0 <fsimplex+0x260>
xor    %eax,%eax
mov    0xa0(%rsp),%rdi
mov    0x60(%rsp),%rbp
movslq (%r11),%rdx
movss  (%r9,%rdx,4),%xmm1
ucomiss %xmm0,%xmm1
mov    %ecx,%edx
jbe    1346 <fsimplex+0x1f6>
mov    %eax,(%r11)
mov    (%r10),%edx
movslq %edx,%rcx
ucomiss (%r9,%rcx,4),%xmm0
jbe    1360 <fsimplex+0x210>
mov    %eax,(%r10)
mov    %eax,%ecx
cmp    %rax,%rdi
jne    1381 <fsimplex+0x231>
jmp    13a0 <fsimplex+0x250>
nopl   0x0(%rax)
movslq %r12d,%rsi
mov    %edx,%ecx
cmp    %rcx,%rax
mov    %esi,%ecx
cmovne %eax,%ecx
ucomiss (%r9,%rsi,4),%xmm0
jbe    1377 <fsimplex+0x227>
mov    %ecx,%r12d
mov    %edx,%ecx
mov    %r12d,%edx
cmp    %rax,%rdi
je     13a0 <fsimplex+0x250>
movss  0x4(%r9,%rax,4),%xmm0
add    $0x1,%rax
mov    %edx,%r12d
jmp    1330 <fsimplex+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%r12d
jmp    13b5 <fsimplex+0x265>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x60(%rsp),%rbp
movslq %ecx,%rax
movss  (%r9,%rax,4),%xmm1
movslq (%r11),%rax
movss  (%r9,%rax,4),%xmm0
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movaps 0xc2b(%rip),%xmm3
andps  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
unpcklps %xmm0,%xmm1
andps  %xmm3,%xmm1
cvtps2pd %xmm1,%xmm1
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
addsd  %xmm1,%xmm3
mulsd  0xb8(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jae    1e33 <fsimplex+0xce3>
movss  0x7c(%rsp),%xmm1
ucomiss %xmm0,%xmm1
ja     1e4c <fsimplex+0xcfc>
mov    0x120(%rsp),%rcx
mov    (%rcx),%eax
cmp    0x118(%rsp),%eax
je     1e65 <fsimplex+0xd15>
add    $0x1,%eax
mov    %eax,(%rcx)
cmpl   $0x0,0x10(%rsp)
jle    145f <fsimplex+0x30f>
mov    %r14,%rdi
xor    %esi,%esi
mov    0x90(%rsp),%rdx
call   1050 <memset@plt>
movss  0xc(%rsp),%xmm4
mov    0x130(%rsp),%r10
mov    0x18(%rsp),%r8
cmpl   $0x0,0x10(%rsp)
mov    0x20(%rsp),%r9
mov    0x80(%rsp),%rbx
mov    0xb0(%rsp),%r11
js     15d0 <fsimplex+0x480>
mov    (%r10),%eax
mov    %r9,%rcx
mov    0x88(%rsp),%rdx
xor    %esi,%esi
jmp    14b3 <fsimplex+0x363>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %rbp,%rdx
add    %rbp,%rcx
cmp    %rbx,%rsi
je     15d0 <fsimplex+0x480>
cmp    %rax,%rsi
je     14a0 <fsimplex+0x350>
cmpl   $0x0,0x10(%rsp)
jle    14a0 <fsimplex+0x350>
cmpl   $0x8,0x10(%rsp)
jae    14d0 <fsimplex+0x380>
xor    %edi,%edi
jmp    15a0 <fsimplex+0x450>
nopl   (%rax)
cmpq   $0x0,0xd0(%rsp)
je     15bf <fsimplex+0x46f>
mov    0xc0(%rsp),%rbp
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x30(%rdx,%rdi,4),%xmm0
movups -0x20(%rdx,%rdi,4),%xmm1
movups (%r14,%rdi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r14,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%r14,%rdi,4),%xmm1
movups 0x30(%r14,%rdi,4),%xmm3
movups %xmm2,(%r14,%rdi,4)
movups %xmm0,0x10(%r14,%rdi,4)
movups -0x10(%rdx,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%rdi,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14f0 <fsimplex+0x3a0>
testb  $0x1,0xc8(%rsp)
01
je     1584 <fsimplex+0x434>
mov    %rsi,%rbp
imul   0x58(%rsp),%rbp
add    %rdi,%rbp
movups (%r9,%rbp,4),%xmm0
movups 0x10(%r9,%rbp,4),%xmm1
movups (%r14,%rdi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r14,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%r14,%rdi,4)
movups %xmm0,0x10(%r14,%rdi,4)
mov    %r11,%rdi
cmp    %r15,%r11
mov    0x60(%rsp),%rbp
je     14a0 <fsimplex+0x350>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%r15
jne    15a0 <fsimplex+0x450>
jmp    14a0 <fsimplex+0x350>
xor    %edi,%edi
testb  $0x1,0xc8(%rsp)
01
jne    1551 <fsimplex+0x401>
jmp    1584 <fsimplex+0x434>
nopl   (%rax)
mov    0x10(%rsp),%rbp
test   %ebp,%ebp
jle    161d <fsimplex+0x4cd>
movslq (%r10),%rax
imul   0x58(%rsp),%rax
lea    (%r9,%rax,4),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rcx,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,(%r14,%rcx,4)
addss  %xmm0,%xmm0
subss  (%rax,%rcx,4),%xmm0
movslq 0x0(%r13,%rcx,4),%rdx
movss  %xmm0,(%r8,%rdx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    15f0 <fsimplex+0x4a0>
cmpl   $0x0,0x54(%rsp)
mov    0xa8(%rsp),%rbx
jle    1646 <fsimplex+0x4f6>
mov    0x30(%rsp),%rdi
mov    %r8,%rsi
mov    0x98(%rsp),%rdx
call   1060 <memcpy@plt>
mov    0x18(%rsp),%r8
mov    %r8,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
movaps %xmm0,%xmm1
mov    0x128(%rsp),%r11
movslq (%r11),%rax
mov    0x48(%rsp),%r9
movss  (%r9,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1770 <fsimplex+0x620>
test   %ebp,%ebp
mov    0x30(%rsp),%r12
jle    1703 <fsimplex+0x5b3>
cmpq   $0x0,0x28(%rsp)
je     1849 <fsimplex+0x6f9>
xor    %eax,%eax
mov    0x18(%rsp),%rdx
mov    0x70(%rsp),%rsi
nopl   0x0(%rax)
movslq 0x0(%r13,%rax,4),%rcx
movss  (%rdx,%rcx,4),%xmm0
addss  %xmm0,%xmm0
subss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
movslq 0x4(%r13,%rax,4),%rcx
movss  (%rdx,%rcx,4),%xmm0
addss  %xmm0,%xmm0
subss  0x4(%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
add    $0x2,%rax
cmp    %rax,%rsi
jne    16a0 <fsimplex+0x550>
test   $0x1,%r15b
je     1703 <fsimplex+0x5b3>
movslq 0x0(%r13,%rax,4),%rcx
mov    0x18(%rsp),%rdx
movss  (%rdx,%rcx,4),%xmm0
addss  %xmm0,%xmm0
subss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
movss  %xmm1,0x78(%rsp)
mov    %r12,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x128(%rsp),%r11
movslq (%r11),%rax
mov    0x48(%rsp),%r9
movss  (%r9,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
mov    0x130(%rsp),%r10
movslq (%r10),%rax
jbe    17c0 <fsimplex+0x670>
test   %ebp,%ebp
mov    0x18(%rsp),%r8
movss  0xc(%rsp),%xmm4
jle    18f8 <fsimplex+0x7a8>
mov    %eax,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x28(%rsp)
jae    185a <fsimplex+0x70a>
xor    %edx,%edx
jmp    18bc <fsimplex+0x76c>
nopl   (%rax)
movslq %r12d,%rax
ucomiss (%r9,%rax,4),%xmm1
mov    0x130(%rsp),%r10
movslq (%r10),%rax
jae    1800 <fsimplex+0x6b0>
test   %ebp,%ebp
mov    0x18(%rsp),%r8
movss  0xc(%rsp),%xmm4
jle    12f0 <fsimplex+0x1a0>
mov    %eax,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x28(%rsp)
jae    1903 <fsimplex+0x7b3>
xor    %edx,%edx
jmp    196c <fsimplex+0x81c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %ebp,%ebp
mov    0x18(%rsp),%r8
movss  0xc(%rsp),%xmm4
movss  0x78(%rsp),%xmm1
jle    1a48 <fsimplex+0x8f8>
mov    %eax,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
cmpq   $0x3,0x28(%rsp)
jae    19ad <fsimplex+0x85d>
xor    %edx,%edx
jmp    1a0c <fsimplex+0x8bc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r9,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r12
movss  0x7f5(%rip),%xmm2
jbe    1afe <fsimplex+0x9ae>
cmpl   $0x0,0x10(%rsp)
jle    1af8 <fsimplex+0x9a8>
mov    %eax,%ecx
imul   0x10(%rsp),%ecx
movslq %ecx,%r8
cmpq   $0x3,0x28(%rsp)
jae    1a53 <fsimplex+0x903>
xor    %edx,%edx
jmp    1abc <fsimplex+0x96c>
xor    %eax,%eax
test   $0x1,%r15b
jne    16e4 <fsimplex+0x594>
jmp    1703 <fsimplex+0x5b3>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%rsi
xor    %edx,%edx
mov    0x40(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movslq 0x0(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0xc(%rsi,%rdx,4)
movslq 0x4(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0x8(%rsi,%rdx,4)
movslq 0x8(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rdx,4)
movslq 0xc(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1870 <fsimplex+0x720>
test   $0x3,%r15b
je     18f8 <fsimplex+0x7a8>
add    %rdx,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    18e0 <fsimplex+0x790>
movss  %xmm0,(%r9,%rax,4)
jmp    12f6 <fsimplex+0x1a6>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%rsi
xor    %edx,%edx
mov    0x40(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq 0x0(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rdx,4)
movslq 0x4(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdx,4)
movslq 0x8(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdx,4)
movslq 0xc(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1920 <fsimplex+0x7d0>
test   $0x3,%r15b
je     12f0 <fsimplex+0x1a0>
add    %rdx,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nop
movslq (%rdx,%rsi,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1990 <fsimplex+0x840>
jmp    12f0 <fsimplex+0x1a0>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%rsi
xor    %edx,%edx
mov    0x40(%rsp),%rbp
nopl   (%rax)
movslq 0x0(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rdx,4)
movslq 0x4(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdx,4)
movslq 0x8(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdx,4)
movslq 0xc(%r13,%rdx,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    19c0 <fsimplex+0x870>
test   $0x3,%r15b
je     1a48 <fsimplex+0x8f8>
add    %rdx,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1a30 <fsimplex+0x8e0>
movss  %xmm1,(%r9,%rax,4)
jmp    12f6 <fsimplex+0x1a6>
mov    0x38(%rsp),%rcx
lea    (%rcx,%r8,4),%rsi
xor    %edx,%edx
mov    0x40(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq 0x0(%r13,%rdx,4),%rdi
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rdx,4)
movslq 0x4(%r13,%rdx,4),%rdi
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdx,4)
movslq 0x8(%r13,%rdx,4),%rdi
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdx,4)
movslq 0xc(%r13,%rdx,4),%rdi
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1a70 <fsimplex+0x920>
test   %rbx,%rbx
je     1af8 <fsimplex+0x9a8>
add    %rdx,%r8
mov    0x20(%rsp),%rsi
lea    (%rsi,%r8,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1ae0 <fsimplex+0x990>
movss  %xmm1,(%r9,%rax,4)
mov    0x10(%rsp),%rbp
test   %ebp,%ebp
jle    1baf <fsimplex+0xa5f>
imul   %ebp,%eax
cltq
cmpq   $0x0,0x28(%rsp)
je     1d5d <fsimplex+0xc0d>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
xor    %ecx,%ecx
mov    0x70(%rsp),%rdi
nopl   0x0(%rax)
movss  (%r14,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
movss  -0x4(%rdx,%rcx,4),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq 0x0(%r13,%rcx,4),%rsi
movss  %xmm1,(%r12,%rsi,4)
movss  0x4(%r14,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
movss  (%rdx,%rcx,4),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq 0x4(%r13,%rcx,4),%rsi
movss  %xmm1,(%r12,%rsi,4)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    1b30 <fsimplex+0x9e0>
test   $0x1,%r15b
je     1baf <fsimplex+0xa5f>
add    %rcx,%rax
movss  (%r14,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
mov    0x20(%rsp),%rdx
movss  (%rdx,%rax,4),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq 0x0(%r13,%rcx,4),%rax
movss  %xmm1,(%r12,%rax,4)
mov    %r12,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x130(%rsp),%r10
movslq (%r10),%rax
mov    0x48(%rsp),%r9
movss  (%r9,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    1c0d <fsimplex+0xabd>
test   %ebp,%ebp
mov    0x18(%rsp),%r8
mov    0x128(%rsp),%r11
movss  0xc(%rsp),%xmm4
jle    1e08 <fsimplex+0xcb8>
mov    %rax,%rcx
imul   0x58(%rsp),%rcx
cmpq   $0x3,0x28(%rsp)
jae    1d6e <fsimplex+0xc1e>
xor    %edx,%edx
jmp    1dcc <fsimplex+0xc7c>
test   %ebp,%ebp
mov    0x18(%rsp),%r8
mov    0x128(%rsp),%r11
movss  0xc(%rsp),%xmm4
js     12f6 <fsimplex+0x1a6>
mov    0x68(%rsp),%rbp
xor    %ebx,%ebx
jmp    1c89 <fsimplex+0xb39>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8,%rdi
xor    %eax,%eax
call   *0x110(%rsp)
mov    0x18(%rsp),%r8
mov    0x48(%rsp),%r9
movss  %xmm0,(%r9,%rbx,4)
mov    0x130(%rsp),%r10
mov    0x128(%rsp),%r11
movss  0xc(%rsp),%xmm4
add    $0x1,%rbx
add    0x60(%rsp),%rbp
cmp    0x80(%rsp),%rbx
je     12f6 <fsimplex+0x1a6>
mov    (%r11),%eax
cmp    %rax,%rbx
je     1c72 <fsimplex+0xb22>
cmpl   $0x0,0x10(%rsp)
mov    0x70(%rsp),%rdi
jle    1c40 <fsimplex+0xaf0>
imul   0x10(%rsp),%eax
cltq
cmpq   $0x0,0x28(%rsp)
je     1d16 <fsimplex+0xbc6>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
xor    %ecx,%ecx
movss  0x351(%rip),%xmm1
nop
movss  -0x4(%rbp,%rcx,4),%xmm0
addss  -0x4(%rdx,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movslq 0x0(%r13,%rcx,4),%rsi
movss  %xmm0,(%r8,%rsi,4)
movss  %xmm0,-0x4(%rbp,%rcx,4)
movss  0x0(%rbp,%rcx,4),%xmm0
addss  (%rdx,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movslq 0x4(%r13,%rcx,4),%rsi
movss  %xmm0,(%r8,%rsi,4)
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    1cc0 <fsimplex+0xb70>
test   $0x1,%r15b
je     1c40 <fsimplex+0xaf0>
jmp    1d22 <fsimplex+0xbd2>
xor    %ecx,%ecx
test   $0x1,%r15b
je     1c40 <fsimplex+0xaf0>
mov    %rbx,%rdx
imul   0x58(%rsp),%rdx
add    %rcx,%rdx
mov    0x20(%rsp),%rsi
movss  (%rsi,%rdx,4),%xmm0
add    %rcx,%rax
addss  (%rsi,%rax,4),%xmm0
mulss  0x2c8(%rip),%xmm0
movslq 0x0(%r13,%rcx,4),%rax
movss  %xmm0,(%r8,%rax,4)
movss  %xmm0,(%rsi,%rdx,4)
jmp    1c40 <fsimplex+0xaf0>
xor    %ecx,%ecx
test   $0x1,%r15b
jne    1b85 <fsimplex+0xa35>
jmp    1baf <fsimplex+0xa5f>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%rsi
xor    %edx,%edx
mov    0x40(%rsp),%rbp
xchg   %ax,%ax
movslq 0x0(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0xc(%rsi,%rdx,4)
movslq 0x4(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0x8(%rsi,%rdx,4)
movslq 0x8(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rdx,4)
movslq 0xc(%r13,%rdx,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1d80 <fsimplex+0xc30>
test   $0x3,%r15b
je     1e08 <fsimplex+0xcb8>
add    %rdx,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
movss  (%r12,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1df0 <fsimplex+0xca0>
movss  %xmm0,(%r9,%rax,4)
jmp    12f6 <fsimplex+0x1a6>
lea    0x1fa(%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 <fsimplex+0xcd1>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0x2,%eax
jmp    1e21 <fsimplex+0xcd1>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    $0x3,%eax
jmp    1e21 <fsimplex+0xcd1>

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

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