#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 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 = ((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 = 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 + (((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 = 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),%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
movss  0xdf3(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x54(%rbp),%xmm0
movss  0xdd4(%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    $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    1776 <frstage+0x676>
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    1460 <frstage+0x360>
add    $0x8,%rsp
pop    %rbp
ret

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

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