void frstage(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 = 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
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
movss  0xde3(%rip),%xmm1
mulss  -0x60(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  0xdc4(%rip),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%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  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%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
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    17d0 <frstage+0x6d0>
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  -0x60(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%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
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x80(%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
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  -0x68(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%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
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x80(%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
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    148a <frstage+0x38a>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<frstage>:
lea    -0x1(%rsi),%ecx
mov    $0x1,%eax
mov    $0x1,%r9d
shl    %cl,%r9
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),%xmm6
movss  (%rdi,%r9,4),%xmm9
movss  0x4(%rdi,%r9,4),%xmm7
movss  (%rdi,%r11,2),%xmm10
movss  0x4(%rdi,%r11,2),%xmm3
movss  (%r10,%r9,4),%xmm0
movss  0x4(%r10,%r9,4),%xmm2
addss  %xmm6,%xmm6
addss  %xmm1,%xmm1
movaps %xmm1,%xmm5
addss  %xmm6,%xmm5
subss  %xmm6,%xmm1
addss  %xmm9,%xmm9
movaps 0xe83(%rip),%xmm6
xorps  %xmm7,%xmm6
subss  %xmm7,%xmm6
movaps %xmm10,%xmm7
addss  %xmm0,%xmm7
movaps %xmm3,%xmm4
subss  %xmm2,%xmm4
addss  %xmm2,%xmm3
subss  %xmm10,%xmm0
mulss  %xmm8,%xmm3
movaps %xmm4,%xmm2
subss  %xmm3,%xmm2
addss  %xmm7,%xmm3
mulss  %xmm8,%xmm0
addss  %xmm0,%xmm3
addss  %xmm2,%xmm0
addss  %xmm7,%xmm7
subss  %xmm3,%xmm7
addss  %xmm4,%xmm4
movss  %xmm5,(%rdi)
movss  %xmm1,0x4(%rdi)
movss  %xmm9,(%rdi,%r9,4)
movss  %xmm6,0x4(%rdi,%r9,4)
movss  %xmm3,(%rdi,%r11,2)
movss  %xmm0,0x4(%rdi,%r11,2)
subss  %xmm4,%xmm0
movss  %xmm7,(%r10,%r9,4)
movss  %xmm0,0x4(%r10,%r9,4)
lea    -0x2(%rsi),%ecx
mov    $0xffffffffffffffff,%rsi
shl    %cl,%rsi
cmp    $0x1,%r8
je     135c <frstage+0x25c>
mov    %rsi,%rcx
not    %rcx
movss  (%rdx,%rcx,4),%xmm9
movss  0x4(%rdx),%xmm10
shl    $0x2,%rsi
neg    %rsi
lea    (%rdi,%r9,4),%rcx
nopl   (%rax)
movss  (%rdi,%rax,8),%xmm0
movss  0x4(%rdi,%rax,8),%xmm7
movss  -0x8(%rcx,%rsi,2),%xmm4
movss  -0x4(%rcx,%rsi,2),%xmm3
movss  -0x4(%rdi,%rsi,2),%xmm12
movss  0x4(%rcx,%rax,8),%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  (%rcx,%rax,8),%xmm5
addss  %xmm2,%xmm2
subss  %xmm0,%xmm2
addss  %xmm11,%xmm11
movss  %xmm0,(%rdi,%rax,8)
movss  %xmm4,0x4(%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,-0x8(%rcx,%rsi,2)
movss  %xmm4,-0x4(%rcx,%rsi,2)
movss  0x4(%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,(%rcx,%rax,8)
movss  %xmm5,0x4(%rcx,%rax,8)
add    $0x1,%rax
add    $0xfffffffffffffffc,%rsi
cmp    %rax,%r8
jne    1230 <frstage+0x130>
ret

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

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