void simplx(int n, float *x, float *f, float tol, int iw, float *xn,
            float *pdash, float *pastx, float *pdastx, float *y, float *p,
            int ldp, void (*funct)(void *, int, float *, float *), void *data,
            int maxcal) {
  float yerr, yerrold = 0.0, yh, yl, yast, ydast, fm, sqrt2;
  int iyhigh, iylow;
  int i, j, icount = 0;
  for (i = 0; i < n; i++)
    (p[(0) * ldp + (i)]) = x[i];
  sqrt2 = sqrt(2);
  for (i = 0; i < n; i++) {
    xn[i] = x[i] * (sqrt((float)iw) + n - 1) / (sqrt2 * n);
    pdash[i] = x[i] * (sqrt((float)iw) - 1.0) / (sqrt2 * n);
  }
  for (i = 1; i < iw; i++) {
    for (j = 0; j < n; j++)
      (p[(i)*ldp + (j)]) = (p[(0) * ldp + (j)]) + pdash[j];
    (p[(i)*ldp + (i - 1)]) += xn[i - 1];
  }
  for (i = 0; i < iw; i++) {
    for (j = 0; j < n; j++)
      xn[j] = (p[(i)*ldp + (j)]);
    funct(data, n, xn, &(y[i]));
  }
L110:
  yh = y[0];
  yl = y[0];
  for (i = 0; i < iw; i++) {
    if (yh <= y[i]) {
      yh = y[i];
      iyhigh = i;
    }
    if (yl >= y[i]) {
      yl = y[i];
      iylow = i;
    }
  }
  for (i = 0; i < n; i++)
    xn[i] = 0.0;
  for (i = 0; i < n; i++)
    for (j = 0; j < iw; j++)
      if (j != iyhigh)
        xn[i] += (p[(j)*ldp + (i)]);
  for (i = 0; i < n; i++)
    pdash[i] = xn[i] / (float)n;
  for (i = 0; i < n; i++)
    pastx[i] = 2.0 * pdash[i] - (p[(iyhigh)*ldp + (i)]);
  funct(data, n, pastx, &yast);
  if (yast < yl)
    goto L1000;
  for (i = 0; i < iw; i++) {
    if (i == iyhigh)
      break;
    if (yast < y[i])
      goto L2030;
  }
  goto L3000;
L2030:
  for (i = 0; i < n; i++)
    (p[(iyhigh)*ldp + (i)]) = pastx[i];
  y[iyhigh] = yast;
L2040:
  fm = 0.0;
  for (i = 0; i < iw; i++)
    fm += y[i];
  fm /= (float)iw;
  yerr = 0.0;
  for (i = 0; i < iw; i++)
    yerr += (y[i] - fm) * (y[i] - fm);
  yerr /= (float)iw;
  for (i = 0; i < n; i++)
    x[i] = (p[(iylow)*ldp + (i)]);
  *f = yl;
  if (yerr < tol)
    return;
  if (fabs(yerr - yerrold) < 1.e-20)
    return;
  yerrold = yerr;
  icount++;
  if (icount == maxcal)
    return;
  goto L110;
L1000:
  for (i = 0; i < n; i++)
    pdastx[i] = 2.0 * pastx[i] - pdash[i];
  funct(data, n, pdastx, &ydast);
  if (ydast >= yl)
    goto L2030;
L1030:
  for (i = 0; i < n; i++)
    (p[(iyhigh)*ldp + (i)]) = pdastx[i];
  y[iyhigh] = ydast;
  goto L2040;
L3000:
  if (yast <= yh) {
    for (i = 0; i < n; i++)
      (p[(iyhigh)*ldp + (i)]) = pastx[i];
    yh = yast;
    y[iyhigh] = yh;
  }
  for (i = 0; i < n; i++)
    pdastx[i] = 0.5 * (p[(iyhigh)*ldp + (i)]) + 0.5 * pdash[i];
  funct(data, n, pdastx, &ydast);
  if (ydast > ((((yast) < (yh)) ? (yast) : (yh)))) {
    for (i = 0; i < n; i++)
      xn[i] = 0.0;
    for (j = 0; j < n; j++)
      for (i = 0; i < iw; i++)
        xn[j] += (p[(i)*ldp + (j)]);
    for (i = 0; i < n; i++)
      xn[i] /= (float)iw;
    for (j = 0; j < iw; j++)
      for (i = 0; i < n; i++)
        (p[(j)*ldp + (i)]) -= xn[i] + (p[(iylow)*ldp + (i)]);
    for (j = 0; j < iw; j++) {
      for (i = 0; i < n; i++)
        xn[i] = (p[(j)*ldp + (i)]);
      funct(data, n, xn, &(y[j]));
    }
  } else
    goto L1030;
  goto L2040;
}


x86 assembly (clang, -O0):
<simplx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a4 <simplx+0x94>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
imul   $0x0,0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    116a <simplx+0x5a>
movsd  0xe54(%rip),%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12aa <simplx+0x19a>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
cvtsi2ssl -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
cvtsi2sdl -0x4(%rbp),%xmm2
addsd  %xmm2,%xmm1
movsd  0xe0e(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
cvtsi2ssl -0x4(%rbp),%xmm2
mulss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
cvtsi2ssl -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xdab(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
cvtsi2ssl -0x4(%rbp),%xmm2
mulss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11c1 <simplx+0xb1>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1354 <simplx+0x244>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1314 <simplx+0x204>
mov    0x28(%rbp),%rax
imul   $0x0,0x30(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12c4 <simplx+0x1b4>
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   0x30(%rbp),%ecx
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12b1 <simplx+0x1a1>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13d9 <simplx+0x2c9>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13ab <simplx+0x29b>
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    136e <simplx+0x25e>
mov    0x38(%rbp),%rax
mov    0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    0x20(%rbp),%rcx
movslq -0x5c(%rbp),%r8
shl    $0x2,%r8
add    %r8,%rcx
call   *%rax
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    135b <simplx+0x24b>
jmp    13de <simplx+0x2ce>
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1480 <simplx+0x370>
movss  -0x3c(%rbp),%xmm1
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     143e <simplx+0x32e>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     146d <simplx+0x35d>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1472 <simplx+0x362>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13ff <simplx+0x2ef>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14b1 <simplx+0x3a1>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1487 <simplx+0x377>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1531 <simplx+0x421>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    151e <simplx+0x40e>
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
je     150b <simplx+0x3fb>
mov    0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1510 <simplx+0x400>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14cb <simplx+0x3bb>
jmp    1523 <simplx+0x413>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    14b8 <simplx+0x3a8>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1575 <simplx+0x465>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1538 <simplx+0x428>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15f1 <simplx+0x4e1>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    157c <simplx+0x46c>
mov    0x38(%rbp),%rax
mov    0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
lea    -0x44(%rbp),%rcx
call   *%rax
movss  -0x44(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    161e <simplx+0x50e>
jmp    1857 <simplx+0x747>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1675 <simplx+0x565>
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    1642 <simplx+0x532>
jmp    1675 <simplx+0x565>
movss  -0x44(%rbp),%xmm1
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1662 <simplx+0x552>
jmp    167a <simplx+0x56a>
jmp    1667 <simplx+0x557>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1625 <simplx+0x515>
jmp    1953 <simplx+0x843>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16be <simplx+0x5ae>
mov    0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1681 <simplx+0x571>
movss  -0x44(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1710 <simplx+0x600>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16df <simplx+0x5cf>
cvtsi2ssl -0x20(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1782 <simplx+0x672>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x4c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1732 <simplx+0x622>
cvtsi2ssl -0x20(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17d9 <simplx+0x6c9>
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    179c <simplx+0x68c>
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    17fe <simplx+0x6ee>
jmp    1c96 <simplx+0xb86>
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x80d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x7f1(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    182e <simplx+0x71e>
jmp    1c96 <simplx+0xb86>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x48(%rbp),%eax
jne    1852 <simplx+0x742>
jmp    1c96 <simplx+0xb86>
jmp    13de <simplx+0x2ce>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18ca <simplx+0x7ba>
mov    0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    185e <simplx+0x74e>
mov    0x38(%rbp),%rax
mov    0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rdx
lea    -0x48(%rbp),%rcx
call   *%rax
movss  -0x48(%rbp),%xmm0
ucomiss -0x40(%rbp),%xmm0
jb     18f3 <simplx+0x7e3>
jmp    167a <simplx+0x56a>
jmp    18f8 <simplx+0x7e8>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    193c <simplx+0x82c>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    18ff <simplx+0x7ef>
movss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16d0 <simplx+0x5c0>
movss  -0x44(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     19c6 <simplx+0x8b6>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19aa <simplx+0x89a>
mov    0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    196d <simplx+0x85d>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a3f <simplx+0x92f>
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x5fc(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x5f0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    19cd <simplx+0x8bd>
mov    0x38(%rbp),%rax
mov    0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rdx
lea    -0x48(%rbp),%rcx
call   *%rax
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1a80 <simplx+0x970>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    1a8a <simplx+0x97a>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1c8c <simplx+0xb7c>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ace <simplx+0x9be>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1aa4 <simplx+0x994>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b3d <simplx+0xa2d>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1b2a <simplx+0xa1a>
mov    0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1ae8 <simplx+0x9d8>
jmp    1b2f <simplx+0xa1f>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1ad5 <simplx+0x9c5>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b79 <simplx+0xa69>
cvtsi2ssl -0x20(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1b44 <simplx+0xa34>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1c02 <simplx+0xaf2>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bef <simplx+0xadf>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1b93 <simplx+0xa83>
jmp    1bf4 <simplx+0xae4>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b80 <simplx+0xa70>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1c87 <simplx+0xb77>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c59 <simplx+0xb49>
mov    0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1c1c <simplx+0xb0c>
mov    0x38(%rbp),%rax
mov    0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    0x20(%rbp),%rcx
movslq -0x60(%rbp),%r8
shl    $0x2,%r8
add    %r8,%rcx
call   *%rax
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1c09 <simplx+0xaf9>
jmp    1c91 <simplx+0xb81>
jmp    18f8 <simplx+0x7e8>
jmp    16d0 <simplx+0x5c0>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %r9,%r15
mov    %r8,%r12
mov    %ecx,%r14d
movss  %xmm0,0x12c(%rsp)
mov    %rdx,0x1c8(%rsp)
mov    0x268(%rsp),%r10
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %rax,0x88(%rsp)
mov    %edi,%r11d
test   %edi,%edi
mov    %rsi,0x70(%rsp)
mov    %edi,0xc(%rsp)
mov    %r11,(%rsp)
jle    1446 <simplx+0x326>
cmp    $0x8,%edi
jb     1198 <simplx+0x78>
lea    (%rsi,%r11,4),%rax
cmp    %r10,%rax
jbe    1210 <simplx+0xf0>
lea    (%r10,%r11,4),%rax
cmp    %rsi,%rax
jbe    1210 <simplx+0xf0>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     11c5 <simplx+0xa5>
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11b0 <simplx+0x90>
cmp    $0x3,%rcx
jb     12f5 <simplx+0x1d5>
nop
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,0x4(%r10,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm0
movss  %xmm0,0x8(%r10,%rax,4)
movss  0xc(%rsi,%rax,4),%xmm0
movss  %xmm0,0xc(%r10,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    11d0 <simplx+0xb0>
jmp    12f5 <simplx+0x1d5>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbp
mov    %rbp,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    1236 <simplx+0x116>
xor    %ebp,%ebp
jmp    12b0 <simplx+0x190>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
and    %rcx,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rbp,4),%xmm0
movups 0x10(%rsi,%rbp,4),%xmm1
movups %xmm0,(%r10,%rbp,4)
movups %xmm1,0x10(%r10,%rbp,4)
movups 0x20(%rsi,%rbp,4),%xmm0
movups 0x30(%rsi,%rbp,4),%xmm1
movups %xmm0,0x20(%r10,%rbp,4)
movups %xmm1,0x30(%r10,%rbp,4)
movups 0x40(%rsi,%rbp,4),%xmm0
movups 0x50(%rsi,%rbp,4),%xmm1
movups %xmm0,0x40(%r10,%rbp,4)
movups %xmm1,0x50(%r10,%rbp,4)
movups 0x60(%rsi,%rbp,4),%xmm0
movups 0x70(%rsi,%rbp,4),%xmm1
movups %xmm0,0x60(%r10,%rbp,4)
movups %xmm1,0x70(%r10,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1250 <simplx+0x130>
test   %r8,%r8
je     12ec <simplx+0x1cc>
lea    (%r10,%rbp,4),%rdx
add    $0x10,%rdx
lea    (%rsi,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rcx,1),%xmm0
movups 0x0(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rcx,1)
movups %xmm1,(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r8
jne    12d0 <simplx+0x1b0>
cmp    %r11,%rax
jne    119a <simplx+0x7a>
test   %edi,%edi
jle    1446 <simplx+0x326>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd  %xmm1,0x60(%rsp)
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
cvtss2sd %xmm0,%xmm2
mulss  0x2cdb(%rip),%xmm1
cvtss2sd %xmm1,%xmm3
xor    %ebp,%ebp
sqrtsd %xmm2,%xmm4
xorpd  %xmm5,%xmm5
movsd  0x2ccd(%rip),%xmm6
movsd  %xmm2,0x28(%rsp)
movsd  %xmm3,0x38(%rsp)
movsd  %xmm4,0x20(%rsp)
jmp    1377 <simplx+0x257>
nop
cvtss2sd %xmm1,%xmm1
addsd  %xmm6,%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r11
je     1446 <simplx+0x326>
movss  (%rsi,%rbp,4),%xmm1
ucomisd %xmm5,%xmm2
movapd %xmm4,%xmm0
jae    13ca <simplx+0x2aa>
movapd %xmm2,%xmm0
movss  %xmm1,0x30(%rsp)
call   1040 <sqrt@plt>
movss  0x30(%rsp),%xmm1
movsd  0x2c65(%rip),%xmm6
xorpd  %xmm5,%xmm5
movsd  0x20(%rsp),%xmm4
movsd  0x38(%rsp),%xmm3
movsd  0x28(%rsp),%xmm2
mov    (%rsp),%r11
mov    0x268(%rsp),%r10
mov    0x70(%rsp),%rsi
addsd  0x60(%rsp),%xmm0
cvtss2sd %xmm1,%xmm1
addsd  %xmm6,%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r12,%rbp,4)
movss  (%rsi,%rbp,4),%xmm1
ucomisd %xmm5,%xmm2
movapd %xmm4,%xmm0
jae    1350 <simplx+0x230>
movapd %xmm2,%xmm0
movss  %xmm1,0x30(%rsp)
call   1040 <sqrt@plt>
movss  0x30(%rsp),%xmm1
movsd  0x2bee(%rip),%xmm6
xorpd  %xmm5,%xmm5
movsd  0x20(%rsp),%xmm4
movsd  0x38(%rsp),%xmm3
movsd  0x28(%rsp),%xmm2
mov    (%rsp),%r11
mov    0x268(%rsp),%r10
mov    0x70(%rsp),%rsi
jmp    1350 <simplx+0x230>
movslq 0x270(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    %r14d,%eax
mov    %rax,0x38(%rsp)
mov    %r14d,0x4c(%rsp)
cmp    $0x2,%r14d
mov    %r15,0x78(%rsp)
jl     1719 <simplx+0x5f9>
mov    0x20(%rsp),%rcx
lea    (%rcx,%r11,1),%rax
mov    %rax,0x28(%rsp)
lea    (%r10,%r11,4),%rax
mov    %rax,0x30(%rsp)
lea    (%r15,%r11,4),%rax
mov    %rax,0x10(%rsp)
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,0xe0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
lea    0x2(%rax),%rsi
mov    %rdx,%rax
mov    %rdx,0x58(%rsp)
and    %rdx,%rsi
mov    %rsi,0xf0(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x60(%rsp)
lea    0x30(%r10),%rax
lea    0x0(,%rcx,4),%r9
lea    (%r10,%rcx,4),%rdx
add    $0x4,%rdx
mov    $0x1,%edi
xor    %r8d,%r8d
mov    %r9,%rcx
jmp    1534 <simplx+0x414>
xchg   %ax,%ax
movss  -0x4(%r12,%rdi,4),%xmm0
lea    (%r14,%rdi,1),%rsi
add    $0xffffffffffffffff,%rsi
addss  (%r10,%rsi,4),%xmm0
movss  %xmm0,(%r10,%rsi,4)
add    $0x1,%rdi
add    $0x1,%r8
add    %r9,%rcx
add    %r9,%rdx
cmp    0x38(%rsp),%rdi
je     1719 <simplx+0x5f9>
mov    %rdi,%r14
imul   0x20(%rsp),%r14
cmpl   $0x0,0xc(%rsp)
jle    1500 <simplx+0x3e0>
cmpl   $0x8,0xc(%rsp)
jae    15c0 <simplx+0x4a0>
xor    %esi,%esi
mov    %rsi,%rbp
test   $0x1,%r11b
je     1573 <simplx+0x453>
movss  (%r10,%rsi,4),%xmm0
addss  (%r15,%rsi,4),%xmm0
lea    (%rsi,%r14,1),%rbp
movss  %xmm0,(%r10,%rbp,4)
mov    %rsi,%rbp
or     $0x1,%rbp
not    %rsi
cmp    0x60(%rsp),%rsi
je     1500 <simplx+0x3e0>
nopl   (%rax)
movss  (%r10,%rbp,4),%xmm0
addss  (%r15,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rbp,4)
movss  0x4(%r10,%rbp,4),%xmm0
addss  0x4(%r15,%rbp,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%r11
jne    1580 <simplx+0x460>
jmp    1500 <simplx+0x3e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8,%rsi
mov    0x20(%rsp),%rbx
imul   %rbx,%rsi
mov    0x28(%rsp),%rbp
add    %rsi,%rbp
add    %rbx,%rsi
lea    (%r10,%rsi,4),%rsi
lea    (%r10,%rbp,4),%rbp
cmp    0x30(%rsp),%rsi
setb   %r13b
cmp    %r10,%rbp
mov    %r15,%r11
seta   %r15b
cmp    0x10(%rsp),%rsi
setb   %r10b
cmp    %r11,%rbp
seta   %r11b
test   %r15b,%r13b
jne    16a9 <simplx+0x589>
mov    $0x0,%esi
and    %r11b,%r10b
mov    0x78(%rsp),%r15
mov    0x268(%rsp),%r10
mov    (%rsp),%r11
jne    154d <simplx+0x42d>
cmpq   $0x0,0x40(%rsp)
je     16c1 <simplx+0x5a1>
lea    (%rax,%rcx,1),%r10
mov    0xf0(%rsp),%r11
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rax,%rbp,4),%xmm0
movups -0x20(%rax,%rbp,4),%xmm1
movups (%r15,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x30(%r10,%rbp,4)
movups %xmm0,-0x20(%r10,%rbp,4)
movups -0x10(%rax,%rbp,4),%xmm0
movups (%rax,%rbp,4),%xmm1
movups 0x20(%r15,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x30(%r15,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x10(%r10,%rbp,4)
movups %xmm0,(%r10,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%r11
jne    1650 <simplx+0x530>
jmp    16c3 <simplx+0x5a3>
xor    %esi,%esi
mov    0x78(%rsp),%r15
mov    0x268(%rsp),%r10
mov    (%rsp),%r11
jmp    154d <simplx+0x42d>
xor    %ebp,%ebp
testb  $0x1,0x58(%rsp)
mov    0x268(%rsp),%r10
je     16fc <simplx+0x5dc>
movups (%r10,%rbp,4),%xmm0
movups 0x10(%r10,%rbp,4),%xmm1
movups (%r15,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%rbp,4),%xmm0
addps  %xmm1,%xmm0
add    %r14,%rbp
movups %xmm2,(%r10,%rbp,4)
movups %xmm0,0x10(%r10,%rbp,4)
mov    0xe0(%rsp),%rbx
mov    %rbx,%rsi
mov    (%rsp),%r11
cmp    %r11,%rbx
je     1500 <simplx+0x3e0>
jmp    154d <simplx+0x42d>
cmpl   $0x0,0x4c(%rsp)
mov    0xc(%rsp),%ebx
jle    19a1 <simplx+0x881>
lea    (%r12,%r11,4),%rax
mov    %rax,0x30(%rsp)
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x10(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xe0(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x3,%edx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x110(%rsp)
mov    %r11d,%eax
and    $0x3,%eax
mov    %rax,0x28(%rsp)
lea    0x70(%r10),%r13
mov    0x20(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x60(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0xf0(%rsp)
lea    0x10(%r10),%r15
mov    %rdx,0x40(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x58(%rsp)
xor    %r14d,%r14d
mov    %r10,%rbp
jmp    1809 <simplx+0x6e9>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x260(%rsp),%rax
lea    (%rax,%r14,4),%rcx
mov    0x280(%rsp),%rdi
mov    %ebx,%esi
mov    %r12,%rdx
call   *0x278(%rsp)
mov    (%rsp),%r11
mov    0x268(%rsp),%r10
add    $0x1,%r14
mov    0x60(%rsp),%rax
add    %rax,%r13
add    %rax,%r15
add    %rax,%rbp
cmp    0x38(%rsp),%r14
je     19a1 <simplx+0x881>
test   %ebx,%ebx
jle    17c0 <simplx+0x6a0>
cmp    $0x8,%ebx
jb     1837 <simplx+0x717>
mov    %r14,%rax
imul   0x20(%rsp),%rax
lea    (%rax,%r11,1),%rcx
lea    (%r10,%rcx,4),%rcx
cmp    %r12,%rcx
jbe    18b1 <simplx+0x791>
lea    (%r10,%rax,4),%rax
cmp    0x30(%rsp),%rax
jae    18b1 <simplx+0x791>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    0x28(%rsp),%rdx
test   %rdx,%rdx
je     1866 <simplx+0x746>
nopl   0x0(%rax)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1850 <simplx+0x730>
cmp    $0x3,%rcx
jb     17c0 <simplx+0x6a0>
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%r12,%rax,4)
movss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,0x8(%r12,%rax,4)
movss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,0xc(%r12,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1870 <simplx+0x750>
jmp    17c0 <simplx+0x6a0>
cmpq   $0x18,0xe0(%rsp)
jae    18c8 <simplx+0x7a8>
xor    %eax,%eax
mov    0x58(%rsp),%rdi
jmp    1949 <simplx+0x829>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
mov    0x58(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movups -0x70(%r13,%rax,4),%xmm0
movups -0x60(%r13,%rax,4),%xmm1
movups %xmm0,(%r12,%rax,4)
movups %xmm1,0x10(%r12,%rax,4)
movups -0x50(%r13,%rax,4),%xmm0
movups -0x40(%r13,%rax,4),%xmm1
movups %xmm0,0x20(%r12,%rax,4)
movups %xmm1,0x30(%r12,%rax,4)
movups -0x30(%r13,%rax,4),%xmm0
movups -0x20(%r13,%rax,4),%xmm1
movups %xmm0,0x40(%r12,%rax,4)
movups %xmm1,0x50(%r12,%rax,4)
movups -0x10(%r13,%rax,4),%xmm0
movups 0x0(%r13,%rax,4),%xmm1
movups %xmm0,0x60(%r12,%rax,4)
movups %xmm1,0x70(%r12,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    18e0 <simplx+0x7c0>
cmpq   $0x0,0x40(%rsp)
je     198b <simplx+0x86b>
mov    0xf0(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
lea    (%r15,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1970 <simplx+0x850>
mov    0x10(%rsp),%rcx
mov    %rcx,%rax
cmp    %r11,%rcx
je     17c0 <simplx+0x6a0>
jmp    1839 <simplx+0x719>
mov    0x78(%rsp),%r15
lea    (%r15,%r11,4),%r8
lea    (%r12,%r11,4),%rcx
mov    0x38(%rsp),%r13
lea    -0x1(%r13),%rdi
mov    %r11d,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc0(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r11d,%esi
and    $0xfffffff8,%esi
mov    %rsi,0x98(%rsp)
add    $0xfffffffffffffff8,%rsi
mov    %rsi,0xc8(%rsp)
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdi,%rsi
mov    %rdi,0x28(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x188(%rsp)
mov    %r13d,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x60(%rsp)
mov    %rcx,0x140(%rsp)
cmp    %r15,%rcx
seta   %cl
cmp    %r12,%r8
seta   %al
and    %cl,%al
mov    %al,0x1f(%rsp)
mov    %rbp,%rcx
mov    %rbp,0xb0(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xa8(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x40(%rsp)
mov    0x250(%rsp),%r9
cmp    %r9,%r8
seta   %cl
lea    (%r9,%r11,4),%rdi
cmp    %r15,%rdi
seta   %al
and    %cl,%al
mov    %al,0x1d(%rsp)
mov    %edx,%ebp
and    $0x3,%ebp
mov    %rdx,%rcx
mov    %rdx,0x108(%rsp)
and    %rdx,0x88(%rsp)
mov    %r11d,%eax
and    $0x3,%eax
mov    %rax,0xd0(%rsp)
mov    0x258(%rsp),%rsi
cmp    %rsi,%r8
seta   %al
lea    (%rsi,%r11,4),%rdx
cmp    %r15,%rdx
seta   %cl
and    %al,%cl
mov    %rdi,0x118(%rsp)
cmp    %rsi,%rdi
seta   %al
mov    %rdx,0x138(%rsp)
cmp    %r9,%rdx
seta   %dl
and    %al,%dl
cvtsi2ss %ebx,%xmm0
mov    0x4c(%rsp),%r14d
cvtsi2ss %r14d,%xmm1
movaps %xmm0,0x1e0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x200(%rsp)
movaps %xmm1,0x150(%rsp)
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0x1f0(%rsp)
mov    %cl,0x1c(%rsp)
or     %cl,%dl
mov    %dl,0x1e(%rsp)
mov    %r13d,%eax
and    $0x7,%eax
mov    %rax,0x1b8(%rsp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x1b0(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x1a8(%rsp)
mov    %r13d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x180(%rsp)
mov    %rbp,0x168(%rsp)
shl    $0x5,%rbp
mov    %rbp,0x90(%rsp)
lea    0x0(,%r11,4),%rax
mov    %rax,0x148(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0x1c0(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x110(%rsp)
movslq %r14d,%rax
mov    %rax,0x1a0(%rsp)
mov    0x70(%rsp),%rax
lea    (%rax,%r11,4),%rcx
mov    %rcx,0x198(%rsp)
lea    (%r10,%r11,4),%rcx
mov    %rcx,0x68(%rsp)
mov    %r9,%rdx
mov    0x20(%rsp),%rcx
lea    0x0(,%rcx,8),%r13
lea    0x10(%r10),%rdi
mov    %rdi,0x50(%rsp)
lea    0x4(%r10),%rdi
mov    %rdi,0x120(%rsp)
lea    0x70(%r10),%rdi
mov    %rdi,0xa0(%rsp)
lea    0x10(%rdx),%rdi
mov    %rdi,0x130(%rsp)
lea    0xc(%r10),%rdi
mov    %rdi,0x100(%rsp)
lea    0x0(,%rcx,4),%rcx
mov    %rcx,0x30(%rsp)
lea    0x10(%r12),%rcx
mov    %rcx,0x190(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0x170(%rsp)
add    $0x10,%rax
mov    %rax,0x178(%rsp)
movl   $0x0,0xdc(%rsp)
mov    %ebx,%r8d
mov    0x260(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rbx),%xmm5
test   %r14d,%r14d
mov    0x10(%rsp),%ebp
mov    0x58(%rsp),%edi
jle    1c90 <simplx+0xb70>
ucomiss %xmm5,%xmm5
mov    $0x0,%eax
cmovnp %eax,%ebp
cmovnp %eax,%edi
cmp    $0x1,%r14d
je     1c90 <simplx+0xb70>
mov    $0x1,%eax
cmp    $0x2,%r14d
jne    1ca0 <simplx+0xb80>
movaps %xmm5,%xmm4
jmp    1d30 <simplx+0xc10>
nopl   0x0(%rax,%rax,1)
movaps %xmm5,%xmm4
jmp    1d76 <simplx+0xc56>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
movaps %xmm5,%xmm4
mov    0x188(%rsp),%rsi
movss  (%rbx,%rax,4),%xmm1
movss  0x4(%rbx,%rax,4),%xmm0
ucomiss %xmm4,%xmm1
movaps %xmm4,%xmm2
cmpnless %xmm1,%xmm2
movaps %xmm2,%xmm3
andnps %xmm1,%xmm3
andps  %xmm4,%xmm2
cmovae %eax,%ebp
orps   %xmm3,%xmm2
ucomiss %xmm1,%xmm5
movaps %xmm1,%xmm3
cmpnless %xmm5,%xmm3
movaps %xmm3,%xmm4
andnps %xmm1,%xmm4
andps  %xmm5,%xmm3
cmovae %eax,%edi
orps   %xmm4,%xmm3
lea    0x1(%rax),%rcx
ucomiss %xmm2,%xmm0
movaps %xmm2,%xmm4
cmpnless %xmm0,%xmm4
movaps %xmm4,%xmm1
andps  %xmm2,%xmm1
andnps %xmm0,%xmm4
orps   %xmm1,%xmm4
cmovae %ecx,%ebp
ucomiss %xmm0,%xmm3
movaps %xmm0,%xmm5
cmpnless %xmm3,%xmm5
movaps %xmm5,%xmm1
andps  %xmm3,%xmm1
andnps %xmm0,%xmm5
orps   %xmm1,%xmm5
cmovae %ecx,%edi
add    $0x2,%rax
cmp    %rsi,%rcx
jne    1cb0 <simplx+0xb90>
testb  $0x1,0x28(%rsp)
je     1d76 <simplx+0xc56>
movss  (%rbx,%rax,4),%xmm0
ucomiss %xmm4,%xmm0
movaps %xmm4,%xmm1
cmpnless %xmm0,%xmm1
movaps %xmm1,%xmm2
andnps %xmm0,%xmm2
andps  %xmm4,%xmm1
orps   %xmm2,%xmm1
cmovae %eax,%ebp
ucomiss %xmm0,%xmm5
movaps %xmm0,%xmm2
cmpnless %xmm5,%xmm2
movaps %xmm2,%xmm3
andnps %xmm0,%xmm3
andps  %xmm5,%xmm2
orps   %xmm3,%xmm2
cmovae %eax,%edi
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movaps %xmm5,0xe0(%rsp)
mov    %edi,0x58(%rsp)
test   %r8d,%r8d
mov    %ebp,0x10(%rsp)
movaps %xmm4,0xf0(%rsp)
jle    21b0 <simplx+0x1090>
mov    %r12,%rdi
xor    %esi,%esi
mov    0x148(%rsp),%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%rbx
mov    (%rsp),%r10
mov    0x268(%rsp),%r9
mov    0xc(%rsp),%r8d
mov    %ebp,%eax
mov    %r9,%rcx
xor    %edx,%edx
mov    0x38(%rsp),%r11
jmp    1de1 <simplx+0xcc1>
nopl   (%rax)
add    $0x1,%rdx
add    $0x4,%rcx
cmp    %r10,%rdx
je     1ea0 <simplx+0xd80>
test   %r14d,%r14d
jle    1dd0 <simplx+0xcb0>
cmpq   $0x0,0x28(%rsp)
je     1e60 <simplx+0xd40>
mov    %rcx,%rdi
xor    %esi,%esi
jmp    1e0e <simplx+0xcee>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r13,%rdi
add    $0x1,%rsi
cmp    0x60(%rsp),%rsi
je     1e50 <simplx+0xd30>
mov    %rsi,%rbp
cmp    %rsi,%rax
je     1e26 <simplx+0xd06>
movss  (%rdi),%xmm0
addss  (%r12,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
lea    0x1(%rbp),%rsi
cmp    %rax,%rsi
je     1e00 <simplx+0xce0>
movss  (%rdi,%rbx,4),%xmm0
addss  (%r12,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
jmp    1e00 <simplx+0xce0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rbp
test   $0x1,%r11b
jne    1e6c <simplx+0xd4c>
jmp    1dd0 <simplx+0xcb0>
nop
xor    %ebp,%ebp
test   $0x1,%r11b
je     1dd0 <simplx+0xcb0>
cmp    %rax,%rbp
je     1dd0 <simplx+0xcb0>
imul   %rbx,%rbp
add    %rdx,%rbp
movss  (%r9,%rbp,4),%xmm0
addss  (%r12,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
jmp    1dd0 <simplx+0xcb0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r8d,%r8d
mov    0x250(%rsp),%rdx
movaps 0x200(%rsp),%xmm2
mov    0x10(%rsp),%esi
jle    21b0 <simplx+0x1090>
cmp    $0x4,%r8d
setb   %al
or     0x1f(%rsp),%al
je     1ed6 <simplx+0xdb6>
xor    %ecx,%ecx
movaps 0x1e0(%rsp),%xmm1
jmp    1f4d <simplx+0xe2d>
cmpq   $0x0,0xb8(%rsp)
movaps 0x1e0(%rsp),%xmm1
je     20a9 <simplx+0xf89>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%r12,%rax,4),%xmm0
divps  %xmm2,%xmm0
movups %xmm0,(%r15,%rax,4)
movups 0x10(%r12,%rax,4),%xmm0
divps  %xmm2,%xmm0
movups %xmm0,0x10(%r15,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f00 <simplx+0xde0>
testb  $0x1,0xb0(%rsp)
01
je     1f3d <simplx+0xe1d>
movups (%r12,%rax,4),%xmm0
divps  %xmm2,%xmm0
movups %xmm0,(%r15,%rax,4)
mov    0xc0(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     1fab <simplx+0xe8b>
mov    %rcx,%rax
test   $0x1,%r10b
je     1f6d <simplx+0xe4d>
movss  (%r12,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r15,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     1fab <simplx+0xe8b>
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  0x4(%r12,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%r15,%rax,4)
add    $0x2,%rax
cmp    %rax,%r10
jne    1f80 <simplx+0xe60>
test   %r8d,%r8d
jle    21b0 <simplx+0x1090>
mov    %esi,%eax
imul   0x270(%rsp),%eax
cltq
cmp    $0x4,%r8d
jb     1ff0 <simplx+0xed0>
lea    (%r9,%rax,4),%rcx
mov    0x68(%rsp),%rsi
lea    (%rsi,%rax,4),%rsi
cmp    %rdx,%rsi
seta   %bl
cmp    0x118(%rsp),%rcx
setb   %cl
and    %bl,%cl
or     0x1d(%rsp),%cl
je     20be <simplx+0xf9e>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%r10b
je     202b <simplx+0xf0b>
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    (%rsi,%rax,1),%rcx
movss  (%r9,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x40(%rsp),%rsi
je     21b0 <simplx+0x1090>
mov    0x120(%rsp),%rsi
lea    (%rsi,%rax,4),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    2050 <simplx+0xf30>
jmp    21b0 <simplx+0x1090>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    1f30 <simplx+0xe10>
jmp    1f3d <simplx+0xe1d>
cmpq   $0x0,0xb8(%rsp)
je     2750 <simplx+0x1630>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
cvtps2pd 0x8(%r15,%rcx,4),%xmm0
cvtps2pd (%r15,%rcx,4),%xmm1
cvtps2pd -0x8(%rdi,%rcx,4),%xmm2
cvtps2pd -0x10(%rdi,%rcx,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,4)
cvtps2pd 0x18(%r15,%rcx,4),%xmm0
cvtps2pd 0x10(%r15,%rcx,4),%xmm1
cvtps2pd 0x8(%rdi,%rcx,4),%xmm2
cvtps2pd (%rdi,%rcx,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rdx,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    20e0 <simplx+0xfc0>
testb  $0x1,0xb0(%rsp)
01
je     219c <simplx+0x107c>
cvtps2pd 0x8(%r15,%rcx,4),%xmm0
cvtps2pd (%r15,%rcx,4),%xmm1
lea    (%rcx,%rax,1),%rsi
cvtps2pd 0x8(%r9,%rsi,4),%xmm2
cvtps2pd (%r9,%rsi,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,4)
mov    0xc0(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r10,%rcx
jne    1ff2 <simplx+0xed2>
mov    0x280(%rsp),%rdi
mov    %r8d,%esi
lea    0x84(%rsp),%rcx
mov    %r8d,%ebp
call   *0x278(%rsp)
movss  0x84(%rsp),%xmm0
movaps 0xe0(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jbe    2220 <simplx+0x1100>
test   %ebp,%ebp
mov    %ebp,%esi
mov    (%rsp),%rdi
mov    0x258(%rsp),%rdx
mov    0x250(%rsp),%rbp
jle    2505 <simplx+0x13e5>
cmp    $0x4,%esi
setb   %al
or     0x1e(%rsp),%al
je     237d <simplx+0x125d>
xor    %ecx,%ecx
jmp    246c <simplx+0x134c>
nopl   0x0(%rax,%rax,1)
test   %r14d,%r14d
mov    %ebp,%r8d
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%rbx
movsd  0x1dd2(%rip),%xmm4
movapd 0x1dda(%rip),%xmm5
mov    0x1a0(%rsp),%rsi
mov    0x10(%rsp),%eax
movaps 0xf0(%rsp),%xmm2
jle    2290 <simplx+0x1170>
test   %eax,%eax
je     2290 <simplx+0x1170>
mov    %eax,%eax
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rcx,4),%xmm1
ucomiss %xmm0,%xmm1
ja     254c <simplx+0x142c>
cmp    %rsi,%rcx
jge    2290 <simplx+0x1170>
lea    0x1(%rcx),%rdx
cmp    %rcx,%rax
mov    %rdx,%rcx
jne    2270 <simplx+0x1150>
ucomiss %xmm0,%xmm2
mov    (%rsp),%r11
mov    0x258(%rsp),%rdx
mov    0x250(%rsp),%rbp
jb     284c <simplx+0x172c>
test   %r8d,%r8d
jle    283f <simplx+0x171f>
mov    0x10(%rsp),%eax
imul   0x270(%rsp),%eax
movslq %eax,%r10
cmp    $0x8,%r8d
jb     22ef <simplx+0x11cf>
lea    (%r9,%r10,4),%rcx
cmp    0x118(%rsp),%rcx
jae    273e <simplx+0x161e>
mov    0x68(%rsp),%rax
lea    (%rax,%r10,4),%rcx
cmp    %rbp,%rcx
jbe    273e <simplx+0x161e>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r11,%rax
mov    0xd0(%rsp),%rdi
test   %rdi,%rdi
je     2325 <simplx+0x1205>
lea    (%r9,%r10,4),%rsi
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    2310 <simplx+0x11f0>
cmp    $0x3,%rax
jb     283f <simplx+0x171f>
mov    0x100(%rsp),%rax
lea    (%rax,%r10,4),%rax
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0xc(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0x8(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0x4(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    2340 <simplx+0x1220>
jmp    283f <simplx+0x171f>
cmpq   $0x0,0xb8(%rsp)
je     263f <simplx+0x151f>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
cvtps2pd 0x8(%rbp,%rax,4),%xmm0
cvtps2pd 0x0(%rbp,%rax,4),%xmm1
cvtps2pd 0x8(%r15,%rax,4),%xmm2
cvtps2pd (%r15,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rax,4)
cvtps2pd 0x18(%rbp,%rax,4),%xmm0
cvtps2pd 0x10(%rbp,%rax,4),%xmm1
cvtps2pd 0x18(%r15,%rax,4),%xmm2
cvtps2pd 0x10(%r15,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    23a0 <simplx+0x1280>
testb  $0x1,0xb0(%rsp)
01
je     2458 <simplx+0x1338>
cvtps2pd 0x8(%rbp,%rax,4),%xmm0
cvtps2pd 0x0(%rbp,%rax,4),%xmm1
cvtps2pd 0x8(%r15,%rax,4),%xmm2
cvtps2pd (%r15,%rax,4),%xmm3
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rax,4)
mov    0xc0(%rsp),%rax
mov    %rax,%rcx
cmp    %rdi,%rax
je     2505 <simplx+0x13e5>
mov    %rcx,%rax
test   $0x1,%dil
je     24a1 <simplx+0x1381>
movss  0x0(%rbp,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r15,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     2505 <simplx+0x13e5>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r15,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%r15,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdi
jne    24b0 <simplx+0x1390>
mov    0x280(%rsp),%rdi
lea    0x80(%rsp),%rcx
call   *0x278(%rsp)
mov    0xc(%rsp),%r8d
movss  0x80(%rsp),%xmm0
ucomiss 0xe0(%rsp),%xmm0
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%rbx
mov    0x10(%rsp),%ebp
jb     2bb0 <simplx+0x1a90>
test   %r8d,%r8d
mov    (%rsp),%r10
mov    0x250(%rsp),%rbp
mov    0xd0(%rsp),%r11
jle    2730 <simplx+0x1610>
mov    0x10(%rsp),%eax
imul   0x270(%rsp),%eax
cltq
cmp    $0x8,%r8d
jb     25a1 <simplx+0x1481>
lea    (%r9,%rax,4),%rcx
cmp    0x118(%rsp),%rcx
jae    262d <simplx+0x150d>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
cmp    %rbp,%rcx
jbe    262d <simplx+0x150d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r10,%rdx
test   $0x3,%r10b
je     25d5 <simplx+0x14b5>
lea    (%r9,%rax,4),%rsi
mov    %r11,%rdi
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    25c0 <simplx+0x14a0>
cmp    $0x3,%rdx
jb     2730 <simplx+0x1610>
mov    0x100(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    25f0 <simplx+0x14d0>
jmp    2730 <simplx+0x1610>
cmpq   $0x18,0xc8(%rsp)
jae    2654 <simplx+0x1534>
xor    %ecx,%ecx
jmp    26c9 <simplx+0x15a9>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    2422 <simplx+0x1302>
jmp    2458 <simplx+0x1338>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
mov    0x88(%rsp),%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,4)
movups %xmm1,-0x60(%rdx,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm0
movups 0x30(%rbp,%rcx,4),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,4)
movups %xmm1,-0x40(%rdx,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm0
movups 0x50(%rbp,%rcx,4),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,4)
movups %xmm1,-0x20(%rdx,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm0
movups 0x70(%rbp,%rcx,4),%xmm1
movups %xmm0,-0x10(%rdx,%rcx,4)
movups %xmm1,(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    2670 <simplx+0x1550>
testb  $0x3,0x108(%rsp)
03
mov    0x90(%rsp),%rdi
je     271b <simplx+0x15fb>
lea    (%rcx,%rax,1),%rdx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    0x130(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    2700 <simplx+0x15e0>
mov    0x98(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r10,%rdx
jne    25a3 <simplx+0x1483>
nop
movss  0x84(%rsp),%xmm0
jmp    32f0 <simplx+0x21d0>
cmpq   $0x18,0xc8(%rsp)
jae    2765 <simplx+0x1645>
xor    %ecx,%ecx
jmp    27d9 <simplx+0x16b9>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    2161 <simplx+0x1041>
jmp    219c <simplx+0x107c>
mov    0xa0(%rsp),%rax
lea    (%rax,%r10,4),%rax
mov    0x88(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,4),%xmm1
movups 0x10(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x70(%rax,%rcx,4)
movups %xmm2,-0x60(%rax,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm1
movups 0x30(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x50(%rax,%rcx,4)
movups %xmm2,-0x40(%rax,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm1
movups 0x50(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x30(%rax,%rcx,4)
movups %xmm2,-0x20(%rax,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm1
movups 0x70(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x10(%rax,%rcx,4)
movups %xmm2,(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    2780 <simplx+0x1660>
cmpq   $0x0,0x168(%rsp)
mov    0x90(%rsp),%rdi
je     282b <simplx+0x170b>
lea    (%rcx,%r10,1),%rax
mov    0x50(%rsp),%rsi
lea    (%rsi,%rax,4),%rax
mov    0x130(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm1
movups (%rcx,%rsi,1),%xmm2
movups %xmm1,-0x10(%rax,%rsi,1)
movups %xmm2,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    2810 <simplx+0x16f0>
mov    0x98(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
jne    22f1 <simplx+0x11d1>
movslq 0x10(%rsp),%rax
movss  %xmm0,(%rbx,%rax,4)
movaps %xmm0,%xmm2
movaps %xmm2,0xf0(%rsp)
test   %r8d,%r8d
mov    0x10(%rsp),%ebp
jle    2a80 <simplx+0x1960>
mov    %ebp,%eax
imul   0x270(%rsp),%eax
cltq
cmp    $0x4,%r8d
jb     289d <simplx+0x177d>
lea    (%r9,%rax,4),%rcx
mov    0x68(%rsp),%rsi
lea    (%rsi,%rax,4),%rsi
cmp    %rdx,%rsi
seta   %bl
cmp    0x138(%rsp),%rcx
setb   %cl
and    %bl,%cl
or     0x1c(%rsp),%cl
je     2961 <simplx+0x1841>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%r11b
je     28dc <simplx+0x17bc>
lea    (%rsi,%rax,1),%rcx
movss  (%r9,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r15,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x40(%rsp),%rsi
je     2a80 <simplx+0x1960>
mov    0x120(%rsp),%rsi
lea    (%rsi,%rax,4),%rax
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r15,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%r15,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    2900 <simplx+0x17e0>
jmp    2a80 <simplx+0x1960>
cmpq   $0x0,0xb8(%rsp)
je     36e1 <simplx+0x25c1>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtps2pd -0x8(%rdi,%rcx,4),%xmm0
cvtps2pd -0x10(%rdi,%rcx,4),%xmm1
cvtps2pd (%r15,%rcx,4),%xmm2
cvtps2pd 0x8(%r15,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,4)
cvtps2pd 0x8(%rdi,%rcx,4),%xmm0
cvtps2pd (%rdi,%rcx,4),%xmm1
cvtps2pd 0x10(%r15,%rcx,4),%xmm2
cvtps2pd 0x18(%r15,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rdx,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2990 <simplx+0x1870>
testb  $0x1,0xb0(%rsp)
01
je     2a68 <simplx+0x1948>
lea    (%rcx,%rax,1),%rsi
cvtps2pd 0x8(%r9,%rsi,4),%xmm0
cvtps2pd (%r9,%rsi,4),%xmm1
cvtps2pd (%r15,%rcx,4),%xmm2
cvtps2pd 0x8(%r15,%rcx,4),%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,4)
mov    0xc0(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r11,%rcx
jne    289f <simplx+0x177f>
nopl   0x0(%rax)
mov    0x280(%rsp),%rdi
mov    %r8d,%esi
lea    0x80(%rsp),%rcx
call   *0x278(%rsp)
mov    0x268(%rsp),%r9
mov    0xc(%rsp),%r8d
movss  0x80(%rsp),%xmm0
movss  0x84(%rsp),%xmm1
minss  0xf0(%rsp),%xmm1
ucomiss %xmm1,%xmm0
mov    0x260(%rsp),%rbx
jbe    2bb0 <simplx+0x1a90>
test   %r8d,%r8d
mov    (%rsp),%r10
mov    0x250(%rsp),%rdx
jle    2d79 <simplx+0x1c59>
mov    %r12,%rdi
xor    %esi,%esi
mov    0x148(%rsp),%rdx
call   1030 <memset@plt>
mov    0x38(%rsp),%rbp
mov    0x20(%rsp),%rdi
mov    (%rsp),%r10
mov    0x268(%rsp),%r9
mov    0xc(%rsp),%r8d
mov    %r9,%rax
xor    %ecx,%ecx
mov    0x60(%rsp),%rbx
jmp    2b41 <simplx+0x1a21>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x4,%rax
cmp    %r10,%rcx
je     2c96 <simplx+0x1b76>
test   %r14d,%r14d
jle    2b30 <simplx+0x1a10>
movss  (%r12,%rcx,4),%xmm0
cmpq   $0x0,0x28(%rsp)
je     2b90 <simplx+0x1a70>
mov    %rax,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
addss  (%rsi),%xmm0
movss  %xmm0,(%r12,%rcx,4)
addss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
add    $0x2,%rdx
add    %r13,%rsi
cmp    %rdx,%rbx
jne    2b60 <simplx+0x1a40>
test   $0x1,%bpl
je     2b30 <simplx+0x1a10>
jmp    2b98 <simplx+0x1a78>
nopl   0x0(%rax)
xor    %edx,%edx
test   $0x1,%bpl
je     2b30 <simplx+0x1a10>
imul   %rdi,%rdx
add    %rcx,%rdx
addss  (%r9,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
jmp    2b30 <simplx+0x1a10>
nopl   (%rax)
test   %r8d,%r8d
jle    2c8d <simplx+0x1b6d>
mov    %ebp,%eax
imul   0x270(%rsp),%eax
cltq
cmp    $0x8,%r8d
mov    (%rsp),%r10
mov    0x258(%rsp),%rbp
mov    0xd0(%rsp),%r11
jb     2c03 <simplx+0x1ae3>
lea    (%r9,%rax,4),%rcx
cmp    0x138(%rsp),%rcx
jae    2ccc <simplx+0x1bac>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
cmp    %rbp,%rcx
jbe    2ccc <simplx+0x1bac>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r10,%rdx
test   $0x3,%r10b
je     2c35 <simplx+0x1b15>
lea    (%r9,%rax,4),%rsi
mov    %r11,%rdi
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    2c20 <simplx+0x1b00>
cmp    $0x3,%rdx
jb     32f0 <simplx+0x21d0>
mov    0x100(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0xc(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0x8(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm1
movss  %xmm1,-0x4(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    2c50 <simplx+0x1b30>
jmp    32f0 <simplx+0x21d0>
mov    (%rsp),%r10
jmp    32f4 <simplx+0x21d4>
test   %r8d,%r8d
mov    0x260(%rsp),%rbx
mov    0x250(%rsp),%rdx
movaps 0x150(%rsp),%xmm1
movaps 0x1f0(%rsp),%xmm2
jle    2d79 <simplx+0x1c59>
cmp    $0x4,%r8d
jae    2ce2 <simplx+0x1bc2>
xor    %eax,%eax
jmp    2d60 <simplx+0x1c40>
cmpq   $0x18,0xc8(%rsp)
jae    3217 <simplx+0x20f7>
xor    %ecx,%ecx
jmp    3289 <simplx+0x2169>
cmpq   $0x0,0xb8(%rsp)
je     36f6 <simplx+0x25d6>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%r12,%rax,4),%xmm0
movups 0x10(%r12,%rax,4),%xmm1
divps  %xmm2,%xmm0
movups %xmm0,(%r12,%rax,4)
divps  %xmm2,%xmm1
movups %xmm1,0x10(%r12,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2d00 <simplx+0x1be0>
testb  $0x1,0xb0(%rsp)
01
je     2d3d <simplx+0x1c1d>
movups (%r12,%rax,4),%xmm0
divps  %xmm2,%xmm0
movups %xmm0,(%r12,%rax,4)
mov    0xc0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
movaps 0x150(%rsp),%xmm1
je     2d79 <simplx+0x1c59>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    2d60 <simplx+0x1c40>
xorps  %xmm0,%xmm0
test   %r14d,%r14d
jle    3204 <simplx+0x20e4>
mov    0x58(%rsp),%eax
imul   0x270(%rsp),%eax
movslq %eax,%rsi
lea    (%r9,%rsi,4),%rax
mov    %rax,0xf0(%rsp)
mov    0x68(%rsp),%rax
lea    (%rax,%rsi,4),%rax
mov    %rax,0x1d8(%rsp)
mov    0x50(%rsp),%rdx
lea    (%rdx,%rsi,4),%r10
mov    0x120(%rsp),%rcx
mov    %rsi,0x1d0(%rsp)
lea    (%rcx,%rsi,4),%rdi
xor    %r14d,%r14d
mov    0x140(%rsp),%rbx
movapd 0xe0(%rsp),%xmm4
jmp    2e0a <simplx+0x1cea>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
mov    0x30(%rsp),%rax
add    %rax,%rdx
add    %rax,%rcx
cmp    0x38(%rsp),%r14
je     2fab <simplx+0x1e8b>
test   %r8d,%r8d
jle    2df0 <simplx+0x1cd0>
mov    %r14,%r11
imul   0x20(%rsp),%r11
cmp    $0x8,%r8d
jae    2ed0 <simplx+0x1db0>
xor    %eax,%eax
mov    (%rsp),%rsi
mov    %rax,%rbp
test   $0x1,%sil
je     2e6a <simplx+0x1d4a>
movss  (%r12,%rax,4),%xmm1
mov    0x1d0(%rsp),%rsi
lea    (%rax,%rsi,1),%rbp
mov    0x268(%rsp),%rsi
addss  (%rsi,%rbp,4),%xmm1
add    %rax,%r11
movss  (%rsi,%r11,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%r11,4)
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    0x40(%rsp),%rax
mov    (%rsp),%rax
je     2df0 <simplx+0x1cd0>
nopl   0x0(%rax)
movss  (%r12,%rbp,4),%xmm1
addss  -0x4(%rdi,%rbp,4),%xmm1
movss  -0x4(%rcx,%rbp,4),%xmm2
subss  %xmm1,%xmm2
movss  (%rcx,%rbp,4),%xmm1
movss  %xmm2,-0x4(%rcx,%rbp,4)
movss  0x4(%r12,%rbp,4),%xmm2
addss  (%rdi,%rbp,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    2e80 <simplx+0x1d60>
jmp    2df0 <simplx+0x1cd0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%rax
add    %r11,%rax
mov    0x268(%rsp),%rsi
lea    (%rsi,%r11,4),%rbp
lea    (%rsi,%rax,4),%rax
cmp    %rbx,%rbp
setb   %r8b
cmp    %r12,%rax
seta   %r9b
cmp    0x1d8(%rsp),%rbp
setb   %bpl
cmp    %rax,0xf0(%rsp)
setb   %r15b
test   %r9b,%r8b
jne    2f9a <simplx+0x1e7a>
mov    $0x0,%eax
and    %r15b,%bpl
mov    0x78(%rsp),%r15
mov    0xc(%rsp),%r8d
mov    (%rsp),%rsi
jne    2e28 <simplx+0x1d08>
xor    %eax,%eax
mov    0x1c0(%rsp),%rsi
nopl   0x0(%rax)
movups (%r12,%rax,1),%xmm1
movups 0x10(%r12,%rax,1),%xmm2
movups -0x10(%r10,%rax,1),%xmm3
addps  %xmm1,%xmm3
movups (%r10,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups -0x10(%rdx,%rax,1),%xmm2
subps  %xmm3,%xmm2
movups (%rdx,%rax,1),%xmm3
subps  %xmm1,%xmm3
movups %xmm2,-0x10(%rdx,%rax,1)
movups %xmm3,(%rdx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rsi
jne    2f40 <simplx+0x1e20>
mov    0x98(%rsp),%rbp
mov    %rbp,%rax
mov    (%rsp),%rsi
cmp    %rsi,%rbp
je     2df0 <simplx+0x1cd0>
jmp    2e28 <simplx+0x1d08>
xor    %eax,%eax
mov    0x78(%rsp),%r15
mov    0xc(%rsp),%r8d
jmp    2e24 <simplx+0x1d04>
mov    0x4c(%rsp),%r14d
test   %r14d,%r14d
mov    0x70(%rsp),%rbp
mov    0x268(%rsp),%r9
mov    (%rsp),%r10
mov    0x20(%rsp),%rcx
mov    0x260(%rsp),%rbx
mov    0x250(%rsp),%rdx
jle    34aa <simplx+0x238a>
mov    %r9,%r14
mov    0x50(%rsp),%rdi
mov    0xa0(%rsp),%r15
xor    %ebp,%ebp
jmp    305a <simplx+0x1f3a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%rbp,4),%rcx
mov    %rdi,%rbx
mov    0x280(%rsp),%rdi
mov    %r8d,%esi
mov    %r12,%rdx
call   *0x278(%rsp)
mov    %rbx,%rdi
mov    0x260(%rsp),%rbx
mov    0x20(%rsp),%rcx
mov    (%rsp),%r10
mov    0x268(%rsp),%r9
mov    0xc(%rsp),%r8d
add    $0x1,%rbp
mov    0x30(%rsp),%rax
add    %rax,%r15
add    %rax,%rdi
add    %rax,%r14
cmp    0x38(%rsp),%rbp
je     32fc <simplx+0x21dc>
test   %r8d,%r8d
jle    3000 <simplx+0x1ee0>
cmp    $0x8,%r8d
jb     308f <simplx+0x1f6f>
mov    %rbp,%rax
imul   %rcx,%rax
lea    (%rax,%r10,1),%rcx
lea    (%r9,%rcx,4),%rcx
cmp    %r12,%rcx
jbe    3114 <simplx+0x1ff4>
lea    (%r9,%rax,4),%rax
cmp    0x140(%rsp),%rax
jae    3114 <simplx+0x1ff4>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r10,%rcx
test   $0x3,%r10b
je     30c6 <simplx+0x1fa6>
mov    0xd0(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    30b0 <simplx+0x1f90>
cmp    $0x3,%rcx
jb     3000 <simplx+0x1ee0>
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
movss  %xmm0,0x4(%r12,%rax,4)
movss  0x8(%r14,%rax,4),%xmm0
movss  %xmm0,0x8(%r12,%rax,4)
movss  0xc(%r14,%rax,4),%xmm0
movss  %xmm0,0xc(%r12,%rax,4)
add    $0x4,%rax
cmp    %rax,%r10
jne    30d0 <simplx+0x1fb0>
jmp    3000 <simplx+0x1ee0>
cmpq   $0x18,0xc8(%rsp)
jae    312e <simplx+0x200e>
xor    %eax,%eax
mov    0x90(%rsp),%rsi
jmp    31a8 <simplx+0x2088>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
mov    0x90(%rsp),%rsi
movups -0x70(%r15,%rax,4),%xmm0
movups -0x60(%r15,%rax,4),%xmm1
movups %xmm0,(%r12,%rax,4)
movups %xmm1,0x10(%r12,%rax,4)
movups -0x50(%r15,%rax,4),%xmm0
movups -0x40(%r15,%rax,4),%xmm1
movups %xmm0,0x20(%r12,%rax,4)
movups %xmm1,0x30(%r12,%rax,4)
movups -0x30(%r15,%rax,4),%xmm0
movups -0x20(%r15,%rax,4),%xmm1
movups %xmm0,0x40(%r12,%rax,4)
movups %xmm1,0x50(%r12,%rax,4)
movups -0x10(%r15,%rax,4),%xmm0
movups (%r15,%rax,4),%xmm1
movups %xmm0,0x60(%r12,%rax,4)
movups %xmm1,0x70(%r12,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    3140 <simplx+0x2020>
testb  $0x3,0x108(%rsp)
03
je     31eb <simplx+0x20cb>
mov    0x190(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
lea    (%rdi,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    31d0 <simplx+0x20b0>
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
je     3000 <simplx+0x1ee0>
jmp    3091 <simplx+0x1f71>
mov    0x70(%rsp),%rbp
movapd 0xe0(%rsp),%xmm4
jmp    34aa <simplx+0x238a>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
mov    0x88(%rsp),%rsi
xor    %ecx,%ecx
nopl   (%rax)
movups 0x0(%rbp,%rcx,4),%xmm1
movups 0x10(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x70(%rdx,%rcx,4)
movups %xmm2,-0x60(%rdx,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm1
movups 0x30(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x50(%rdx,%rcx,4)
movups %xmm2,-0x40(%rdx,%rcx,4)
movups 0x40(%rbp,%rcx,4),%xmm1
movups 0x50(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x30(%rdx,%rcx,4)
movups %xmm2,-0x20(%rdx,%rcx,4)
movups 0x60(%rbp,%rcx,4),%xmm1
movups 0x70(%rbp,%rcx,4),%xmm2
movups %xmm1,-0x10(%rdx,%rcx,4)
movups %xmm2,(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    3230 <simplx+0x2110>
testb  $0x3,0x108(%rsp)
03
mov    0x90(%rsp),%rdi
je     32db <simplx+0x21bb>
lea    (%rcx,%rax,1),%rdx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    0x170(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm1
movups (%rcx,%rsi,1),%xmm2
movups %xmm1,-0x10(%rdx,%rsi,1)
movups %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    32c0 <simplx+0x21a0>
mov    0x98(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r10,%rdx
jne    2c05 <simplx+0x1ae5>
nop
mov    0x10(%rsp),%ebp
movslq %ebp,%rax
movss  %xmm0,(%rbx,%rax,4)
mov    0x4c(%rsp),%r14d
test   %r14d,%r14d
jle    3350 <simplx+0x2230>
cmpq   $0x7,0x28(%rsp)
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%rbp
mov    0x1b8(%rsp),%rsi
mov    0x1b0(%rsp),%rcx
mov    0x1a8(%rsp),%rdi
movapd 0xe0(%rsp),%xmm4
xorps  %xmm1,%xmm1
jae    3380 <simplx+0x2260>
xor    %eax,%eax
mov    0x250(%rsp),%rdx
jmp    33c8 <simplx+0x22a8>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%rbp
mov    0x250(%rsp),%rdx
movapd 0xe0(%rsp),%xmm4
jmp    34aa <simplx+0x238a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
mov    0x250(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
addss  (%rbx,%rax,4),%xmm1
addss  0x4(%rbx,%rax,4),%xmm1
addss  0x8(%rbx,%rax,4),%xmm1
addss  0xc(%rbx,%rax,4),%xmm1
addss  0x10(%rbx,%rax,4),%xmm1
addss  0x14(%rbx,%rax,4),%xmm1
addss  0x18(%rbx,%rax,4),%xmm1
addss  0x1c(%rbx,%rax,4),%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
jne    3390 <simplx+0x2270>
test   %rsi,%rsi
je     33ee <simplx+0x22ce>
lea    (%rbx,%rax,4),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rax,%rcx,4),%xmm1
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    33e0 <simplx+0x22c0>
test   %r14d,%r14d
jle    3410 <simplx+0x22f0>
divss  0x150(%rsp),%xmm1
cmpq   $0x3,0x28(%rsp)
jae    3418 <simplx+0x22f8>
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    3480 <simplx+0x2360>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
jmp    34aa <simplx+0x238a>
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    0x180(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm2
movss  0x4(%rbx,%rax,4),%xmm3
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
subss  %xmm1,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rbx,%rax,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  0xc(%rbx,%rax,4),%xmm0
subss  %xmm1,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x4,%rax
cmp    %rax,%rcx
jne    3430 <simplx+0x2310>
test   %rdi,%rdi
je     34aa <simplx+0x238a>
lea    (%rbx,%rax,4),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    3490 <simplx+0x2370>
test   %r8d,%r8d
jle    3670 <simplx+0x2550>
mov    0x58(%rsp),%eax
imul   0x270(%rsp),%eax
movslq %eax,%r11
cmp    $0x8,%r8d
jb     34ec <simplx+0x23cc>
mov    0x68(%rsp),%rax
lea    (%rax,%r11,4),%rcx
cmp    %rbp,%rcx
jbe    357d <simplx+0x245d>
lea    (%r9,%r11,4),%rcx
cmp    0x198(%rsp),%rcx
jae    357d <simplx+0x245d>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r10,%rax
test   $0x3,%r10b
je     3525 <simplx+0x2405>
lea    (%r9,%r11,4),%rsi
mov    0xd0(%rsp),%rdi
nopl   0x0(%rax)
movss  (%rsi,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    3510 <simplx+0x23f0>
cmp    $0x3,%rax
jb     3670 <simplx+0x2550>
mov    0x100(%rsp),%rax
lea    (%rax,%r11,4),%rax
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rax,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
movss  -0x8(%rax,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbp,%rcx,4)
movss  -0x4(%rax,%rcx,4),%xmm1
movss  %xmm1,0x8(%rbp,%rcx,4)
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    3540 <simplx+0x2420>
jmp    3670 <simplx+0x2550>
cmpq   $0x18,0xc8(%rsp)
jae    358c <simplx+0x246c>
xor    %ecx,%ecx
jmp    3609 <simplx+0x24e9>
mov    0xa0(%rsp),%rax
lea    (%rax,%r11,4),%rax
mov    0x88(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rax,%rcx,4),%xmm1
movups -0x60(%rax,%rcx,4),%xmm2
movups %xmm1,0x0(%rbp,%rcx,4)
movups %xmm2,0x10(%rbp,%rcx,4)
movups -0x50(%rax,%rcx,4),%xmm1
movups -0x40(%rax,%rcx,4),%xmm2
movups %xmm1,0x20(%rbp,%rcx,4)
movups %xmm2,0x30(%rbp,%rcx,4)
movups -0x30(%rax,%rcx,4),%xmm1
movups -0x20(%rax,%rcx,4),%xmm2
movups %xmm1,0x40(%rbp,%rcx,4)
movups %xmm2,0x50(%rbp,%rcx,4)
movups -0x10(%rax,%rcx,4),%xmm1
movups (%rax,%rcx,4),%xmm2
movups %xmm1,0x60(%rbp,%rcx,4)
movups %xmm2,0x70(%rbp,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    35b0 <simplx+0x2490>
testb  $0x3,0x108(%rsp)
03
mov    0x90(%rsp),%rdi
je     365b <simplx+0x253b>
mov    0x178(%rsp),%rax
lea    (%rax,%rcx,4),%rax
add    %r11,%rcx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%rsi,1),%xmm1
movups (%rcx,%rsi,1),%xmm2
movups %xmm1,-0x10(%rax,%rsi,1)
movups %xmm2,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    3640 <simplx+0x2520>
mov    0x98(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
jne    34ee <simplx+0x23ce>
nop
divss  0x150(%rsp),%xmm0
mov    0x1c8(%rsp),%rax
movss  %xmm4,(%rax)
movss  0x12c(%rsp),%xmm1
ucomiss %xmm0,%xmm1
ja     370b <simplx+0x25eb>
movaps %xmm0,%xmm1
subss  0x110(%rsp),%xmm1
andps  0x98a(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x966(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     370b <simplx+0x25eb>
mov    0xdc(%rsp),%eax
add    $0x1,%eax
movss  %xmm0,0x110(%rsp)
mov    %eax,0xdc(%rsp)
cmp    0x288(%rsp),%eax
jne    1c50 <simplx+0xb30>
jmp    370b <simplx+0x25eb>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    2a25 <simplx+0x1905>
jmp    2a68 <simplx+0x1948>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    2d30 <simplx+0x1c10>
jmp    2d3d <simplx+0x1c1d>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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