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

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void 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 = ((uint32_t)1 << (M - 1));
  posi = pos + 1;
  p0r = ioptr;
  p1r = ioptr + pos / 2;
  u0r = Utbl + ((uint32_t)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 + (((uint32_t)1 << (M - 2)) - 1);
  w0r = *u0r;
  w0i = *u0i;
  p0r = (ioptr + 2);
  p1r = (ioptr + (((uint32_t)1 << (M - 2)) - 1) * 2);
  for (diffUcnt = ((uint32_t)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),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
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    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
movslq %ecx,%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    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%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    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    1797 <ifrstage+0x697>
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    144d <ifrstage+0x34d>
add    $0x8,%rsp
pop    %rbp
ret

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

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