#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void bfstages(float *ioptr, int M, float *Utbl, int Ustride, int NDiffU,
              int StageCnt) {
  unsigned int pos;
  unsigned int posi;
  unsigned int pinc;
  unsigned int pnext;
  unsigned int NSameU;
  int Uinc;
  int Uinc2;
  int Uinc4;
  unsigned int DiffUCnt;
  unsigned int SameUCnt;
  unsigned int U2toU3;
  float *pstrt;
  float *p0r, *p1r, *p2r, *p3r;
  float *u0r, *u0i, *u1r, *u1i, *u2r, *u2i;
  float w0r, w0i, w1r, w1i, w2r, w2i, w3r, w3i;
  float f0r, f0i, f1r, f1i, f2r, f2i, f3r, f3i;
  float f4r, f4i, f5r, f5i, f6r, f6i, f7r, f7i;
  float t0r, t0i, t1r, t1i;
  const float Two = 2.0;
  pinc = NDiffU * 2;
  pnext = pinc * 8;
  pos = pinc * 4;
  posi = pos + 1;
  NSameU = ((uint32_t)1 << (M)) / 8 / NDiffU;
  Uinc = (int)NSameU * Ustride;
  Uinc2 = Uinc * 2;
  Uinc4 = Uinc * 4;
  U2toU3 = (((uint32_t)1 << (M)) / 8) * Ustride;
  for (; StageCnt > 0; StageCnt--) {
    u0r = &Utbl[0];
    u0i = &Utbl[((uint32_t)1 << (M - 2)) * Ustride];
    u1r = u0r;
    u1i = u0i;
    u2r = u0r;
    u2i = u0i;
    w0r = *u0r;
    w0i = *u0i;
    w1r = *u1r;
    w1i = *u1i;
    w2r = *u2r;
    w2i = *u2i;
    w3r = *(u2r + U2toU3);
    w3i = *(u2i - U2toU3);
    pstrt = ioptr;
    p0r = pstrt;
    p1r = pstrt + pinc;
    p2r = p1r + pinc;
    p3r = p2r + pinc;
    for (DiffUCnt = NDiffU; DiffUCnt > 0; DiffUCnt--) {
      f0r = *p0r;
      f0i = *(p0r + 1);
      f1r = *p1r;
      f1i = *(p1r + 1);
      for (SameUCnt = NSameU - 1; SameUCnt > 0; SameUCnt--) {
        f2r = *p2r;
        f2i = *(p2r + 1);
        f3r = *p3r;
        f3i = *(p3r + 1);
        t0r = f0r + f1r * w0r + f1i * w0i;
        t0i = f0i - f1r * w0i + f1i * w0r;
        f1r = f0r * Two - t0r;
        f1i = f0i * Two - t0i;
        f4r = *(p0r + pos);
        f4i = *(p0r + posi);
        f5r = *(p1r + pos);
        f5i = *(p1r + posi);
        f6r = *(p2r + pos);
        f6i = *(p2r + posi);
        f7r = *(p3r + pos);
        f7i = *(p3r + posi);
        t1r = f2r - f3r * w0r - f3i * w0i;
        t1i = f2i + f3r * w0i - f3i * w0r;
        f2r = f2r * Two - t1r;
        f2i = f2i * Two - t1i;
        f0r = t0r + f2r * w1r + f2i * w1i;
        f0i = t0i - f2r * w1i + f2i * w1r;
        f2r = t0r * Two - f0r;
        f2i = t0i * Two - f0i;
        f3r = f1r + t1r * w1i - t1i * w1r;
        f3i = f1i + t1r * w1r + t1i * w1i;
        f1r = f1r * Two - f3r;
        f1i = f1i * Two - f3i;
        t0r = f4r + f5r * w0r + f5i * w0i;
        t0i = f4i - f5r * w0i + f5i * w0r;
        f5r = f4r * Two - t0r;
        f5i = f4i * Two - t0i;
        t1r = f6r - f7r * w0r - f7i * w0i;
        t1i = f6i + f7r * w0i - f7i * w0r;
        f6r = f6r * Two - t1r;
        f6i = f6i * Two - t1i;
        f4r = t0r + f6r * w1r + f6i * w1i;
        f4i = t0i - f6r * w1i + f6i * w1r;
        f6r = t0r * Two - f4r;
        f6i = t0i * Two - f4i;
        f7r = f5r + t1r * w1i - t1i * w1r;
        f7i = f5i + t1r * w1r + t1i * w1i;
        f5r = f5r * Two - f7r;
        f5i = f5i * Two - f7i;
        t0r = f0r - f4r * w2r - f4i * w2i;
        t0i = f0i + f4r * w2i - f4i * w2r;
        f0r = f0r * Two - t0r;
        f0i = f0i * Two - t0i;
        t1r = f1r - f5r * w3r - f5i * w3i;
        t1i = f1i + f5r * w3i - f5i * w3r;
        f1r = f1r * Two - t1r;
        f1i = f1i * Two - t1i;
        *(p0r + pos) = t0r;
        *(p1r + pos) = t1r;
        *(p0r + posi) = t0i;
        *(p1r + posi) = t1i;
        *p0r = f0r;
        *p1r = f1r;
        *(p0r + 1) = f0i;
        *(p1r + 1) = f1i;
        p0r += pnext;
        f0r = *p0r;
        f0i = *(p0r + 1);
        p1r += pnext;
        f1r = *p1r;
        f1i = *(p1r + 1);
        f4r = f2r - f6r * w2i + f6i * w2r;
        f4i = f2i - f6r * w2r - f6i * w2i;
        f6r = f2r * Two - f4r;
        f6i = f2i * Two - f4i;
        f5r = f3r - f7r * w3i + f7i * w3r;
        f5i = f3i - f7r * w3r - f7i * w3i;
        f7r = f3r * Two - f5r;
        f7i = f3i * Two - f5i;
        *p2r = f4r;
        *p3r = f5r;
        *(p2r + 1) = f4i;
        *(p3r + 1) = f5i;
        *(p2r + pos) = f6r;
        *(p3r + pos) = f7r;
        *(p2r + posi) = f6i;
        *(p3r + posi) = f7i;
        p2r += pnext;
        p3r += pnext;
      }
      f2r = *p2r;
      f2i = *(p2r + 1);
      f3r = *p3r;
      f3i = *(p3r + 1);
      t0r = f0r + f1r * w0r + f1i * w0i;
      t0i = f0i - f1r * w0i + f1i * w0r;
      f1r = f0r * Two - t0r;
      f1i = f0i * Two - t0i;
      f4r = *(p0r + pos);
      f4i = *(p0r + posi);
      f5r = *(p1r + pos);
      f5i = *(p1r + posi);
      f6r = *(p2r + pos);
      f6i = *(p2r + posi);
      f7r = *(p3r + pos);
      f7i = *(p3r + posi);
      t1r = f2r - f3r * w0r - f3i * w0i;
      t1i = f2i + f3r * w0i - f3i * w0r;
      f2r = f2r * Two - t1r;
      f2i = f2i * Two - t1i;
      f0r = t0r + f2r * w1r + f2i * w1i;
      f0i = t0i - f2r * w1i + f2i * w1r;
      f2r = t0r * Two - f0r;
      f2i = t0i * Two - f0i;
      f3r = f1r + t1r * w1i - t1i * w1r;
      f3i = f1i + t1r * w1r + t1i * w1i;
      f1r = f1r * Two - f3r;
      f1i = f1i * Two - f3i;
      if ((int)DiffUCnt == NDiffU / 2)
        Uinc4 = -Uinc4;
      u0r += Uinc4;
      u0i -= Uinc4;
      u1r += Uinc2;
      u1i -= Uinc2;
      u2r += Uinc;
      u2i -= Uinc;
      pstrt += 2;
      t0r = f4r + f5r * w0r + f5i * w0i;
      t0i = f4i - f5r * w0i + f5i * w0r;
      f5r = f4r * Two - t0r;
      f5i = f4i * Two - t0i;
      t1r = f6r - f7r * w0r - f7i * w0i;
      t1i = f6i + f7r * w0i - f7i * w0r;
      f6r = f6r * Two - t1r;
      f6i = f6i * Two - t1i;
      f4r = t0r + f6r * w1r + f6i * w1i;
      f4i = t0i - f6r * w1i + f6i * w1r;
      f6r = t0r * Two - f4r;
      f6i = t0i * Two - f4i;
      f7r = f5r + t1r * w1i - t1i * w1r;
      f7i = f5i + t1r * w1r + t1i * w1i;
      f5r = f5r * Two - f7r;
      f5i = f5i * Two - f7i;
      w0r = *u0r;
      w0i = *u0i;
      w1r = *u1r;
      w1i = *u1i;
      if ((int)DiffUCnt <= NDiffU / 2)
        w0r = -w0r;
      t0r = f0r - f4r * w2r - f4i * w2i;
      t0i = f0i + f4r * w2i - f4i * w2r;
      f0r = f0r * Two - t0r;
      f0i = f0i * Two - t0i;
      f4r = f2r - f6r * w2i + f6i * w2r;
      f4i = f2i - f6r * w2r - f6i * w2i;
      f6r = f2r * Two - f4r;
      f6i = f2i * Two - f4i;
      *(p0r + pos) = t0r;
      *p2r = f4r;
      *(p0r + posi) = t0i;
      *(p2r + 1) = f4i;
      w2r = *u2r;
      w2i = *u2i;
      *p0r = f0r;
      *(p2r + pos) = f6r;
      *(p0r + 1) = f0i;
      *(p2r + posi) = f6i;
      p0r = pstrt;
      p2r = pstrt + pinc + pinc;
      t1r = f1r - f5r * w3r - f5i * w3i;
      t1i = f1i + f5r * w3i - f5i * w3r;
      f1r = f1r * Two - t1r;
      f1i = f1i * Two - t1i;
      f5r = f3r - f7r * w3i + f7i * w3r;
      f5i = f3i - f7r * w3r - f7i * w3i;
      f7r = f3r * Two - f5r;
      f7i = f3i * Two - f5i;
      *(p1r + pos) = t1r;
      *p3r = f5r;
      *(p1r + posi) = t1i;
      *(p3r + 1) = f5i;
      w3r = *(u2r + U2toU3);
      w3i = *(u2i - U2toU3);
      *p1r = f1r;
      *(p3r + pos) = f7r;
      *(p1r + 1) = f1i;
      *(p3r + posi) = f7i;
      p1r = pstrt + pinc;
      p3r = p2r + pinc;
    }
    NSameU /= 8;
    Uinc /= 8;
    Uinc2 /= 8;
    Uinc4 = Uinc * 4;
    NDiffU *= 8;
    pinc *= 8;
    pnext *= 8;
    pos *= 8;
    posi = pos + 1;
  }
}


x86 assembly (clang, -O0):
<bfstages>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa8,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movss  0x2ed7(%rip),%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
imul   -0x1c(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    3171 <bfstages+0x2071>
mov    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x80(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x88(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0x90(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x98(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0xa0(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
mov    -0xa8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
mov    -0xa0(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0xa8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jbe    3108 <bfstages+0x2008>
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0x68(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jbe    2174 <bfstages+0x1074>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xe8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x108(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movss  -0xc0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xc4(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x114(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x118(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xcc(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd4(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xd8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0x68(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
movss  -0xc4(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xf8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xf4(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xf0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xf8(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xfc(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x104(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x100(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x108(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1354 <bfstages+0x254>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xfc(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xe8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x120(%rbp),%eax
cmp    %ecx,%eax
jne    2638 <bfstages+0x1538>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
movss  -0xec(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x118(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x108(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x80(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x88(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0x90(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x98(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x124(%rbp),%eax
cmp    %ecx,%eax
jg     2b2f <bfstages+0x1a2f>
movss  -0xac(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movss  -0xc0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xec(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xec(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xa0(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
mov    -0xa8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xfc(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xd0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x100(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xc4(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm1
ff
movss  -0xc4(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x108(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0xf4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xf8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
movss  -0x114(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf4(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x118(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xa0(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0xa8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x104(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xd8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x108(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    12ff <bfstages+0x1ff>
mov    -0x38(%rbp),%eax
shr    $0x3,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11a3 <bfstages+0xa3>
add    $0xa8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bfstages>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%r11d
mov    %rdx,0x38(%rsp)
mov    %esi,%ecx
mov    %rdi,0xa8(%rsp)
mov    $0x1,%edx
shl    %cl,%edx
lea    0x7(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
sar    $0x3,%eax
mov    %rax,%rsi
cltd
mov    %r8,-0x20(%rsp)
idiv   %r8d
mov    %rax,-0x18(%rsp)
test   %r9d,%r9d
jle    1ed6 <bfstages+0xdd6>
mov    -0x18(%rsp),%rax
imul   %r11d,%eax
imul   %r11d,%esi
mov    %rax,(%rsp)
add    %eax,%eax
mov    %rax,0x8(%rsp)
mov    -0x20(%rsp),%rdx
mov    %edx,%eax
shl    $0x4,%eax
mov    %eax,-0x38(%rsp)
lea    (%rdx,%rdx,1),%ebp
add    $0xfe,%cl
shl    %cl,%r11d
movslq %r11d,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0xa0(%rsp)
mov    %rsi,%rax
mov    %rsi,0x48(%rsp)
neg    %rsi
mov    %rsi,0x40(%rsp)
mov    %edx,%edi
jmp    120b <bfstages+0x10b>
cs nopw 0x0(%rax,%rax,1)
mov    -0x18(%rsp),%rax
shr    $0x3,%eax
mov    %rax,-0x18(%rsp)
mov    (%rsp),%rcx
lea    0x7(%rcx),%eax
test   %ecx,%ecx
cmovns %ecx,%eax
sar    $0x3,%eax
mov    0x8(%rsp),%rdx
lea    0x7(%rdx),%ecx
test   %edx,%edx
cmovns %edx,%ecx
sar    $0x3,%ecx
mov    -0x34(%rsp),%edi
shl    $0x3,%edi
shl    $0x3,%ebp
shll   $0x3,-0x38(%rsp)
mov    0xb0(%rsp),%rsi
lea    -0x1(%rsi),%edx
mov    %rcx,0x8(%rsp)
mov    %rax,(%rsp)
cmp    $0x1,%esi
mov    %edx,%r9d
jle    1ed6 <bfstages+0xdd6>
mov    %r9,0xb0(%rsp)
mov    -0x20(%rsp),%rax
shl    $0x3,%eax
mov    %rax,-0x20(%rsp)
mov    %ebp,%ebp
mov    %edi,-0x34(%rsp)
test   %edi,%edi
je     11b0 <bfstages+0xb0>
mov    0x38(%rsp),%rdx
movss  (%rdx),%xmm1
mov    0xa0(%rsp),%rbx
movss  (%rbx),%xmm3
mov    -0x20(%rsp),%rdi
mov    %edi,%ecx
or     $0x1,%ecx
mov    %rcx,0x98(%rsp)
mov    0x40(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm0
mov    0x48(%rsp),%rcx
movss  (%rdx,%rcx,4),%xmm2
mov    (%rsp),%r9
lea    0x0(,%r9,4),%ecx
mov    %ecx,-0x58(%rsp)
mov    -0x18(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    %edi,%ecx
mov    -0x38(%rsp),%edi
mov    -0x34(%rsp),%r8d
mov    %r8d,%esi
shr    $0x1f,%esi
add    %r8d,%esi
sar    %esi
mov    %esi,0x24(%rsp)
movslq 0x8(%rsp),%rsi
mov    %rsi,0x88(%rsp)
neg    %rsi
mov    %rsi,0x80(%rsp)
movslq %r9d,%rsi
mov    %rsi,0x78(%rsp)
neg    %rsi
mov    %rsi,0x70(%rsp)
lea    0x0(,%rbp,4),%rsi
mov    %rsi,0xb8(%rsp)
lea    (%rsi,%rsi,2),%r15
shl    $0x2,%rdi
lea    0x0(,%rcx,4),%r14
mov    %rcx,0x90(%rsp)
lea    (%r15,%rcx,4),%rsi
add    $0x4,%rsi
lea    0x0(,%rbp,8),%rcx
movss  %xmm3,-0x60(%rsp)
movss  %xmm1,-0x6c(%rsp)
movss  %xmm3,-0x54(%rsp)
movss  %xmm3,-0x74(%rsp)
movss  %xmm1,-0x64(%rsp)
lea    0x4(%r14,%rbp,8),%r10
lea    0x4(%r14,%rbp,4),%r9
lea    0x4(%rdi,%rbp,4),%r12
mov    %rbx,0x58(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rbx,0x68(%rsp)
mov    %rdx,0x60(%rsp)
mov    0xa8(%rsp),%rbx
mov    %r8d,-0x28(%rsp)
mov    %rbp,0xc0(%rsp)
mov    %eax,0x28(%rsp)
jmp    1782 <bfstages+0x682>
xorps  0xc99(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movss  -0x74(%rsp),%xmm4
movaps %xmm8,%xmm3
movss  -0x2c(%rsp),%xmm7
movss  -0x30(%rsp),%xmm2
movaps %xmm2,%xmm0
movss  -0x70(%rsp),%xmm1
mulss  %xmm1,%xmm0
movss  0x30(%rsp),%xmm13
addss  %xmm13,%xmm0
movss  0x2c(%rsp),%xmm6
movaps %xmm6,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm4,%xmm2
movss  -0x50(%rsp),%xmm14
movaps %xmm14,%xmm0
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
movaps %xmm11,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm7,%xmm9
subss  %xmm2,%xmm9
movaps %xmm10,%xmm2
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm9
mulss  %xmm4,%xmm11
mulss  %xmm1,%xmm10
addss  %xmm8,%xmm11
subss  %xmm10,%xmm11
addss  %xmm7,%xmm7
subss  %xmm9,%xmm7
addss  %xmm8,%xmm3
subss  %xmm11,%xmm3
movaps %xmm7,%xmm2
movss  -0x6c(%rsp),%xmm1
mulss  %xmm1,%xmm2
addss  %xmm5,%xmm2
movaps %xmm3,%xmm4
movss  -0x60(%rsp),%xmm10
mulss  %xmm10,%xmm4
addss  %xmm2,%xmm4
mulss  %xmm10,%xmm7
movaps %xmm6,%xmm2
subss  %xmm7,%xmm2
mulss  %xmm1,%xmm3
addss  %xmm2,%xmm3
movaps %xmm11,%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rsp)
movaps %xmm9,%xmm15
mulss  %xmm1,%xmm9
mulss  %xmm10,%xmm15
mulss  %xmm10,%xmm11
movaps %xmm4,%xmm1
movss  -0x64(%rsp),%xmm10
mulss  %xmm10,%xmm1
movaps %xmm12,%xmm8
movaps %xmm12,%xmm7
subss  %xmm1,%xmm7
movaps %xmm3,%xmm1
movss  -0x54(%rsp),%xmm2
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm7
addss  %xmm13,%xmm13
subss  %xmm5,%xmm13
addss  %xmm14,%xmm14
subss  %xmm6,%xmm14
addss  %xmm5,%xmm5
subss  %xmm4,%xmm5
addss  %xmm6,%xmm6
subss  %xmm3,%xmm6
mulss  %xmm2,%xmm4
movss  -0x4c(%rsp),%xmm0
addss  %xmm0,%xmm4
mulss  %xmm10,%xmm3
subss  %xmm3,%xmm4
movaps %xmm5,%xmm1
mulss  %xmm2,%xmm1
movss  -0x5c(%rsp),%xmm12
movaps %xmm12,%xmm3
subss  %xmm1,%xmm3
movaps %xmm6,%xmm1
mulss  %xmm10,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm10,%xmm5
movss  -0x3c(%rsp),%xmm10
movaps %xmm10,%xmm3
subss  %xmm5,%xmm3
mulss  %xmm2,%xmm6
subss  %xmm6,%xmm3
lea    (%rax,%rdx,4),%rax
mov    %rax,0x60(%rsp)
shl    $0x2,%rdx
mov    0x68(%rsp),%rax
sub    %rdx,%rax
mov    %rax,0x68(%rsp)
addss  %xmm8,%xmm8
subss  %xmm7,%xmm8
movss  (%rax),%xmm5
movss  %xmm5,-0x74(%rsp)
mov    0x10(%rsp),%rdx
mov    0x88(%rsp),%rax
movss  (%rdx,%rax,4),%xmm2
movss  %xmm2,-0x6c(%rsp)
mov    0x80(%rsp),%rax
mov    0x18(%rsp),%rdx
movss  (%rdx,%rax,4),%xmm2
movss  %xmm2,-0x60(%rsp)
mov    0x90(%rsp),%r8
movss  %xmm7,(%rbx,%r8,4)
addss  %xmm12,%xmm12
subss  %xmm1,%xmm12
movss  %xmm1,(%r11)
addss  %xmm0,%xmm0
subss  %xmm4,%xmm0
mov    0x98(%rsp),%rax
movss  %xmm4,(%rbx,%rax,4)
addss  %xmm10,%xmm10
subss  %xmm3,%xmm10
movss  %xmm3,0x4(%r11)
mov    0x50(%rsp),%rdx
mov    0x78(%rsp),%rbp
movss  (%rdx,%rbp,4),%xmm1
movss  %xmm1,-0x64(%rsp)
mov    0x58(%rsp),%r13
mov    0x70(%rsp),%rbp
movss  0x0(%r13,%rbp,4),%xmm1
movss  %xmm1,-0x54(%rsp)
movss  %xmm8,(%rbx)
movss  %xmm12,(%r11,%r8,4)
movss  %xmm0,0x4(%rbx)
movss  %xmm10,(%r11,%rax,4)
addss  %xmm13,%xmm15
subss  -0x70(%rsp),%xmm15
movaps %xmm14,%xmm2
addss  %xmm14,%xmm9
addss  %xmm9,%xmm11
addss  %xmm13,%xmm13
subss  %xmm15,%xmm13
movaps %xmm13,%xmm0
movss  -0x48(%rsp),%xmm6
mulss  %xmm6,%xmm0
movss  -0x44(%rsp),%xmm4
movaps %xmm4,%xmm1
subss  %xmm0,%xmm1
addss  %xmm14,%xmm2
subss  %xmm11,%xmm2
movaps %xmm2,%xmm0
movss  -0x24(%rsp),%xmm5
mulss  %xmm5,%xmm0
subss  %xmm0,%xmm1
mulss  %xmm5,%xmm13
movss  -0x40(%rsp),%xmm14
addss  %xmm14,%xmm13
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm13
movaps %xmm15,%xmm0
mulss  %xmm5,%xmm0
movss  0x34(%rsp),%xmm7
movaps %xmm7,%xmm3
subss  %xmm0,%xmm3
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
addss  %xmm3,%xmm0
mulss  %xmm6,%xmm15
movss  -0x68(%rsp),%xmm6
movaps %xmm6,%xmm3
subss  %xmm15,%xmm3
mulss  %xmm5,%xmm11
subss  %xmm11,%xmm3
addss  %xmm4,%xmm4
subss  %xmm1,%xmm4
mov    -0x10(%rsp),%r11
movss  %xmm1,(%r11,%r8,4)
addss  %xmm7,%xmm7
subss  %xmm0,%xmm7
mov    -0x8(%rsp),%rbx
movss  %xmm0,(%rbx)
mov    0x78(%rsp),%rbp
lea    (%rdx,%rbp,4),%rdx
mov    0x70(%rsp),%rbp
lea    0x0(%r13,%rbp,4),%r13
addss  %xmm14,%xmm14
subss  %xmm13,%xmm14
addss  %xmm6,%xmm6
subss  %xmm3,%xmm6
movss  %xmm13,(%r11,%rax,4)
movss  %xmm3,0x4(%rbx)
mov    0x48(%rsp),%rbp
movss  (%rdx,%rbp,4),%xmm2
mov    0x40(%rsp),%rbp
movss  0x0(%r13,%rbp,4),%xmm0
movss  %xmm4,(%r11)
movss  %xmm7,(%rbx,%r8,4)
movss  %xmm14,0x4(%r11)
movss  %xmm6,(%rbx,%rax,4)
mov    0x10(%rsp),%rax
mov    0x88(%rsp),%rbp
lea    (%rax,%rbp,4),%rax
mov    0x80(%rsp),%rbp
mov    0x18(%rsp),%rbx
lea    (%rbx,%rbp,4),%rbp
mov    0xc8(%rsp),%rbx
add    $0x8,%rbx
movaps 0xd0(%rsp),%xmm1
mov    %r13,0x58(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rbp,0x18(%rsp)
mov    %rax,0x10(%rsp)
addl   $0xffffffff,-0x28(%rsp)
mov    0xc0(%rsp),%rbp
mov    0x28(%rsp),%eax
je     11b0 <bfstages+0xb0>
movss  %xmm1,-0x70(%rsp)
movss  (%rbx),%xmm8
movss  0x4(%rbx),%xmm14
movss  (%rbx,%rbp,4),%xmm1
movss  0x4(%rbx,%rbp,4),%xmm13
test   %eax,%eax
movss  %xmm0,-0x24(%rsp)
movss  %xmm2,-0x48(%rsp)
mov    %rbx,0xc8(%rsp)
je     1cb0 <bfstages+0xbb0>
mov    0xb8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rcx,1),%xmm5
movss  0x4(%rbx,%rcx,1),%xmm3
movss  (%rbx,%r15,1),%xmm9
movss  0x4(%rbx,%r15,1),%xmm7
movaps %xmm1,%xmm0
movss  -0x70(%rsp),%xmm2
mulss  %xmm2,%xmm0
movaps %xmm2,%xmm6
movaps %xmm13,%xmm4
addss  %xmm8,%xmm0
movss  -0x74(%rsp),%xmm11
mulss  %xmm11,%xmm4
mulss  %xmm11,%xmm1
movaps %xmm14,%xmm2
subss  %xmm1,%xmm2
addss  %xmm0,%xmm4
movaps %xmm4,%xmm0
movss  %xmm4,-0x10(%rsp)
mulss  %xmm6,%xmm13
addss  %xmm8,%xmm8
addss  %xmm14,%xmm14
addss  %xmm2,%xmm13
movss  %xmm13,-0x3c(%rsp)
movss  (%rbx,%r14,1),%xmm10
movss  0x4(%rbx,%r14,1),%xmm12
movss  -0x4(%rbx,%r9,1),%xmm2
movss  %xmm2,-0x4c(%rsp)
subss  %xmm4,%xmm8
movss  %xmm8,-0x44(%rsp)
movss  (%rbx,%r9,1),%xmm0
movss  %xmm0,-0x68(%rsp)
movss  -0x4(%rbx,%rsi,1),%xmm15
movaps %xmm9,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm5,%xmm2
subss  %xmm13,%xmm14
movss  %xmm14,-0x40(%rsp)
subss  %xmm0,%xmm2
movaps %xmm7,%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm11,%xmm9
subss  %xmm0,%xmm2
addss  %xmm3,%xmm9
mulss  %xmm6,%xmm7
addss  %xmm5,%xmm5
subss  %xmm7,%xmm9
subss  %xmm2,%xmm5
addss  %xmm3,%xmm3
subss  %xmm9,%xmm3
movaps %xmm9,%xmm7
movaps %xmm3,%xmm6
movaps %xmm5,%xmm0
movss  -0x6c(%rsp),%xmm4
mulss  %xmm4,%xmm0
movss  -0x60(%rsp),%xmm9
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm13
movaps %xmm2,%xmm3
mulss  %xmm9,%xmm3
movaps %xmm7,%xmm1
addss  %xmm8,%xmm3
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm3
movss  %xmm3,-0x8(%rsp)
movaps %xmm6,%xmm3
movaps %xmm6,%xmm8
mulss  %xmm9,%xmm3
addss  -0x10(%rsp),%xmm0
mulss  %xmm4,%xmm2
movaps %xmm4,%xmm1
addss  %xmm14,%xmm2
mulss  %xmm9,%xmm7
addss  %xmm0,%xmm3
movaps %xmm3,%xmm6
movss  %xmm3,-0x50(%rsp)
addss  %xmm2,%xmm7
movss  %xmm7,-0x5c(%rsp)
movss  -0x4c(%rsp),%xmm2
movaps %xmm2,%xmm0
movss  -0x70(%rsp),%xmm4
mulss  %xmm4,%xmm0
movss  -0x68(%rsp),%xmm14
movaps %xmm14,%xmm3
mulss  %xmm11,%xmm3
addss  %xmm10,%xmm0
addss  %xmm0,%xmm3
mulss  %xmm11,%xmm2
movaps %xmm12,%xmm0
subss  %xmm2,%xmm0
movss  -0x4(%rbx,%r10,1),%xmm5
movaps %xmm8,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm4,%xmm14
movaps %xmm4,%xmm8
addss  %xmm0,%xmm14
movaps %xmm15,%xmm0
addss  %xmm13,%xmm2
movss  %xmm2,-0x68(%rsp)
mulss  %xmm4,%xmm0
movaps %xmm5,%xmm7
subss  %xmm0,%xmm7
movss  (%rbx,%rsi,1),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm11,%xmm0
subss  %xmm0,%xmm7
mulss  %xmm11,%xmm15
movss  (%rbx,%r10,1),%xmm11
addss  %xmm11,%xmm15
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm15
addss  %xmm5,%xmm5
subss  %xmm7,%xmm5
movaps %xmm5,%xmm0
mulss  %xmm9,%xmm5
movaps %xmm14,%xmm4
subss  %xmm5,%xmm4
addss  %xmm11,%xmm11
subss  %xmm15,%xmm11
mulss  %xmm1,%xmm0
addss  %xmm3,%xmm0
movaps %xmm11,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm0,%xmm5
addss  %xmm10,%xmm10
subss  %xmm3,%xmm10
movaps %xmm7,%xmm13
mulss  %xmm9,%xmm13
addss  %xmm10,%xmm13
movaps %xmm15,%xmm0
mulss  %xmm1,%xmm0
subss  %xmm0,%xmm13
mulss  %xmm1,%xmm11
addss  %xmm4,%xmm11
addss  %xmm12,%xmm12
subss  %xmm14,%xmm12
mulss  %xmm1,%xmm7
addss  %xmm12,%xmm7
mulss  %xmm9,%xmm15
addss  %xmm7,%xmm15
movaps %xmm5,%xmm0
mulss  -0x64(%rsp),%xmm0
movaps %xmm6,%xmm7
subss  %xmm0,%xmm7
movss  -0x44(%rsp),%xmm2
addss  %xmm2,%xmm2
subss  -0x8(%rsp),%xmm2
addss  %xmm10,%xmm10
subss  %xmm13,%xmm10
movaps %xmm10,%xmm0
movss  -0x48(%rsp),%xmm1
mulss  %xmm1,%xmm0
movaps %xmm2,%xmm4
subss  %xmm0,%xmm4
movaps %xmm11,%xmm0
movss  -0x54(%rsp),%xmm8
mulss  %xmm8,%xmm0
subss  %xmm0,%xmm7
addss  %xmm3,%xmm3
subss  %xmm5,%xmm3
movss  -0x40(%rsp),%xmm9
addss  %xmm14,%xmm14
subss  %xmm11,%xmm14
mulss  %xmm8,%xmm5
movss  -0x68(%rsp),%xmm6
addss  %xmm6,%xmm5
mulss  -0x64(%rsp),%xmm11
subss  %xmm11,%xmm5
addss  %xmm12,%xmm12
subss  %xmm15,%xmm12
movaps %xmm12,%xmm0
movss  -0x24(%rsp),%xmm11
mulss  %xmm11,%xmm0
subss  %xmm0,%xmm4
addss  %xmm9,%xmm9
subss  -0x5c(%rsp),%xmm9
mulss  %xmm11,%xmm10
addss  %xmm9,%xmm10
mulss  %xmm1,%xmm12
subss  %xmm12,%xmm10
movss  -0x10(%rsp),%xmm12
addss  %xmm12,%xmm12
movss  -0x50(%rsp),%xmm0
subss  %xmm0,%xmm12
addss  %xmm0,%xmm0
subss  %xmm7,%xmm0
movaps %xmm0,%xmm1
movss  %xmm7,(%rbx,%r14,1)
addss  %xmm2,%xmm2
subss  %xmm4,%xmm2
movss  %xmm4,-0x4(%rbx,%r9,1)
movss  -0x3c(%rsp),%xmm0
addss  %xmm0,%xmm0
subss  %xmm6,%xmm0
addss  %xmm6,%xmm6
subss  %xmm5,%xmm6
movss  %xmm5,0x4(%rbx,%r14,1)
addss  %xmm9,%xmm9
subss  %xmm10,%xmm9
movss  %xmm10,(%rbx,%r9,1)
movss  %xmm1,(%rbx)
movaps %xmm3,%xmm1
movss  %xmm2,(%rbx,%rdx,1)
mulss  %xmm8,%xmm1
movaps %xmm12,%xmm4
subss  %xmm1,%xmm4
movaps %xmm14,%xmm5
movss  -0x64(%rsp),%xmm1
mulss  %xmm1,%xmm5
movss  %xmm6,0x4(%rbx)
addss  %xmm4,%xmm5
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm7
subss  %xmm3,%xmm7
movss  %xmm9,0x4(%rbx,%rdx,1)
mulss  %xmm8,%xmm14
subss  %xmm14,%xmm7
addss  %xmm12,%xmm12
movaps %xmm13,%xmm1
movss  (%rbx,%rdi,1),%xmm8
mulss  %xmm11,%xmm1
movss  -0x8(%rsp),%xmm3
movaps %xmm3,%xmm2
subss  %xmm1,%xmm2
movaps %xmm15,%xmm4
movss  -0x48(%rsp),%xmm1
mulss  %xmm1,%xmm4
movss  0x4(%rbx,%rdi,1),%xmm14
addss  %xmm2,%xmm4
mulss  %xmm1,%xmm13
movss  -0x5c(%rsp),%xmm9
movaps %xmm9,%xmm2
subss  %xmm13,%xmm2
movss  -0x4(%rbx,%r12,1),%xmm1
subss  %xmm5,%xmm12
mulss  %xmm11,%xmm15
subss  %xmm15,%xmm2
movss  (%rbx,%r12,1),%xmm13
movss  %xmm5,(%rbx,%rcx,1)
addss  %xmm3,%xmm3
subss  %xmm4,%xmm3
movss  %xmm4,(%rbx,%r15,1)
addss  %xmm0,%xmm0
subss  %xmm7,%xmm0
movss  %xmm7,0x4(%rbx,%rcx,1)
movaps %xmm9,%xmm4
addss  %xmm9,%xmm4
subss  %xmm2,%xmm4
movss  %xmm2,0x4(%rbx,%r15,1)
movss  %xmm12,-0x4(%rbx,%r10,1)
movss  %xmm3,-0x4(%rbx,%rsi,1)
movss  %xmm0,(%rbx,%r10,1)
movss  %xmm4,(%rbx,%rsi,1)
add    %rdi,%rbx
add    $0xffffffff,%eax
jne    17d0 <bfstages+0x6d0>
lea    (%rbx,%r15,1),%r8
lea    (%rbx,%rcx,1),%r11
mov    %rbx,%r13
add    %rdx,%r13
jmp    1cc3 <bfstages+0xbc3>
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%rbp,4),%r13
lea    0x0(,%rbp,4),%r11
add    %r13,%r11
lea    (%r11,%rbp,4),%r8
mov    -0x58(%rsp),%ebp
movss  -0x74(%rsp),%xmm4
movss  (%r11),%xmm0
movss  0x4(%r11),%xmm15
movss  (%r8),%xmm12
movss  0x4(%r8),%xmm6
movaps %xmm1,%xmm2
movss  -0x70(%rsp),%xmm10
mulss  %xmm10,%xmm2
movaps %xmm8,%xmm9
addss  %xmm8,%xmm2
movaps %xmm13,%xmm7
mulss  %xmm4,%xmm7
addss  %xmm2,%xmm7
mulss  %xmm4,%xmm1
movaps %xmm14,%xmm2
subss  %xmm1,%xmm2
mulss  %xmm10,%xmm13
addss  %xmm2,%xmm13
addss  %xmm8,%xmm9
subss  %xmm7,%xmm9
addss  %xmm14,%xmm14
subss  %xmm13,%xmm14
mov    0x90(%rsp),%rdx
movss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,0x30(%rsp)
mov    0x98(%rsp),%rax
movss  (%rbx,%rax,4),%xmm1
movss  %xmm1,-0x50(%rsp)
movss  0x0(%r13,%rdx,4),%xmm1
movss  %xmm1,-0x30(%rsp)
mov    %r13,-0x10(%rsp)
movss  0x0(%r13,%rax,4),%xmm1
movss  %xmm1,0x2c(%rsp)
movss  (%r11,%rdx,4),%xmm1
movss  %xmm1,-0x2c(%rsp)
movss  (%r11,%rax,4),%xmm8
movss  (%r8,%rdx,4),%xmm11
movaps %xmm12,%xmm1
mulss  %xmm10,%xmm1
movaps %xmm0,%xmm3
subss  %xmm1,%xmm3
movaps %xmm6,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm3
mulss  %xmm4,%xmm12
addss  %xmm15,%xmm12
mulss  %xmm10,%xmm6
subss  %xmm6,%xmm12
addss  %xmm0,%xmm0
subss  %xmm3,%xmm0
addss  %xmm15,%xmm15
subss  %xmm12,%xmm15
movaps %xmm0,%xmm1
movss  -0x6c(%rsp),%xmm6
mulss  %xmm6,%xmm1
addss  %xmm7,%xmm1
movaps %xmm15,%xmm2
movss  -0x60(%rsp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm4,%xmm0
movaps %xmm13,%xmm1
subss  %xmm0,%xmm1
mulss  %xmm6,%xmm15
addss  %xmm1,%xmm15
movaps %xmm3,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm9,%xmm5
movaps %xmm12,%xmm0
mulss  %xmm6,%xmm0
subss  %xmm0,%xmm5
mov    %r8,-0x8(%rsp)
movss  (%r8,%rax,4),%xmm10
addss  %xmm7,%xmm7
subss  %xmm2,%xmm7
movss  %xmm7,-0x5c(%rsp)
addss  %xmm13,%xmm13
movss  %xmm15,-0x4c(%rsp)
subss  %xmm15,%xmm13
movss  %xmm13,-0x3c(%rsp)
movss  %xmm6,-0x6c(%rsp)
mulss  %xmm6,%xmm3
addss  %xmm14,%xmm3
mulss  %xmm4,%xmm12
addss  %xmm3,%xmm12
addss  %xmm9,%xmm9
subss  %xmm5,%xmm9
movss  %xmm9,-0x44(%rsp)
addss  %xmm14,%xmm14
movss  %xmm12,-0x68(%rsp)
subss  %xmm12,%xmm14
movss  %xmm14,-0x40(%rsp)
mov    %ebp,%edx
neg    %edx
mov    -0x28(%rsp),%eax
cmp    0x24(%rsp),%eax
cmove  %edx,%ebp
movslq %ebp,%rdx
mov    0x60(%rsp),%rax
movss  (%rax,%rdx,4),%xmm0
mov    %ebp,-0x58(%rsp)
movss  %xmm5,0x34(%rsp)
movaps %xmm2,%xmm12
jle    1360 <bfstages+0x260>
movss  -0x74(%rsp),%xmm4
movaps %xmm0,0xd0(%rsp)
jmp    1375 <bfstages+0x275>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @bfstages(float* nocapture %0, i32 %1, float* nocapture %2, i32 %3, i32 %4, i32 %5) {
%7 = shl nuw i32 1, %1
%8 = sdiv i32 %7, 8
%9 = sdiv i32 %8, %4
%10 = mul nsw i32 %9, %3
%11 = icmp sgt i32 %5, 0
br i1 %11, label %12, label %412
12: ; preds = %6
%13 = mul nsw i32 %8, %3
%14 = shl nsw i32 %10, 1
%15 = shl i32 %4, 4
%16 = shl nsw i32 %4, 1
%17 = add nsw i32 %1, -2
%18 = shl i32 %3, %17
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds float, float* %2, i64 %19
%21 = zext i32 %13 to i64
%22 = getelementptr inbounds float, float* %2, i64 %21
%23 = sub nsw i64 0, %21
%24 = getelementptr inbounds float, float* %20, i64 %23
br label %25
25: ; preds = %12, %403
%26 = phi i32 [ %4, %12 ], [ %34, %403 ]
%27 = phi i32 [ %4, %12 ], [ %407, %403 ]
%28 = phi i32 [ %5, %12 ], [ %410, %403 ]
%29 = phi i32 [ %14, %12 ], [ %406, %403 ]
%30 = phi i32 [ %10, %12 ], [ %405, %403 ]
%31 = phi i32 [ %9, %12 ], [ %404, %403 ]
%32 = phi i32 [ %15, %12 ], [ %409, %403 ]
%33 = phi i32 [ %16, %12 ], [ %408, %403 ]
%34 = shl i32 %26, 3
%35 = load float, float* %2
%36 = load float, float* %20
%37 = zext i32 %33 to i64
%38 = icmp eq i32 %27, 0
br i1 %38, label %403, label %39
39: ; preds = %25
%40 = or i32 %34, 1
%41 = load float, float* %24
%42 = load float, float* %22
%43 = shl nsw i32 %30, 2
%44 = add nsw i32 %31, -1
%45 = icmp eq i32 %44, 0
%46 = zext i32 %34 to i64
%47 = zext i32 %40 to i64
%48 = zext i32 %32 to i64
%49 = sdiv i32 %27, 2
%50 = sext i32 %29 to i64
%51 = sub nsw i64 0, %50
%52 = sext i32 %30 to i64
%53 = sub nsw i64 0, %52
br label %54
54: ; preds = %39, %235
%55 = phi float [ %41, %39 ], [ %399, %235 ]
%56 = phi float [ %42, %39 ], [ %397, %235 ]
%57 = phi float [ %36, %39 ], [ %376, %235 ]
%58 = phi float [ %35, %39 ], [ %375, %235 ]
%59 = phi float [ %36, %39 ], [ %353, %235 ]
%60 = phi float [ %35, %39 ], [ %352, %235 ]
%61 = phi float [ %36, %39 ], [ %351, %235 ]
%62 = phi float [ %35, %39 ], [ %356, %235 ]
%63 = phi float* [ %20, %39 ], [ %312, %235 ]
%64 = phi float* [ %2, %39 ], [ %311, %235 ]
%65 = phi float* [ %20, %39 ], [ %310, %235 ]
%66 = phi float* [ %2, %39 ], [ %309, %235 ]
%67 = phi float* [ %20, %39 ], [ %308, %235 ]
%68 = phi float* [ %2, %39 ], [ %306, %235 ]
%69 = phi float* [ %0, %39 ], [ %313, %235 ]
%70 = phi i32 [ %27, %39 ], [ %401, %235 ]
%71 = phi i32 [ %43, %39 ], [ %304, %235 ]
%72 = getelementptr inbounds float, float* %69, i64 %37
%73 = getelementptr inbounds float, float* %72, i64 %37
%74 = getelementptr inbounds float, float* %73, i64 %37
%75 = load float, float* %69
%76 = getelementptr inbounds float, float* %69, i64 1
%77 = load float, float* %76
%78 = load float, float* %72
%79 = getelementptr inbounds float, float* %72, i64 1
%80 = load float, float* %79
br i1 %45, label %235, label %81
81: ; preds = %54, %81
%82 = phi i32 [ %233, %81 ], [ %44, %54 ]
%83 = phi float [ %212, %81 ], [ %80, %54 ]
%84 = phi float [ %210, %81 ], [ %78, %54 ]
%85 = phi float [ %208, %81 ], [ %77, %54 ]
%86 = phi float [ %206, %81 ], [ %75, %54 ]
%87 = phi float* [ %232, %81 ], [ %74, %54 ]
%88 = phi float* [ %231, %81 ], [ %73, %54 ]
%89 = phi float* [ %209, %81 ], [ %72, %54 ]
%90 = phi float* [ %205, %81 ], [ %69, %54 ]
%91 = load float, float* %88
%92 = getelementptr inbounds float, float* %88, i64 1
%93 = load float, float* %92
%94 = load float, float* %87
%95 = getelementptr inbounds float, float* %87, i64 1
%96 = load float, float* %95
%97 = tail call float @llvm.fmuladd.f32(float %84, float %62, float %86)
%98 = tail call float @llvm.fmuladd.f32(float %83, float %61, float %97)
%99 = fneg float %84
%100 = tail call float @llvm.fmuladd.f32(float %99, float %61, float %85)
%101 = tail call float @llvm.fmuladd.f32(float %83, float %62, float %100)
%102 = fneg float %98
%103 = tail call float @llvm.fmuladd.f32(float %86, float 2.000000e+00, float %102)
%104 = fneg float %101
%105 = tail call float @llvm.fmuladd.f32(float %85, float 2.000000e+00, float %104)
%106 = getelementptr inbounds float, float* %90, i64 %46
%107 = load float, float* %106
%108 = getelementptr inbounds float, float* %90, i64 %47
%109 = load float, float* %108
%110 = getelementptr inbounds float, float* %89, i64 %46
%111 = load float, float* %110
%112 = getelementptr inbounds float, float* %89, i64 %47
%113 = load float, float* %112
%114 = getelementptr inbounds float, float* %88, i64 %46
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %88, i64 %47
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %87, i64 %46
%119 = load float, float* %118
%120 = getelementptr inbounds float, float* %87, i64 %47
%121 = load float, float* %120
%122 = fneg float %94
%123 = tail call float @llvm.fmuladd.f32(float %122, float %62, float %91)
%124 = fneg float %96
%125 = tail call float @llvm.fmuladd.f32(float %124, float %61, float %123)
%126 = tail call float @llvm.fmuladd.f32(float %94, float %61, float %93)
%127 = tail call float @llvm.fmuladd.f32(float %124, float %62, float %126)
%128 = fneg float %125
%129 = tail call float @llvm.fmuladd.f32(float %91, float 2.000000e+00, float %128)
%130 = fneg float %127
%131 = tail call float @llvm.fmuladd.f32(float %93, float 2.000000e+00, float %130)
%132 = tail call float @llvm.fmuladd.f32(float %129, float %60, float %98)
%133 = tail call float @llvm.fmuladd.f32(float %131, float %59, float %132)
%134 = fneg float %129
%135 = tail call float @llvm.fmuladd.f32(float %134, float %59, float %101)
%136 = tail call float @llvm.fmuladd.f32(float %131, float %60, float %135)
%137 = fneg float %133
%138 = tail call float @llvm.fmuladd.f32(float %98, float 2.000000e+00, float %137)
%139 = fneg float %136
%140 = tail call float @llvm.fmuladd.f32(float %101, float 2.000000e+00, float %139)
%141 = tail call float @llvm.fmuladd.f32(float %125, float %59, float %103)
%142 = tail call float @llvm.fmuladd.f32(float %130, float %60, float %141)
%143 = tail call float @llvm.fmuladd.f32(float %125, float %60, float %105)
%144 = tail call float @llvm.fmuladd.f32(float %127, float %59, float %143)
%145 = fneg float %142
%146 = tail call float @llvm.fmuladd.f32(float %103, float 2.000000e+00, float %145)
%147 = fneg float %144
%148 = tail call float @llvm.fmuladd.f32(float %105, float 2.000000e+00, float %147)
%149 = tail call float @llvm.fmuladd.f32(float %111, float %62, float %107)
%150 = tail call float @llvm.fmuladd.f32(float %113, float %61, float %149)
%151 = fneg float %111
%152 = tail call float @llvm.fmuladd.f32(float %151, float %61, float %109)
%153 = tail call float @llvm.fmuladd.f32(float %113, float %62, float %152)
%154 = fneg float %150
%155 = tail call float @llvm.fmuladd.f32(float %107, float 2.000000e+00, float %154)
%156 = fneg float %153
%157 = tail call float @llvm.fmuladd.f32(float %109, float 2.000000e+00, float %156)
%158 = fneg float %119
%159 = tail call float @llvm.fmuladd.f32(float %158, float %62, float %115)
%160 = fneg float %121
%161 = tail call float @llvm.fmuladd.f32(float %160, float %61, float %159)
%162 = tail call float @llvm.fmuladd.f32(float %119, float %61, float %117)
%163 = tail call float @llvm.fmuladd.f32(float %160, float %62, float %162)
%164 = fneg float %161
%165 = tail call float @llvm.fmuladd.f32(float %115, float 2.000000e+00, float %164)
%166 = fneg float %163
%167 = tail call float @llvm.fmuladd.f32(float %117, float 2.000000e+00, float %166)
%168 = tail call float @llvm.fmuladd.f32(float %165, float %60, float %150)
%169 = tail call float @llvm.fmuladd.f32(float %167, float %59, float %168)
%170 = fneg float %165
%171 = tail call float @llvm.fmuladd.f32(float %170, float %59, float %153)
%172 = tail call float @llvm.fmuladd.f32(float %167, float %60, float %171)
%173 = fneg float %169
%174 = tail call float @llvm.fmuladd.f32(float %150, float 2.000000e+00, float %173)
%175 = fneg float %172
%176 = tail call float @llvm.fmuladd.f32(float %153, float 2.000000e+00, float %175)
%177 = tail call float @llvm.fmuladd.f32(float %161, float %59, float %155)
%178 = tail call float @llvm.fmuladd.f32(float %166, float %60, float %177)
%179 = tail call float @llvm.fmuladd.f32(float %161, float %60, float %157)
%180 = tail call float @llvm.fmuladd.f32(float %163, float %59, float %179)
%181 = fneg float %178
%182 = tail call float @llvm.fmuladd.f32(float %155, float 2.000000e+00, float %181)
%183 = fneg float %180
%184 = tail call float @llvm.fmuladd.f32(float %157, float 2.000000e+00, float %183)
%185 = tail call float @llvm.fmuladd.f32(float %173, float %58, float %133)
%186 = tail call float @llvm.fmuladd.f32(float %175, float %57, float %185)
%187 = tail call float @llvm.fmuladd.f32(float %169, float %57, float %136)
%188 = tail call float @llvm.fmuladd.f32(float %175, float %58, float %187)
%189 = fneg float %186
%190 = tail call float @llvm.fmuladd.f32(float %133, float 2.000000e+00, float %189)
%191 = fneg float %188
%192 = tail call float @llvm.fmuladd.f32(float %136, float 2.000000e+00, float %191)
%193 = fneg float %182
%194 = tail call float @llvm.fmuladd.f32(float %193, float %56, float %146)
%195 = fneg float %184
%196 = tail call float @llvm.fmuladd.f32(float %195, float %55, float %194)
%197 = tail call float @llvm.fmuladd.f32(float %182, float %55, float %148)
%198 = tail call float @llvm.fmuladd.f32(float %195, float %56, float %197)
%199 = fneg float %196
%200 = tail call float @llvm.fmuladd.f32(float %146, float 2.000000e+00, float %199)
%201 = fneg float %198
%202 = tail call float @llvm.fmuladd.f32(float %148, float 2.000000e+00, float %201)
store float %186, float* %106
store float %196, float* %110
store float %188, float* %108
store float %198, float* %112
store float %190, float* %90
store float %200, float* %89
%203 = getelementptr inbounds float, float* %90, i64 1
store float %192, float* %203
%204 = getelementptr inbounds float, float* %89, i64 1
store float %202, float* %204
%205 = getelementptr inbounds float, float* %90, i64 %48
%206 = load float, float* %205
%207 = getelementptr inbounds float, float* %205, i64 1
%208 = load float, float* %207
%209 = getelementptr inbounds float, float* %89, i64 %48
%210 = load float, float* %209
%211 = getelementptr inbounds float, float* %209, i64 1
%212 = load float, float* %211
%213 = fneg float %174
%214 = tail call float @llvm.fmuladd.f32(float %213, float %57, float %138)
%215 = tail call float @llvm.fmuladd.f32(float %176, float %58, float %214)
%216 = tail call float @llvm.fmuladd.f32(float %213, float %58, float %140)
%217 = fneg float %176
%218 = tail call float @llvm.fmuladd.f32(float %217, float %57, float %216)
%219 = fneg float %215
%220 = tail call float @llvm.fmuladd.f32(float %138, float 2.000000e+00, float %219)
%221 = fneg float %218
%222 = tail call float @llvm.fmuladd.f32(float %140, float 2.000000e+00, float %221)
%223 = tail call float @llvm.fmuladd.f32(float %181, float %55, float %142)
%224 = tail call float @llvm.fmuladd.f32(float %180, float %56, float %223)
%225 = tail call float @llvm.fmuladd.f32(float %181, float %56, float %144)
%226 = tail call float @llvm.fmuladd.f32(float %183, float %55, float %225)
%227 = fneg float %224
%228 = tail call float @llvm.fmuladd.f32(float %142, float 2.000000e+00, float %227)
%229 = fneg float %226
%230 = tail call float @llvm.fmuladd.f32(float %144, float 2.000000e+00, float %229)
store float %215, float* %88
store float %224, float* %87
store float %218, float* %92
store float %226, float* %95
store float %220, float* %114
store float %228, float* %118
store float %222, float* %116
store float %230, float* %120
%231 = getelementptr inbounds float, float* %88, i64 %48
%232 = getelementptr inbounds float, float* %87, i64 %48
%233 = add i32 %82, -1
%234 = icmp eq i32 %233, 0
br i1 %234, label %235, label %81
235: ; preds = %81, %54
%236 = phi float* [ %69, %54 ], [ %205, %81 ]
%237 = phi float* [ %72, %54 ], [ %209, %81 ]
%238 = phi float* [ %73, %54 ], [ %231, %81 ]
%239 = phi float* [ %74, %54 ], [ %232, %81 ]
%240 = phi float [ %75, %54 ], [ %206, %81 ]
%241 = phi float [ %77, %54 ], [ %208, %81 ]
%242 = phi float [ %78, %54 ], [ %210, %81 ]
%243 = phi float [ %80, %54 ], [ %212, %81 ]
%244 = load float, float* %238
%245 = getelementptr inbounds float, float* %238, i64 1
%246 = load float, float* %245
%247 = load float, float* %239
%248 = getelementptr inbounds float, float* %239, i64 1
%249 = load float, float* %248
%250 = tail call float @llvm.fmuladd.f32(float %242, float %62, float %240)
%251 = tail call float @llvm.fmuladd.f32(float %243, float %61, float %250)
%252 = fneg float %242
%253 = tail call float @llvm.fmuladd.f32(float %252, float %61, float %241)
%254 = tail call float @llvm.fmuladd.f32(float %243, float %62, float %253)
%255 = fneg float %251
%256 = tail call float @llvm.fmuladd.f32(float %240, float 2.000000e+00, float %255)
%257 = fneg float %254
%258 = tail call float @llvm.fmuladd.f32(float %241, float 2.000000e+00, float %257)
%259 = getelementptr inbounds float, float* %236, i64 %46
%260 = load float, float* %259
%261 = getelementptr inbounds float, float* %236, i64 %47
%262 = load float, float* %261
%263 = getelementptr inbounds float, float* %237, i64 %46
%264 = load float, float* %263
%265 = getelementptr inbounds float, float* %237, i64 %47
%266 = load float, float* %265
%267 = getelementptr inbounds float, float* %238, i64 %46
%268 = load float, float* %267
%269 = getelementptr inbounds float, float* %238, i64 %47
%270 = load float, float* %269
%271 = getelementptr inbounds float, float* %239, i64 %46
%272 = load float, float* %271
%273 = getelementptr inbounds float, float* %239, i64 %47
%274 = load float, float* %273
%275 = fneg float %247
%276 = tail call float @llvm.fmuladd.f32(float %275, float %62, float %244)
%277 = fneg float %249
%278 = tail call float @llvm.fmuladd.f32(float %277, float %61, float %276)
%279 = tail call float @llvm.fmuladd.f32(float %247, float %61, float %246)
%280 = tail call float @llvm.fmuladd.f32(float %277, float %62, float %279)
%281 = fneg float %278
%282 = tail call float @llvm.fmuladd.f32(float %244, float 2.000000e+00, float %281)
%283 = fneg float %280
%284 = tail call float @llvm.fmuladd.f32(float %246, float 2.000000e+00, float %283)
%285 = tail call float @llvm.fmuladd.f32(float %282, float %60, float %251)
%286 = tail call float @llvm.fmuladd.f32(float %284, float %59, float %285)
%287 = fneg float %282
%288 = tail call float @llvm.fmuladd.f32(float %287, float %59, float %254)
%289 = tail call float @llvm.fmuladd.f32(float %284, float %60, float %288)
%290 = fneg float %286
%291 = tail call float @llvm.fmuladd.f32(float %251, float 2.000000e+00, float %290)
%292 = fneg float %289
%293 = tail call float @llvm.fmuladd.f32(float %254, float 2.000000e+00, float %292)
%294 = tail call float @llvm.fmuladd.f32(float %278, float %59, float %256)
%295 = tail call float @llvm.fmuladd.f32(float %283, float %60, float %294)
%296 = tail call float @llvm.fmuladd.f32(float %278, float %60, float %258)
%297 = tail call float @llvm.fmuladd.f32(float %280, float %59, float %296)
%298 = fneg float %295
%299 = tail call float @llvm.fmuladd.f32(float %256, float 2.000000e+00, float %298)
%300 = fneg float %297
%301 = tail call float @llvm.fmuladd.f32(float %258, float 2.000000e+00, float %300)
%302 = icmp eq i32 %70, %49
%303 = sub nsw i32 0, %71
%304 = select i1 %302, i32 %303, i32 %71
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float, float* %68, i64 %305
%307 = sub nsw i64 0, %305
%308 = getelementptr inbounds float, float* %67, i64 %307
%309 = getelementptr inbounds float, float* %66, i64 %50
%310 = getelementptr inbounds float, float* %65, i64 %51
%311 = getelementptr inbounds float, float* %64, i64 %52
%312 = getelementptr inbounds float, float* %63, i64 %53
%313 = getelementptr inbounds float, float* %69, i64 2
%314 = tail call float @llvm.fmuladd.f32(float %264, float %62, float %260)
%315 = tail call float @llvm.fmuladd.f32(float %266, float %61, float %314)
%316 = fneg float %264
%317 = tail call float @llvm.fmuladd.f32(float %316, float %61, float %262)
%318 = tail call float @llvm.fmuladd.f32(float %266, float %62, float %317)
%319 = fneg float %315
%320 = tail call float @llvm.fmuladd.f32(float %260, float 2.000000e+00, float %319)
%321 = fneg float %318
%322 = tail call float @llvm.fmuladd.f32(float %262, float 2.000000e+00, float %321)
%323 = fneg float %272
%324 = tail call float @llvm.fmuladd.f32(float %323, float %62, float %268)
%325 = fneg float %274
%326 = tail call float @llvm.fmuladd.f32(float %325, float %61, float %324)
%327 = tail call float @llvm.fmuladd.f32(float %272, float %61, float %270)
%328 = tail call float @llvm.fmuladd.f32(float %325, float %62, float %327)
%329 = fneg float %326
%330 = tail call float @llvm.fmuladd.f32(float %268, float 2.000000e+00, float %329)
%331 = fneg float %328
%332 = tail call float @llvm.fmuladd.f32(float %270, float 2.000000e+00, float %331)
%333 = tail call float @llvm.fmuladd.f32(float %330, float %60, float %315)
%334 = tail call float @llvm.fmuladd.f32(float %332, float %59, float %333)
%335 = fneg float %330
%336 = tail call float @llvm.fmuladd.f32(float %335, float %59, float %318)
%337 = tail call float @llvm.fmuladd.f32(float %332, float %60, float %336)
%338 = fneg float %334
%339 = tail call float @llvm.fmuladd.f32(float %315, float 2.000000e+00, float %338)
%340 = fneg float %337
%341 = tail call float @llvm.fmuladd.f32(float %318, float 2.000000e+00, float %340)
%342 = tail call float @llvm.fmuladd.f32(float %326, float %59, float %320)
%343 = tail call float @llvm.fmuladd.f32(float %331, float %60, float %342)
%344 = tail call float @llvm.fmuladd.f32(float %326, float %60, float %322)
%345 = tail call float @llvm.fmuladd.f32(float %328, float %59, float %344)
%346 = fneg float %343
%347 = tail call float @llvm.fmuladd.f32(float %320, float 2.000000e+00, float %346)
%348 = fneg float %345
%349 = tail call float @llvm.fmuladd.f32(float %322, float 2.000000e+00, float %348)
%350 = load float, float* %306
%351 = load float, float* %308
%352 = load float, float* %309
%353 = load float, float* %310
%354 = icmp sgt i32 %70, %49
%355 = fneg float %350
%356 = select i1 %354, float %350, float %355
%357 = tail call float @llvm.fmuladd.f32(float %338, float %58, float %286)
%358 = tail call float @llvm.fmuladd.f32(float %340, float %57, float %357)
%359 = tail call float @llvm.fmuladd.f32(float %334, float %57, float %289)
%360 = tail call float @llvm.fmuladd.f32(float %340, float %58, float %359)
%361 = fneg float %358
%362 = tail call float @llvm.fmuladd.f32(float %286, float 2.000000e+00, float %361)
%363 = fneg float %360
%364 = tail call float @llvm.fmuladd.f32(float %289, float 2.000000e+00, float %363)
%365 = fneg float %339
%366 = tail call float @llvm.fmuladd.f32(float %365, float %57, float %291)
%367 = tail call float @llvm.fmuladd.f32(float %341, float %58, float %366)
%368 = tail call float @llvm.fmuladd.f32(float %365, float %58, float %293)
%369 = fneg float %341
%370 = tail call float @llvm.fmuladd.f32(float %369, float %57, float %368)
%371 = fneg float %367
%372 = tail call float @llvm.fmuladd.f32(float %291, float 2.000000e+00, float %371)
%373 = fneg float %370
%374 = tail call float @llvm.fmuladd.f32(float %293, float 2.000000e+00, float %373)
store float %358, float* %259
store float %367, float* %238
store float %360, float* %261
store float %370, float* %245
%375 = load float, float* %311
%376 = load float, float* %312
store float %362, float* %236
store float %372, float* %267
%377 = getelementptr inbounds float, float* %236, i64 1
store float %364, float* %377
store float %374, float* %269
%378 = fneg float %347
%379 = tail call float @llvm.fmuladd.f32(float %378, float %56, float %299)
%380 = fneg float %349
%381 = tail call float @llvm.fmuladd.f32(float %380, float %55, float %379)
%382 = tail call float @llvm.fmuladd.f32(float %347, float %55, float %301)
%383 = tail call float @llvm.fmuladd.f32(float %380, float %56, float %382)
%384 = fneg float %381
%385 = tail call float @llvm.fmuladd.f32(float %299, float 2.000000e+00, float %384)
%386 = fneg float %383
%387 = tail call float @llvm.fmuladd.f32(float %301, float 2.000000e+00, float %386)
%388 = tail call float @llvm.fmuladd.f32(float %346, float %55, float %295)
%389 = tail call float @llvm.fmuladd.f32(float %345, float %56, float %388)
%390 = tail call float @llvm.fmuladd.f32(float %346, float %56, float %297)
%391 = tail call float @llvm.fmuladd.f32(float %348, float %55, float %390)
%392 = fneg float %389
%393 = tail call float @llvm.fmuladd.f32(float %295, float 2.000000e+00, float %392)
%394 = fneg float %391
%395 = tail call float @llvm.fmuladd.f32(float %297, float 2.000000e+00, float %394)
store float %381, float* %263
store float %389, float* %239
store float %383, float* %265
store float %391, float* %248
%396 = getelementptr inbounds float, float* %311, i64 %21
%397 = load float, float* %396
%398 = getelementptr inbounds float, float* %312, i64 %23
%399 = load float, float* %398
store float %385, float* %237
store float %393, float* %271
%400 = getelementptr inbounds float, float* %237, i64 1
store float %387, float* %400
store float %395, float* %273
%401 = add i32 %70, -1
%402 = icmp eq i32 %401, 0
br i1 %402, label %403, label %54
403: ; preds = %235, %25
%404 = lshr i32 %31, 3
%405 = sdiv i32 %30, 8
%406 = sdiv i32 %29, 8
%407 = shl nsw i32 %27, 3
%408 = shl i32 %33, 3
%409 = shl i32 %32, 3
%410 = add nsw i32 %28, -1
%411 = icmp sgt i32 %28, 1
br i1 %411, label %25, label %412
412: ; preds = %403, %6
ret void
}