void ifrstage(float *ioptr, int M, float *Utbl) {
  unsigned int pos;
  unsigned int posi;
  unsigned int diffUcnt;
  float *p0r, *p1r;
  float *u0r, *u0i;
  float w0r, w0i;
  float f0r, f0i, f1r, f1i, f4r, f4i, f5r, f5i;
  float t0r, t0i, t1r, t1i;
  const float Two = 2.0;
  pos = ((unsigned long)1 << (M - 1));
  posi = pos + 1;
  p0r = ioptr;
  p1r = ioptr + pos / 2;
  u0r = Utbl + ((unsigned long)1 << (M - 3));
  w0r = *u0r, f0r = *(p0r);
  f0i = *(p0r + 1);
  f4r = *(p0r + pos);
  f4i = *(p0r + posi);
  f1r = *(p1r);
  f1i = *(p1r + 1);
  f5r = *(p1r + pos);
  f5i = *(p1r + posi);
  t0r = f0r + f0i;
  t0i = f0r - f0i;
  t1r = f4r + f4r;
  t1i = -f4i - f4i;
  f0r = f1r + f5r;
  f0i = f1i - f5i;
  f4r = f1r - f5r;
  f4i = f1i + f5i;
  f1r = f0r - w0r * f4r - w0r * f4i;
  f1i = f0i + w0r * f4r - w0r * f4i;
  f5r = Two * f0r - f1r;
  f5i = f1i - Two * f0i;
  *(p0r) = t0r;
  *(p0r + 1) = t0i;
  *(p0r + pos) = t1r;
  *(p0r + posi) = t1i;
  *(p1r) = f1r;
  *(p1r + 1) = f1i;
  *(p1r + pos) = f5r;
  *(p1r + posi) = f5i;
  u0r = Utbl + 1;
  u0i = Utbl + (((unsigned long)1 << (M - 2)) - 1);
  w0r = *u0r, w0i = *u0i;
  p0r = (ioptr + 2);
  p1r = (ioptr + (((unsigned long)1 << (M - 2)) - 1) * 2);
  for (diffUcnt = ((unsigned long)1 << (M - 3)) - 1; diffUcnt > 0; diffUcnt--) {
    f0r = *(p0r);
    f0i = *(p0r + 1);
    f5r = *(p1r + pos);
    f5i = *(p1r + posi);
    f1r = *(p1r);
    f1i = *(p1r + 1);
    f4r = *(p0r + pos);
    f4i = *(p0r + posi);
    t0r = f0r + f5r;
    t0i = f0i - f5i;
    t1r = f0r - f5r;
    t1i = f0i + f5i;
    f0r = t0r - w0i * t1r - w0r * t1i;
    f0i = t0i + w0r * t1r - w0i * t1i;
    f5r = Two * t0r - f0r;
    f5i = f0i - Two * t0i;
    t0r = f1r + f4r;
    t0i = f1i - f4i;
    t1r = f1r - f4r;
    t1i = f1i + f4i;
    f1r = t0r - w0r * t1r - w0i * t1i;
    f1i = t0i + w0i * t1r - w0r * t1i;
    f4r = Two * t0r - f1r;
    f4i = f1i - Two * t0i;
    *(p0r) = f0r;
    *(p0r + 1) = f0i;
    *(p1r + pos) = f5r;
    *(p1r + posi) = f5i;
    w0r = *++u0r;
    w0i = *--u0i;
    *(p1r) = f1r;
    *(p1r + 1) = f1i;
    *(p0r + pos) = f4r;
    *(p0r + posi) = f4i;
    p0r += 2;
    p1r -= 2;
  };
}


x86 assembly (clang, -O0):
<ifrstage>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movss  0xee8(%rip),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
mov    %ecx,%ecx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
mov    %ecx,%ecx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
mov    %ecx,%ecx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
shl    $0x1,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x3,%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
sub    $0x1,%rax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    17a8 <ifrstage+0x6a8>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rbp)
movss  -0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    145e <ifrstage+0x35e>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ifrstage>:
lea    -0x1(%rsi),%ecx
mov    $0x1,%r10d
mov    $0x1,%eax
shl    %cl,%rax
lea    0x1(%rax),%r8d
mov    %eax,%r9d
and    $0xfffffffe,%eax
lea    (%rdi,%rax,2),%r11
lea    -0x3(%rsi),%ecx
shl    %cl,%r10
movss  (%rdx,%r10,4),%xmm8
movss  (%rdi),%xmm11
movss  0x4(%rdi),%xmm4
movss  (%rdi,%r9,4),%xmm9
movss  (%rdi,%r8,4),%xmm7
movss  (%rdi,%rax,2),%xmm0
movss  0x4(%rdi,%rax,2),%xmm6
movss  (%r11,%r9,4),%xmm2
movss  (%r11,%r8,4),%xmm3
movaps %xmm11,%xmm10
addss  %xmm4,%xmm10
subss  %xmm4,%xmm11
addss  %xmm9,%xmm9
movaps 0xe8e(%rip),%xmm1
movaps %xmm7,%xmm5
xorps  %xmm1,%xmm5
subss  %xmm7,%xmm5
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
movaps %xmm6,%xmm7
subss  %xmm3,%xmm7
subss  %xmm2,%xmm0
addss  %xmm3,%xmm6
xorps  %xmm8,%xmm1
mulss  %xmm8,%xmm0
movaps %xmm4,%xmm2
subss  %xmm0,%xmm2
mulss  %xmm6,%xmm1
addss  %xmm1,%xmm2
addss  %xmm7,%xmm0
addss  %xmm1,%xmm0
addss  %xmm4,%xmm4
subss  %xmm2,%xmm4
addss  %xmm7,%xmm7
movss  %xmm10,(%rdi)
movss  %xmm11,0x4(%rdi)
movss  %xmm9,(%rdi,%r9,4)
movss  %xmm5,(%rdi,%r8,4)
movss  %xmm2,(%rdi,%rax,2)
movss  %xmm0,0x4(%rdi,%rax,2)
subss  %xmm7,%xmm0
movss  %xmm4,(%r11,%r9,4)
movss  %xmm0,(%r11,%r8,4)
lea    -0x2(%rsi),%ecx
mov    $0xffffffffffffffff,%rax
shl    %cl,%rax
add    $0xffffffff,%r10d
je     138c <ifrstage+0x28c>
mov    %rax,%rcx
not    %rcx
movss  (%rdx,%rcx,4),%xmm10
movss  0x4(%rdx),%xmm9
mov    %r10d,%r10d
lea    0x0(,%rax,4),%rsi
neg    %rsi
add    %rax,%rax
mov    %r9,%r11
sub    %rax,%r11
add    $0xfffffffffffffffe,%r11
mov    %r8,%rcx
sub    %rax,%rcx
add    $0xfffffffffffffffe,%rcx
add    $0x2,%r9
add    $0x2,%r8
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  0x8(%rdi,%rax,8),%xmm3
movss  0xc(%rdi,%rax,8),%xmm7
movss  (%rdi,%r11,4),%xmm0
movss  (%rdi,%rcx,4),%xmm5
movss  -0x8(%rdi,%rsi,2),%xmm2
movss  (%rdi,%r9,4),%xmm8
movaps %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps %xmm7,%xmm13
subss  %xmm5,%xmm13
subss  %xmm0,%xmm3
addss  %xmm5,%xmm7
movaps %xmm9,%xmm11
mulss  %xmm7,%xmm11
mulss  %xmm10,%xmm7
movaps %xmm2,%xmm5
subss  %xmm8,%xmm2
movaps %xmm9,%xmm12
mulss  %xmm2,%xmm12
movaps %xmm10,%xmm0
mulss  %xmm10,%xmm2
mulss  %xmm3,%xmm10
movaps %xmm1,%xmm4
subss  %xmm10,%xmm4
subss  %xmm11,%xmm4
movss  -0x4(%rdi,%rsi,2),%xmm6
mulss  %xmm9,%xmm3
addss  %xmm13,%xmm3
subss  %xmm7,%xmm3
movss  (%rdi,%r8,4),%xmm7
addss  %xmm1,%xmm1
subss  %xmm4,%xmm1
addss  %xmm13,%xmm13
movss  %xmm4,0x8(%rdi,%rax,8)
movss  %xmm3,0xc(%rdi,%rax,8)
subss  %xmm13,%xmm3
addss  %xmm8,%xmm5
movaps %xmm6,%xmm4
subss  %xmm7,%xmm4
addss  %xmm7,%xmm6
movaps %xmm5,%xmm7
subss  %xmm12,%xmm7
mulss  %xmm6,%xmm0
subss  %xmm0,%xmm7
addss  %xmm4,%xmm2
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm2
addss  %xmm5,%xmm5
subss  %xmm7,%xmm5
addss  %xmm4,%xmm4
movss  %xmm1,(%rdi,%r11,4)
movss  %xmm3,(%rdi,%rcx,4)
movss  0x8(%rdx,%rax,4),%xmm9
movss  -0x8(%rdx,%rsi,1),%xmm10
movss  %xmm7,-0x8(%rdi,%rsi,2)
movss  %xmm2,-0x4(%rdi,%rsi,2)
subss  %xmm4,%xmm2
movss  %xmm5,(%rdi,%r9,4)
movss  %xmm2,(%rdi,%r8,4)
add    $0x1,%rax
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffe,%r11
add    $0xfffffffffffffffe,%rcx
add    $0x2,%r9
add    $0x2,%r8
cmp    %eax,%r10d
jne    1250 <ifrstage+0x150>
ret

LLVM IR (-O0):
define void @ifrstage(float* %0, i32 %1, float* %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca float*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
store float* %0, float** %4
store i32 %1, i32* %5
store float* %2, float** %6
store float 2.000000e+00, float* %28
%29 = load i32, i32* %5
%30 = sub nsw i32 %29, 1
%31 = zext i32 %30 to i64
%32 = shl i64 1, %31
%33 = trunc i64 %32 to i32
store i32 %33, i32* %7
%34 = load i32, i32* %7
%35 = add i32 %34, 1
store i32 %35, i32* %8
%36 = load float*, float** %4
store float* %36, float** %10
%37 = load float*, float** %4
%38 = load i32, i32* %7
%39 = udiv i32 %38, 2
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds float, float* %37, i64 %40
store float* %41, float** %11
%42 = load float*, float** %6
%43 = load i32, i32* %5
%44 = sub nsw i32 %43, 3
%45 = zext i32 %44 to i64
%46 = shl i64 1, %45
%47 = getelementptr inbounds float, float* %42, i64 %46
store float* %47, float** %12
%48 = load float*, float** %12
%49 = load float, float* %48
store float %49, float* %14
%50 = load float*, float** %10
%51 = load float, float* %50
store float %51, float* %16
%52 = load float*, float** %10
%53 = getelementptr inbounds float, float* %52, i64 1
%54 = load float, float* %53
store float %54, float* %17
%55 = load float*, float** %10
%56 = load i32, i32* %7
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
store float %59, float* %20
%60 = load float*, float** %10
%61 = load i32, i32* %8
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
store float %64, float* %21
%65 = load float*, float** %11
%66 = load float, float* %65
store float %66, float* %18
%67 = load float*, float** %11
%68 = getelementptr inbounds float, float* %67, i64 1
%69 = load float, float* %68
store float %69, float* %19
%70 = load float*, float** %11
%71 = load i32, i32* %7
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
store float %74, float* %22
%75 = load float*, float** %11
%76 = load i32, i32* %8
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
%79 = load float, float* %78
store float %79, float* %23
%80 = load float, float* %16
%81 = load float, float* %17
%82 = fadd float %80, %81
store float %82, float* %24
%83 = load float, float* %16
%84 = load float, float* %17
%85 = fsub float %83, %84
store float %85, float* %25
%86 = load float, float* %20
%87 = load float, float* %20
%88 = fadd float %86, %87
store float %88, float* %26
%89 = load float, float* %21
%90 = fneg float %89
%91 = load float, float* %21
%92 = fsub float %90, %91
store float %92, float* %27
%93 = load float, float* %18
%94 = load float, float* %22
%95 = fadd float %93, %94
store float %95, float* %16
%96 = load float, float* %19
%97 = load float, float* %23
%98 = fsub float %96, %97
store float %98, float* %17
%99 = load float, float* %18
%100 = load float, float* %22
%101 = fsub float %99, %100
store float %101, float* %20
%102 = load float, float* %19
%103 = load float, float* %23
%104 = fadd float %102, %103
store float %104, float* %21
%105 = load float, float* %16
%106 = load float, float* %14
%107 = load float, float* %20
%108 = fneg float %106
%109 = call float @llvm.fmuladd.f32(float %108, float %107, float %105)
%110 = load float, float* %14
%111 = load float, float* %21
%112 = fneg float %110
%113 = call float @llvm.fmuladd.f32(float %112, float %111, float %109)
store float %113, float* %18
%114 = load float, float* %17
%115 = load float, float* %14
%116 = load float, float* %20
%117 = call float @llvm.fmuladd.f32(float %115, float %116, float %114)
%118 = load float, float* %14
%119 = load float, float* %21
%120 = fneg float %118
%121 = call float @llvm.fmuladd.f32(float %120, float %119, float %117)
store float %121, float* %19
%122 = load float, float* %16
%123 = load float, float* %18
%124 = fneg float %123
%125 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %122, float %124)
store float %125, float* %22
%126 = load float, float* %19
%127 = load float, float* %17
%128 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %127, float %126)
store float %128, float* %23
%129 = load float, float* %24
%130 = load float*, float** %10
store float %129, float* %130
%131 = load float, float* %25
%132 = load float*, float** %10
%133 = getelementptr inbounds float, float* %132, i64 1
store float %131, float* %133
%134 = load float, float* %26
%135 = load float*, float** %10
%136 = load i32, i32* %7
%137 = zext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
store float %134, float* %138
%139 = load float, float* %27
%140 = load float*, float** %10
%141 = load i32, i32* %8
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds float, float* %140, i64 %142
store float %139, float* %143
%144 = load float, float* %18
%145 = load float*, float** %11
store float %144, float* %145
%146 = load float, float* %19
%147 = load float*, float** %11
%148 = getelementptr inbounds float, float* %147, i64 1
store float %146, float* %148
%149 = load float, float* %22
%150 = load float*, float** %11
%151 = load i32, i32* %7
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
store float %149, float* %153
%154 = load float, float* %23
%155 = load float*, float** %11
%156 = load i32, i32* %8
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
store float %154, float* %158
%159 = load float*, float** %6
%160 = getelementptr inbounds float, float* %159, i64 1
store float* %160, float** %12
%161 = load float*, float** %6
%162 = load i32, i32* %5
%163 = sub nsw i32 %162, 2
%164 = zext i32 %163 to i64
%165 = shl i64 1, %164
%166 = sub i64 %165, 1
%167 = getelementptr inbounds float, float* %161, i64 %166
store float* %167, float** %13
%168 = load float*, float** %12
%169 = load float, float* %168
store float %169, float* %14
%170 = load float*, float** %13
%171 = load float, float* %170
store float %171, float* %15
%172 = load float*, float** %4
%173 = getelementptr inbounds float, float* %172, i64 2
store float* %173, float** %10
%174 = load float*, float** %4
%175 = load i32, i32* %5
%176 = sub nsw i32 %175, 2
%177 = zext i32 %176 to i64
%178 = shl i64 1, %177
%179 = sub i64 %178, 1
%180 = mul i64 %179, 2
%181 = getelementptr inbounds float, float* %174, i64 %180
store float* %181, float** %11
%182 = load i32, i32* %5
%183 = sub nsw i32 %182, 3
%184 = zext i32 %183 to i64
%185 = shl i64 1, %184
%186 = sub i64 %185, 1
%187 = trunc i64 %186 to i32
store i32 %187, i32* %9
br label %188
188: ; preds = %334, %3
%189 = load i32, i32* %9
%190 = icmp ugt i32 %189, 0
br i1 %190, label %191, label %337
191: ; preds = %188
%192 = load float*, float** %10
%193 = load float, float* %192
store float %193, float* %16
%194 = load float*, float** %10
%195 = getelementptr inbounds float, float* %194, i64 1
%196 = load float, float* %195
store float %196, float* %17
%197 = load float*, float** %11
%198 = load i32, i32* %7
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds float, float* %197, i64 %199
%201 = load float, float* %200
store float %201, float* %22
%202 = load float*, float** %11
%203 = load i32, i32* %8
%204 = zext i32 %203 to i64
%205 = getelementptr inbounds float, float* %202, i64 %204
%206 = load float, float* %205
store float %206, float* %23
%207 = load float*, float** %11
%208 = load float, float* %207
store float %208, float* %18
%209 = load float*, float** %11
%210 = getelementptr inbounds float, float* %209, i64 1
%211 = load float, float* %210
store float %211, float* %19
%212 = load float*, float** %10
%213 = load i32, i32* %7
%214 = zext i32 %213 to i64
%215 = getelementptr inbounds float, float* %212, i64 %214
%216 = load float, float* %215
store float %216, float* %20
%217 = load float*, float** %10
%218 = load i32, i32* %8
%219 = zext i32 %218 to i64
%220 = getelementptr inbounds float, float* %217, i64 %219
%221 = load float, float* %220
store float %221, float* %21
%222 = load float, float* %16
%223 = load float, float* %22
%224 = fadd float %222, %223
store float %224, float* %24
%225 = load float, float* %17
%226 = load float, float* %23
%227 = fsub float %225, %226
store float %227, float* %25
%228 = load float, float* %16
%229 = load float, float* %22
%230 = fsub float %228, %229
store float %230, float* %26
%231 = load float, float* %17
%232 = load float, float* %23
%233 = fadd float %231, %232
store float %233, float* %27
%234 = load float, float* %24
%235 = load float, float* %15
%236 = load float, float* %26
%237 = fneg float %235
%238 = call float @llvm.fmuladd.f32(float %237, float %236, float %234)
%239 = load float, float* %14
%240 = load float, float* %27
%241 = fneg float %239
%242 = call float @llvm.fmuladd.f32(float %241, float %240, float %238)
store float %242, float* %16
%243 = load float, float* %25
%244 = load float, float* %14
%245 = load float, float* %26
%246 = call float @llvm.fmuladd.f32(float %244, float %245, float %243)
%247 = load float, float* %15
%248 = load float, float* %27
%249 = fneg float %247
%250 = call float @llvm.fmuladd.f32(float %249, float %248, float %246)
store float %250, float* %17
%251 = load float, float* %24
%252 = load float, float* %16
%253 = fneg float %252
%254 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %251, float %253)
store float %254, float* %22
%255 = load float, float* %17
%256 = load float, float* %25
%257 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %256, float %255)
store float %257, float* %23
%258 = load float, float* %18
%259 = load float, float* %20
%260 = fadd float %258, %259
store float %260, float* %24
%261 = load float, float* %19
%262 = load float, float* %21
%263 = fsub float %261, %262
store float %263, float* %25
%264 = load float, float* %18
%265 = load float, float* %20
%266 = fsub float %264, %265
store float %266, float* %26
%267 = load float, float* %19
%268 = load float, float* %21
%269 = fadd float %267, %268
store float %269, float* %27
%270 = load float, float* %24
%271 = load float, float* %14
%272 = load float, float* %26
%273 = fneg float %271
%274 = call float @llvm.fmuladd.f32(float %273, float %272, float %270)
%275 = load float, float* %15
%276 = load float, float* %27
%277 = fneg float %275
%278 = call float @llvm.fmuladd.f32(float %277, float %276, float %274)
store float %278, float* %18
%279 = load float, float* %25
%280 = load float, float* %15
%281 = load float, float* %26
%282 = call float @llvm.fmuladd.f32(float %280, float %281, float %279)
%283 = load float, float* %14
%284 = load float, float* %27
%285 = fneg float %283
%286 = call float @llvm.fmuladd.f32(float %285, float %284, float %282)
store float %286, float* %19
%287 = load float, float* %24
%288 = load float, float* %18
%289 = fneg float %288
%290 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %287, float %289)
store float %290, float* %20
%291 = load float, float* %19
%292 = load float, float* %25
%293 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %292, float %291)
store float %293, float* %21
%294 = load float, float* %16
%295 = load float*, float** %10
store float %294, float* %295
%296 = load float, float* %17
%297 = load float*, float** %10
%298 = getelementptr inbounds float, float* %297, i64 1
store float %296, float* %298
%299 = load float, float* %22
%300 = load float*, float** %11
%301 = load i32, i32* %7
%302 = zext i32 %301 to i64
%303 = getelementptr inbounds float, float* %300, i64 %302
store float %299, float* %303
%304 = load float, float* %23
%305 = load float*, float** %11
%306 = load i32, i32* %8
%307 = zext i32 %306 to i64
%308 = getelementptr inbounds float, float* %305, i64 %307
store float %304, float* %308
%309 = load float*, float** %12
%310 = getelementptr inbounds float, float* %309, i32 1
store float* %310, float** %12
%311 = load float, float* %310
store float %311, float* %14
%312 = load float*, float** %13
%313 = getelementptr inbounds float, float* %312, i32 -1
store float* %313, float** %13
%314 = load float, float* %313
store float %314, float* %15
%315 = load float, float* %18
%316 = load float*, float** %11
store float %315, float* %316
%317 = load float, float* %19
%318 = load float*, float** %11
%319 = getelementptr inbounds float, float* %318, i64 1
store float %317, float* %319
%320 = load float, float* %20
%321 = load float*, float** %10
%322 = load i32, i32* %7
%323 = zext i32 %322 to i64
%324 = getelementptr inbounds float, float* %321, i64 %323
store float %320, float* %324
%325 = load float, float* %21
%326 = load float*, float** %10
%327 = load i32, i32* %8
%328 = zext i32 %327 to i64
%329 = getelementptr inbounds float, float* %326, i64 %328
store float %325, float* %329
%330 = load float*, float** %10
%331 = getelementptr inbounds float, float* %330, i64 2
store float* %331, float** %10
%332 = load float*, float** %11
%333 = getelementptr inbounds float, float* %332, i64 -2
store float* %333, float** %11
br label %334
334: ; preds = %191
%335 = load i32, i32* %9
%336 = add i32 %335, -1
store i32 %336, i32* %9
br label %188
337: ; preds = %188
ret void
}

LLVM IR (-O2):
define void @ifrstage(float* nocapture %0, i32 %1, float* nocapture %2) {
%4 = add nsw i32 %1, -1
%5 = zext i32 %4 to i64
%6 = shl nuw i64 1, %5
%7 = add nuw i64 %6, 1
%8 = lshr i64 %6, 1
%9 = and i64 %8, 2147483647
%10 = getelementptr inbounds float, float* %0, i64 %9
%11 = add nsw i32 %1, -3
%12 = zext i32 %11 to i64
%13 = shl nuw i64 1, %12
%14 = getelementptr inbounds float, float* %2, i64 %13
%15 = load float, float* %14
%16 = load float, float* %0
%17 = getelementptr inbounds float, float* %0, i64 1
%18 = load float, float* %17
%19 = and i64 %6, 4294967295
%20 = getelementptr inbounds float, float* %0, i64 %19
%21 = load float, float* %20
%22 = and i64 %7, 4294967295
%23 = getelementptr inbounds float, float* %0, i64 %22
%24 = load float, float* %23
%25 = load float, float* %10
%26 = getelementptr inbounds float, float* %10, i64 1
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %10, i64 %19
%29 = load float, float* %28
%30 = getelementptr inbounds float, float* %10, i64 %22
%31 = load float, float* %30
%32 = fadd float %16, %18
%33 = fsub float %16, %18
%34 = fadd float %21, %21
%35 = fneg float %24
%36 = fsub float %35, %24
%37 = fadd float %25, %29
%38 = fsub float %27, %31
%39 = fsub float %25, %29
%40 = fadd float %27, %31
%41 = fneg float %15
%42 = tail call float @llvm.fmuladd.f32(float %41, float %39, float %37)
%43 = tail call float @llvm.fmuladd.f32(float %41, float %40, float %42)
%44 = tail call float @llvm.fmuladd.f32(float %15, float %39, float %38)
%45 = tail call float @llvm.fmuladd.f32(float %41, float %40, float %44)
%46 = fneg float %43
%47 = tail call float @llvm.fmuladd.f32(float %37, float 2.000000e+00, float %46)
%48 = tail call float @llvm.fmuladd.f32(float %38, float -2.000000e+00, float %45)
store float %32, float* %0
store float %33, float* %17
store float %34, float* %20
store float %36, float* %23
store float %43, float* %10
store float %45, float* %26
store float %47, float* %28
store float %48, float* %30
%49 = getelementptr inbounds float, float* %2, i64 1
%50 = add nsw i32 %1, -2
%51 = zext i32 %50 to i64
%52 = shl nsw i64 -1, %51
%53 = xor i64 %52, -1
%54 = getelementptr inbounds float, float* %2, i64 %53
%55 = trunc i64 %13 to i32
%56 = add i32 %55, -1
%57 = icmp eq i32 %56, 0
br i1 %57, label %117, label %58
58: ; preds = %3
%59 = shl i64 %53, 1
%60 = getelementptr inbounds float, float* %0, i64 %59
%61 = load float, float* %54
%62 = load float, float* %49
br label %63
63: ; preds = %58, %63
%64 = phi i32 [ %115, %63 ], [ %56, %58 ]
%65 = phi float [ %113, %63 ], [ %61, %58 ]
%66 = phi float [ %111, %63 ], [ %62, %58 ]
%67 = phi float* [ %112, %63 ], [ %54, %58 ]
%68 = phi float* [ %110, %63 ], [ %49, %58 ]
%69 = phi float* [ %114, %63 ], [ %60, %58 ]
%70 = phi float* [ %71, %63 ], [ %0, %58 ]
%71 = getelementptr inbounds float, float* %70, i64 2
%72 = load float, float* %71
%73 = getelementptr inbounds float, float* %70, i64 3
%74 = load float, float* %73
%75 = getelementptr inbounds float, float* %69, i64 %19
%76 = load float, float* %75
%77 = getelementptr inbounds float, float* %69, i64 %22
%78 = load float, float* %77
%79 = load float, float* %69
%80 = getelementptr inbounds float, float* %69, i64 1
%81 = load float, float* %80
%82 = getelementptr inbounds float, float* %71, i64 %19
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %71, i64 %22
%85 = load float, float* %84
%86 = fadd float %72, %76
%87 = fsub float %74, %78
%88 = fsub float %72, %76
%89 = fadd float %74, %78
%90 = fneg float %65
%91 = tail call float @llvm.fmuladd.f32(float %90, float %88, float %86)
%92 = fneg float %66
%93 = tail call float @llvm.fmuladd.f32(float %92, float %89, float %91)
%94 = tail call float @llvm.fmuladd.f32(float %66, float %88, float %87)
%95 = tail call float @llvm.fmuladd.f32(float %90, float %89, float %94)
%96 = fneg float %93
%97 = tail call float @llvm.fmuladd.f32(float %86, float 2.000000e+00, float %96)
%98 = tail call float @llvm.fmuladd.f32(float %87, float -2.000000e+00, float %95)
%99 = fadd float %79, %83
%100 = fsub float %81, %85
%101 = fsub float %79, %83
%102 = fadd float %81, %85
%103 = tail call float @llvm.fmuladd.f32(float %92, float %101, float %99)
%104 = tail call float @llvm.fmuladd.f32(float %90, float %102, float %103)
%105 = tail call float @llvm.fmuladd.f32(float %65, float %101, float %100)
%106 = tail call float @llvm.fmuladd.f32(float %92, float %102, float %105)
%107 = fneg float %104
%108 = tail call float @llvm.fmuladd.f32(float %99, float 2.000000e+00, float %107)
%109 = tail call float @llvm.fmuladd.f32(float %100, float -2.000000e+00, float %106)
store float %93, float* %71
store float %95, float* %73
store float %97, float* %75
store float %98, float* %77
%110 = getelementptr inbounds float, float* %68, i64 1
%111 = load float, float* %110
%112 = getelementptr inbounds float, float* %67, i64 -1
%113 = load float, float* %112
store float %104, float* %69
store float %106, float* %80
store float %108, float* %82
store float %109, float* %84
%114 = getelementptr inbounds float, float* %69, i64 -2
%115 = add i32 %64, -1
%116 = icmp eq i32 %115, 0
br i1 %116, label %117, label %63
117: ; preds = %63, %3
ret void
}