void frstage(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 = Two * f0r + Two * f0i;
  t0i = Two * f0r - Two * f0i;
  t1r = f4r + f4r;
  t1i = -f4i - f4i;
  f0r = f1r + f5r;
  f0i = f1i - f5i;
  f4r = f1i + f5i;
  f4i = f5r - f1r;
  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 = f0i + f5i;
    t1i = f5r - f0r;
    f0r = t0r + w0r * t1r + w0i * t1i;
    f0i = t0i - w0i * t1r + w0r * t1i;
    f5r = Two * t0r - f0r;
    f5i = f0i - Two * t0i;
    t0r = f1r + f4r;
    t0i = f1i - f4i;
    t1r = f1i + f4i;
    t1i = f4r - f1r;
    f1r = t0r + w0i * t1r + w0r * t1i;
    f1i = t0i - w0r * t1r + w0i * 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):
<frstage>:
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
movss  0xded(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x54(%rbp),%xmm0
movss  0xdce(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%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  -0x60(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x6c(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%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
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    1787 <frstage+0x687>
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  -0x58(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x6c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%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
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  -0x60(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x78(%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
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    1471 <frstage+0x371>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<frstage>:
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),%xmm0
movss  0x4(%rdi),%xmm6
movss  (%rdi,%r9,4),%xmm9
movss  (%rdi,%r8,4),%xmm7
movss  (%rdi,%rax,2),%xmm10
movss  0x4(%rdi,%rax,2),%xmm3
movss  (%r11,%r9,4),%xmm1
movss  (%r11,%r8,4),%xmm2
addss  %xmm6,%xmm6
addss  %xmm0,%xmm0
movaps %xmm0,%xmm5
addss  %xmm6,%xmm5
subss  %xmm6,%xmm0
addss  %xmm9,%xmm9
movaps 0xe89(%rip),%xmm6
xorps  %xmm7,%xmm6
subss  %xmm7,%xmm6
movaps %xmm10,%xmm7
addss  %xmm1,%xmm7
movaps %xmm3,%xmm4
subss  %xmm2,%xmm4
addss  %xmm2,%xmm3
subss  %xmm10,%xmm1
mulss  %xmm8,%xmm3
movaps %xmm4,%xmm2
subss  %xmm3,%xmm2
addss  %xmm7,%xmm3
mulss  %xmm8,%xmm1
addss  %xmm1,%xmm3
addss  %xmm2,%xmm1
addss  %xmm7,%xmm7
subss  %xmm3,%xmm7
addss  %xmm4,%xmm4
movss  %xmm5,(%rdi)
movss  %xmm0,0x4(%rdi)
movss  %xmm9,(%rdi,%r9,4)
movss  %xmm6,(%rdi,%r8,4)
movss  %xmm3,(%rdi,%rax,2)
movss  %xmm1,0x4(%rdi,%rax,2)
subss  %xmm4,%xmm1
movss  %xmm7,(%r11,%r9,4)
movss  %xmm1,(%r11,%r8,4)
lea    -0x2(%rsi),%ecx
mov    $0xffffffffffffffff,%rax
shl    %cl,%rax
add    $0xffffffff,%r10d
je     138d <frstage+0x28d>
mov    %rax,%rcx
not    %rcx
movss  (%rdx,%rcx,4),%xmm9
movss  0x4(%rdx),%xmm10
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
nopw   0x0(%rax,%rax,1)
movss  0x8(%rdi,%rax,8),%xmm0
movss  0xc(%rdi,%rax,8),%xmm7
movss  (%rdi,%r11,4),%xmm4
movss  (%rdi,%rcx,4),%xmm3
movss  -0x4(%rdi,%rsi,2),%xmm12
movss  (%rdi,%r8,4),%xmm8
movaps %xmm0,%xmm2
addss  %xmm4,%xmm2
movaps %xmm7,%xmm11
subss  %xmm3,%xmm11
addss  %xmm3,%xmm7
subss  %xmm0,%xmm4
movaps %xmm9,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm10,%xmm4
movaps %xmm12,%xmm3
addss  %xmm8,%xmm12
movaps %xmm9,%xmm1
mulss  %xmm12,%xmm1
movaps %xmm10,%xmm6
mulss  %xmm10,%xmm12
mulss  %xmm7,%xmm10
addss  %xmm2,%xmm10
addss  %xmm10,%xmm0
mulss  %xmm9,%xmm7
movaps %xmm11,%xmm5
subss  %xmm7,%xmm5
movss  -0x8(%rdi,%rsi,2),%xmm7
addss  %xmm5,%xmm4
movss  (%rdi,%r9,4),%xmm5
addss  %xmm2,%xmm2
subss  %xmm0,%xmm2
addss  %xmm11,%xmm11
movss  %xmm0,0x8(%rdi,%rax,8)
movss  %xmm4,0xc(%rdi,%rax,8)
subss  %xmm11,%xmm4
movaps %xmm7,%xmm0
addss  %xmm5,%xmm0
subss  %xmm8,%xmm3
subss  %xmm7,%xmm5
addss  %xmm0,%xmm1
mulss  %xmm5,%xmm6
addss  %xmm1,%xmm6
movaps %xmm3,%xmm1
subss  %xmm12,%xmm1
mulss  %xmm9,%xmm5
addss  %xmm1,%xmm5
addss  %xmm0,%xmm0
subss  %xmm6,%xmm0
addss  %xmm3,%xmm3
movss  %xmm2,(%rdi,%r11,4)
movss  %xmm4,(%rdi,%rcx,4)
movss  0x8(%rdx,%rax,4),%xmm10
movss  -0x8(%rdx,%rsi,1),%xmm9
movss  %xmm6,-0x8(%rdi,%rsi,2)
movss  %xmm5,-0x4(%rdi,%rsi,2)
subss  %xmm3,%xmm5
movss  %xmm0,(%rdi,%r9,4)
movss  %xmm5,(%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 <frstage+0x150>
ret

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

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