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

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