void ifrstage(float *ioptr, long M, float *Utbl) {
  unsigned long pos;
  unsigned long posi;
  unsigned long 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
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  0xee4(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x1,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x3,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%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    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x6c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x74(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
shl    $0x1,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rcx
sub    $0x3,%rcx
mov    $0x1,%eax
shl    %cl,%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jbe    17f1 <ifrstage+0x6f1>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x84(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x84(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x68(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x84(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x84(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x70(%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  -0x74(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x50(%rbp)
movss  -0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1477 <ifrstage+0x377>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ifrstage>:
lea    -0x1(%rsi),%ecx
mov    $0x1,%r9d
shl    %cl,%r9
mov    $0x1,%eax
mov    %r9,%r11
and    $0xfffffffffffffffe,%r11
lea    (%rdi,%r11,2),%r10
lea    -0x3(%rsi),%ecx
mov    $0x1,%r8d
shl    %cl,%r8
movss  (%rdx,%r8,4),%xmm8
movss  (%rdi),%xmm1
movss  0x4(%rdi),%xmm4
movss  (%rdi,%r9,4),%xmm9
movss  0x4(%rdi,%r9,4),%xmm6
movss  (%rdi,%r11,2),%xmm0
movss  0x4(%rdi,%r11,2),%xmm7
movss  (%r10,%r9,4),%xmm2
movss  0x4(%r10,%r9,4),%xmm11
movaps %xmm1,%xmm10
addss  %xmm4,%xmm10
subss  %xmm4,%xmm1
addss  %xmm9,%xmm9
movaps 0xe89(%rip),%xmm3
movaps %xmm6,%xmm5
xorps  %xmm3,%xmm5
subss  %xmm6,%xmm5
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
movaps %xmm7,%xmm6
subss  %xmm11,%xmm6
subss  %xmm2,%xmm0
addss  %xmm11,%xmm7
xorps  %xmm8,%xmm3
mulss  %xmm8,%xmm0
movaps %xmm4,%xmm2
subss  %xmm0,%xmm2
mulss  %xmm7,%xmm3
addss  %xmm3,%xmm2
addss  %xmm6,%xmm0
addss  %xmm3,%xmm0
addss  %xmm4,%xmm4
subss  %xmm2,%xmm4
addss  %xmm6,%xmm6
movss  %xmm10,(%rdi)
movss  %xmm1,0x4(%rdi)
movss  %xmm9,(%rdi,%r9,4)
movss  %xmm5,0x4(%rdi,%r9,4)
movss  %xmm2,(%rdi,%r11,2)
movss  %xmm0,0x4(%rdi,%r11,2)
subss  %xmm6,%xmm0
movss  %xmm4,(%r10,%r9,4)
movss  %xmm0,0x4(%r10,%r9,4)
lea    -0x2(%rsi),%ecx
mov    $0xffffffffffffffff,%rsi
shl    %cl,%rsi
cmp    $0x1,%r8
je     135b <ifrstage+0x25b>
mov    %rsi,%rcx
not    %rcx
movss  (%rdx,%rcx,4),%xmm11
movss  0x4(%rdx),%xmm9
shl    $0x2,%rsi
neg    %rsi
lea    (%rdi,%r9,4),%rcx
xchg   %ax,%ax
movss  (%rdi,%rax,8),%xmm3
movss  0x4(%rdi,%rax,8),%xmm7
movss  -0x8(%rcx,%rsi,2),%xmm0
movss  -0x4(%rcx,%rsi,2),%xmm5
movss  -0x8(%rdi,%rsi,2),%xmm2
movss  (%rcx,%rax,8),%xmm8
movaps %xmm3,%xmm6
addss  %xmm0,%xmm6
movaps %xmm7,%xmm12
subss  %xmm5,%xmm12
subss  %xmm0,%xmm3
addss  %xmm5,%xmm7
movaps %xmm9,%xmm10
mulss  %xmm7,%xmm10
mulss  %xmm11,%xmm7
movaps %xmm2,%xmm5
subss  %xmm8,%xmm2
movaps %xmm9,%xmm13
mulss  %xmm2,%xmm13
movaps %xmm11,%xmm1
mulss  %xmm11,%xmm2
mulss  %xmm3,%xmm11
movaps %xmm6,%xmm4
subss  %xmm11,%xmm4
subss  %xmm10,%xmm4
movss  -0x4(%rdi,%rsi,2),%xmm0
mulss  %xmm9,%xmm3
addss  %xmm12,%xmm3
subss  %xmm7,%xmm3
movss  0x4(%rcx,%rax,8),%xmm7
addss  %xmm6,%xmm6
subss  %xmm4,%xmm6
addss  %xmm12,%xmm12
movss  %xmm4,(%rdi,%rax,8)
movss  %xmm3,0x4(%rdi,%rax,8)
subss  %xmm12,%xmm3
addss  %xmm8,%xmm5
movaps %xmm0,%xmm4
subss  %xmm7,%xmm4
addss  %xmm7,%xmm0
movaps %xmm5,%xmm7
subss  %xmm13,%xmm7
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm7
addss  %xmm4,%xmm2
mulss  %xmm9,%xmm0
subss  %xmm0,%xmm2
addss  %xmm5,%xmm5
subss  %xmm7,%xmm5
addss  %xmm4,%xmm4
movss  %xmm6,-0x8(%rcx,%rsi,2)
movss  %xmm3,-0x4(%rcx,%rsi,2)
movss  0x4(%rdx,%rax,4),%xmm9
movss  -0x8(%rdx,%rsi,1),%xmm11
movss  %xmm7,-0x8(%rdi,%rsi,2)
movss  %xmm2,-0x4(%rdi,%rsi,2)
subss  %xmm4,%xmm2
movss  %xmm5,(%rcx,%rax,8)
movss  %xmm2,0x4(%rcx,%rax,8)
add    $0x1,%rax
add    $0xfffffffffffffffc,%rsi
cmp    %rax,%r8
jne    1230 <ifrstage+0x130>
ret

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

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