#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 */

/* Variables and functions */
double cos(double);
double sin(double);
void cosft2(float y[], int n, int isign) {
  void realft(float data[], unsigned long n, int isign);
  int i;
  float sum, sum1, y1, y2, ytemp;
  double theta, wi = 0.0, wi1, wpi, wpr, wr = 1.0, wr1, wtemp;
  theta = 0.5 * 3.141592653589793 / n;
  wr1 = cos(theta);
  wi1 = sin(theta);
  wpr = -2.0 * wi1 * wi1;
  wpi = sin(2.0 * theta);
  if (isign == 1) {
    for (i = 1; i <= n / 2; i++) {
      y1 = 0.5 * (y[i] + y[n - i + 1]);
      y2 = wi1 * (y[i] - y[n - i + 1]);
      y[i] = y1 + y2;
      y[n - i + 1] = y1 - y2;
      wr1 = (wtemp = wr1) * wpr - wi1 * wpi + wr1;
      wi1 = wi1 * wpr + wtemp * wpi + wi1;
    }
    realft(y, n, 1);
    for (i = 3; i <= n; i += 2) {
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
      y1 = y[i] * wr - y[i + 1] * wi;
      y2 = y[i + 1] * wr + y[i] * wi;
      y[i] = y1;
      y[i + 1] = y2;
    }
    sum = 0.5 * y[2];
    for (i = n; i >= 2; i -= 2) {
      sum1 = sum;
      sum += y[i];
      y[i] = sum1;
    }
  } else if (isign == -1) {
    ytemp = y[n];
    for (i = n; i >= 4; i -= 2)
      y[i] = y[i - 2] - y[i];
    y[2] = 2.0 * ytemp;
    for (i = 3; i <= n; i += 2) {
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
      y1 = y[i] * wr + y[i + 1] * wi;
      y2 = y[i + 1] * wr - y[i] * wi;
      y[i] = y1;
      y[i + 1] = y2;
    }
    realft(y, n, -1);
    for (i = 1; i <= n / 2; i++) {
      y1 = y[i] + y[n - i + 1];
      y2 = (0.5 / wi1) * (y[i] - y[n - i + 1]);
      y[i] = 0.5 * (y1 + y2);
      y[n - i + 1] = 0.5 * (y1 - y2);
      wr1 = (wtemp = wr1) * wpr - wi1 * wpi + wr1;
      wi1 = wi1 * wpr + wtemp * wpi + wi1;
    }
  }
}


x86 assembly (clang, -O0):
<cosft2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xec6(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xeac(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  0xe75(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xe56(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x1,-0x10(%rbp)
jne    14de <cosft2+0x3ae>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
cmp    %ecx,%eax
jg     1307 <cosft2+0x1d7>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe0a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ca <cosft2+0x9a>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rsi
mov    $0x1,%edx
call   1030 <realft@plt>
movl   $0x3,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1466 <cosft2+0x336>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1320 <cosft2+0x1f0>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xba5(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
jl     14d9 <cosft2+0x3a9>
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    148e <cosft2+0x35e>
jmp    182f <cosft2+0x6ff>
cmpl   $0xffffffff,-0x10(%rbp)
jne    182a <cosft2+0x6fa>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     1544 <cosft2+0x414>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1500 <cosft2+0x3d0>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xaab(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movl   $0x3,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     16b3 <cosft2+0x583>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    156d <cosft2+0x43d>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rsi
mov    $0xffffffff,%edx
call   1030 <realft@plt>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
cmp    %ecx,%eax
jg     1825 <cosft2+0x6f5>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movsd  0x907(%rip),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x8b9(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x88e(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16cc <cosft2+0x59c>
jmp    182a <cosft2+0x6fa>
jmp    182f <cosft2+0x6ff>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cosft2>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x48,%rsp
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,%r14
cvtsi2sd %esi,%xmm1
movsd  0xeb3(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
call   1050 <cos@plt>
movapd %xmm0,0x30(%rsp)
movsd  (%rsp),%xmm0
call   1040 <sin@plt>
movsd  0xe95(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm0,0x20(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
movsd  (%rsp),%xmm0
addsd  %xmm0,%xmm0
call   1040 <sin@plt>
cmp    $0xffffffff,%ebp
je     11d2 <cosft2+0xa2>
cmp    $0x1,%ebp
movapd 0x10(%rsp),%xmm5
movapd 0x30(%rsp),%xmm7
jne    155f <cosft2+0x42f>
cmp    $0x1,%ebx
jg     13cb <cosft2+0x29b>
movslq %ebx,%rsi
mov    %r14,%rdi
mov    $0x1,%edx
add    $0x48,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <realft@plt>
movslq %ebx,%rsi
movss  (%r14,%rsi,4),%xmm4
cmp    $0x4,%ebx
jl     1220 <cosft2+0xf0>
mov    %ebx,%ecx
lea    (%r14,%rcx,4),%rax
movss  (%r14,%rcx,4),%xmm1
lea    0x2(%rbx),%ecx
lea    -0x2(%rbx),%edx
lea    (%r14,%rdx,4),%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rdi,4),%xmm2
movaps %xmm2,%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,(%rax,%rdi,4)
add    $0xfffffffffffffffe,%rdi
lea    (%rcx,%rdi,1),%ebp
movaps %xmm2,%xmm1
cmp    $0x5,%ebp
ja     1200 <cosft2+0xd0>
addss  %xmm4,%xmm4
movss  %xmm4,0x8(%r14)
cmp    $0x3,%ebx
jl     12dc <cosft2+0x1ac>
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd 0x10(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
movsd  0xdc3(%rip),%xmm2
mov    $0x3,%eax
movapd 0xdc5(%rip),%xmm8
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
xorpd  %xmm8,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm4,%xmm5
addpd  %xmm5,%xmm2
movss  (%r14,%rax,4),%xmm4
movss  0x4(%r14,%rax,4),%xmm5
cvtss2sd %xmm4,%xmm4
cvtss2sd %xmm5,%xmm5
movapd %xmm2,%xmm6
unpckhpd %xmm2,%xmm6
movapd %xmm6,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm4,%xmm6
mulsd  %xmm2,%xmm4
addsd  %xmm7,%xmm4
cvtsd2ss %xmm4,%xmm4
mulsd  %xmm2,%xmm5
subsd  %xmm6,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm4,(%r14,%rax,4)
movss  %xmm5,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rsi,%rax
jle    1260 <cosft2+0x130>
mov    %r14,%rdi
mov    $0xffffffff,%edx
movapd %xmm0,(%rsp)
call   1030 <realft@plt>
movapd (%rsp),%xmm10
cmp    $0x2,%ebx
movapd 0x10(%rsp),%xmm0
movapd 0x30(%rsp),%xmm2
jl     155f <cosft2+0x42f>
mov    %ebx,%eax
shr    %eax
unpcklpd 0x20(%rsp),%xmm2
unpcklpd %xmm0,%xmm0
unpcklpd %xmm10,%xmm10
xor    %ecx,%ecx
movsd  0xcf1(%rip),%xmm8
movss  0xd01(%rip),%xmm1
movapd 0xce8(%rip),%xmm9
nopl   0x0(%rax,%rax,1)
movss  0x4(%r14,%rcx,4),%xmm3
movslq %ebx,%rbx
movss  (%r14,%rbx,4),%xmm4
movaps %xmm3,%xmm5
movapd %xmm2,%xmm6
unpckhpd %xmm2,%xmm6
movapd %xmm8,%xmm7
divsd  %xmm6,%xmm7
subss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm7,%xmm3
cvtsd2ss %xmm3,%xmm3
addss  %xmm4,%xmm5
movaps %xmm5,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm1,%xmm4
movss  %xmm4,0x4(%r14,%rcx,4)
subss  %xmm3,%xmm5
mulss  %xmm1,%xmm5
movss  %xmm5,(%r14,%rbx,4)
xorpd  %xmm9,%xmm6
unpcklpd %xmm2,%xmm6
mulpd  %xmm10,%xmm6
movapd %xmm2,%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm6,%xmm3
addpd  %xmm3,%xmm2
add    $0xffffffff,%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1340 <cosft2+0x210>
jmp    155f <cosft2+0x42f>
mov    %ebx,%eax
shr    %eax
unpcklpd 0x20(%rsp),%xmm7
unpcklpd %xmm5,%xmm5
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
movss  0xc49(%rip),%xmm6
mov    %ebx,%edx
nopl   0x0(%rax)
movss  0x4(%r14,%rcx,4),%xmm1
movslq %edx,%rdx
movss  (%r14,%rdx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm6,%xmm3
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
mulsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps %xmm3,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,0x4(%r14,%rcx,4)
subss  %xmm1,%xmm3
movss  %xmm3,(%r14,%rdx,4)
xorpd  0xbdd(%rip),%xmm2
unpcklpd %xmm7,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm7,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
addpd  %xmm1,%xmm7
add    $0xffffffff,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13f0 <cosft2+0x2c0>
movslq %ebx,%r15
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x1,%edx
movapd %xmm5,0x10(%rsp)
movapd %xmm0,(%rsp)
call   1030 <realft@plt>
movapd 0xb93(%rip),%xmm7
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm5
cmp    $0x3,%ebx
jl     152b <cosft2+0x3fb>
movsd  0xb67(%rip),%xmm0
mov    $0x3,%eax
xchg   %ax,%ax
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
xorpd  %xmm7,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm6,%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm2,%xmm0
movss  (%r14,%rax,4),%xmm1
movss  0x4(%r14,%rax,4),%xmm2
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm1
subsd  %xmm4,%xmm1
cvtsd2ss %xmm1,%xmm1
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,(%r14,%rax,4)
movss  %xmm2,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %r15,%rax
jle    14b0 <cosft2+0x380>
cmp    $0x2,%ebx
jl     155f <cosft2+0x42f>
movss  0x8(%r14),%xmm0
mulss  0xaf2(%rip),%xmm0
mov    %ebx,%eax
movss  (%r14,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm0,(%r14,%rax,4)
add    $0xfffffffffffffffe,%rax
lea    0x2(%rax),%ecx
movaps %xmm1,%xmm0
cmp    $0x3,%ecx
ja     1540 <cosft2+0x410>
add    $0x48,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cosft2(float* %0, i32 %1, i32 %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
store float* %0, float** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store double 0.000000e+00, double* %14
store double 1.000000e+00, double* %18
%21 = load i32, i32* %5
%22 = sitofp i32 %21 to double
%23 = fdiv double 0x3FF921FB54442D18, %22
store double %23, double* %13
%24 = load double, double* %13
%25 = call double @cos(double %24)
store double %25, double* %19
%26 = load double, double* %13
%27 = call double @sin(double %26)
store double %27, double* %15
%28 = load double, double* %15
%29 = fmul double -2.000000e+00, %28
%30 = load double, double* %15
%31 = fmul double %29, %30
store double %31, double* %17
%32 = load double, double* %13
%33 = fmul double 2.000000e+00, %32
%34 = call double @sin(double %33)
store double %34, double* %16
%35 = load i32, i32* %6
%36 = icmp eq i32 %35, 1
br i1 %36, label %37, label %222
37: ; preds = %3
store i32 1, i32* %7
br label %38
38: ; preds = %113, %37
%39 = load i32, i32* %7
%40 = load i32, i32* %5
%41 = sdiv i32 %40, 2
%42 = icmp sle i32 %39, %41
br i1 %42, label %43, label %116
43: ; preds = %38
%44 = load float*, float** %4
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = load float*, float** %4
%50 = load i32, i32* %5
%51 = load i32, i32* %7
%52 = sub nsw i32 %50, %51
%53 = add nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %49, i64 %54
%56 = load float, float* %55
%57 = fadd float %48, %56
%58 = fpext float %57 to double
%59 = fmul double 5.000000e-01, %58
%60 = fptrunc double %59 to float
store float %60, float* %10
%61 = load double, double* %15
%62 = load float*, float** %4
%63 = load i32, i32* %7
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = load float*, float** %4
%68 = load i32, i32* %5
%69 = load i32, i32* %7
%70 = sub nsw i32 %68, %69
%71 = add nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %67, i64 %72
%74 = load float, float* %73
%75 = fsub float %66, %74
%76 = fpext float %75 to double
%77 = fmul double %61, %76
%78 = fptrunc double %77 to float
store float %78, float* %11
%79 = load float, float* %10
%80 = load float, float* %11
%81 = fadd float %79, %80
%82 = load float*, float** %4
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %82, i64 %84
store float %81, float* %85
%86 = load float, float* %10
%87 = load float, float* %11
%88 = fsub float %86, %87
%89 = load float*, float** %4
%90 = load i32, i32* %5
%91 = load i32, i32* %7
%92 = sub nsw i32 %90, %91
%93 = add nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %89, i64 %94
store float %88, float* %95
%96 = load double, double* %19
store double %96, double* %20
%97 = load double, double* %17
%98 = load double, double* %15
%99 = load double, double* %16
%100 = fmul double %98, %99
%101 = fneg double %100
%102 = call double @llvm.fmuladd.f64(double %96, double %97, double %101)
%103 = load double, double* %19
%104 = fadd double %102, %103
store double %104, double* %19
%105 = load double, double* %15
%106 = load double, double* %17
%107 = load double, double* %20
%108 = load double, double* %16
%109 = fmul double %107, %108
%110 = call double @llvm.fmuladd.f64(double %105, double %106, double %109)
%111 = load double, double* %15
%112 = fadd double %110, %111
store double %112, double* %15
br label %113
113: ; preds = %43
%114 = load i32, i32* %7
%115 = add nsw i32 %114, 1
store i32 %115, i32* %7
br label %38
116: ; preds = %38
%117 = load float*, float** %4
%118 = load i32, i32* %5
%119 = sext i32 %118 to i64
store i32 3, i32* %7
br label %120
120: ; preds = %190, %116
%121 = load i32, i32* %7
%122 = load i32, i32* %5
%123 = icmp sle i32 %121, %122
br i1 %123, label %124, label %193
124: ; preds = %120
%125 = load double, double* %18
store double %125, double* %20
%126 = load double, double* %17
%127 = load double, double* %14
%128 = load double, double* %16
%129 = fmul double %127, %128
%130 = fneg double %129
%131 = call double @llvm.fmuladd.f64(double %125, double %126, double %130)
%132 = load double, double* %18
%133 = fadd double %131, %132
store double %133, double* %18
%134 = load double, double* %14
%135 = load double, double* %17
%136 = load double, double* %20
%137 = load double, double* %16
%138 = fmul double %136, %137
%139 = call double @llvm.fmuladd.f64(double %134, double %135, double %138)
%140 = load double, double* %14
%141 = fadd double %139, %140
store double %141, double* %14
%142 = load float*, float** %4
%143 = load i32, i32* %7
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %142, i64 %144
%146 = load float, float* %145
%147 = fpext float %146 to double
%148 = load double, double* %18
%149 = load float*, float** %4
%150 = load i32, i32* %7
%151 = add nsw i32 %150, 1
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %149, i64 %152
%154 = load float, float* %153
%155 = fpext float %154 to double
%156 = load double, double* %14
%157 = fmul double %155, %156
%158 = fneg double %157
%159 = call double @llvm.fmuladd.f64(double %147, double %148, double %158)
%160 = fptrunc double %159 to float
store float %160, float* %10
%161 = load float*, float** %4
%162 = load i32, i32* %7
%163 = add nsw i32 %162, 1
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %161, i64 %164
%166 = load float, float* %165
%167 = fpext float %166 to double
%168 = load double, double* %18
%169 = load float*, float** %4
%170 = load i32, i32* %7
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
%173 = load float, float* %172
%174 = fpext float %173 to double
%175 = load double, double* %14
%176 = fmul double %174, %175
%177 = call double @llvm.fmuladd.f64(double %167, double %168, double %176)
%178 = fptrunc double %177 to float
store float %178, float* %11
%179 = load float, float* %10
%180 = load float*, float** %4
%181 = load i32, i32* %7
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
store float %179, float* %183
%184 = load float, float* %11
%185 = load float*, float** %4
%186 = load i32, i32* %7
%187 = add nsw i32 %186, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %185, i64 %188
store float %184, float* %189
br label %190
190: ; preds = %124
%191 = load i32, i32* %7
%192 = add nsw i32 %191, 2
store i32 %192, i32* %7
br label %120
193: ; preds = %120
%194 = load float*, float** %4
%195 = getelementptr inbounds float, float* %194, i64 2
%196 = load float, float* %195
%197 = fpext float %196 to double
%198 = fmul double 5.000000e-01, %197
%199 = fptrunc double %198 to float
store float %199, float* %8
%200 = load i32, i32* %5
store i32 %200, i32* %7
br label %201
201: ; preds = %218, %193
%202 = load i32, i32* %7
%203 = icmp sge i32 %202, 2
br i1 %203, label %204, label %221
204: ; preds = %201
%205 = load float, float* %8
store float %205, float* %9
%206 = load float*, float** %4
%207 = load i32, i32* %7
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %206, i64 %208
%210 = load float, float* %209
%211 = load float, float* %8
%212 = fadd float %211, %210
store float %212, float* %8
%213 = load float, float* %9
%214 = load float*, float** %4
%215 = load i32, i32* %7
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
store float %213, float* %217
br label %218
218: ; preds = %204
%219 = load i32, i32* %7
%220 = sub nsw i32 %219, 2
store i32 %220, i32* %7
br label %201
221: ; preds = %201
br label %423
222: ; preds = %3
%223 = load i32, i32* %6
%224 = icmp eq i32 %223, -1
br i1 %224, label %225, label %422
225: ; preds = %222
%226 = load float*, float** %4
%227 = load i32, i32* %5
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
%230 = load float, float* %229
store float %230, float* %12
%231 = load i32, i32* %5
store i32 %231, i32* %7
br label %232
232: ; preds = %252, %225
%233 = load i32, i32* %7
%234 = icmp sge i32 %233, 4
br i1 %234, label %235, label %255
235: ; preds = %232
%236 = load float*, float** %4
%237 = load i32, i32* %7
%238 = sub nsw i32 %237, 2
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float, float* %236, i64 %239
%241 = load float, float* %240
%242 = load float*, float** %4
%243 = load i32, i32* %7
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %242, i64 %244
%246 = load float, float* %245
%247 = fsub float %241, %246
%248 = load float*, float** %4
%249 = load i32, i32* %7
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %248, i64 %250
store float %247, float* %251
br label %252
252: ; preds = %235
%253 = load i32, i32* %7
%254 = sub nsw i32 %253, 2
store i32 %254, i32* %7
br label %232
255: ; preds = %232
%256 = load float, float* %12
%257 = fpext float %256 to double
%258 = fmul double 2.000000e+00, %257
%259 = fptrunc double %258 to float
%260 = load float*, float** %4
%261 = getelementptr inbounds float, float* %260, i64 2
store float %259, float* %261
store i32 3, i32* %7
br label %262
262: ; preds = %332, %255
%263 = load i32, i32* %7
%264 = load i32, i32* %5
%265 = icmp sle i32 %263, %264
br i1 %265, label %266, label %335
266: ; preds = %262
%267 = load double, double* %18
store double %267, double* %20
%268 = load double, double* %17
%269 = load double, double* %14
%270 = load double, double* %16
%271 = fmul double %269, %270
%272 = fneg double %271
%273 = call double @llvm.fmuladd.f64(double %267, double %268, double %272)
%274 = load double, double* %18
%275 = fadd double %273, %274
store double %275, double* %18
%276 = load double, double* %14
%277 = load double, double* %17
%278 = load double, double* %20
%279 = load double, double* %16
%280 = fmul double %278, %279
%281 = call double @llvm.fmuladd.f64(double %276, double %277, double %280)
%282 = load double, double* %14
%283 = fadd double %281, %282
store double %283, double* %14
%284 = load float*, float** %4
%285 = load i32, i32* %7
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %284, i64 %286
%288 = load float, float* %287
%289 = fpext float %288 to double
%290 = load double, double* %18
%291 = load float*, float** %4
%292 = load i32, i32* %7
%293 = add nsw i32 %292, 1
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %291, i64 %294
%296 = load float, float* %295
%297 = fpext float %296 to double
%298 = load double, double* %14
%299 = fmul double %297, %298
%300 = call double @llvm.fmuladd.f64(double %289, double %290, double %299)
%301 = fptrunc double %300 to float
store float %301, float* %10
%302 = load float*, float** %4
%303 = load i32, i32* %7
%304 = add nsw i32 %303, 1
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float, float* %302, i64 %305
%307 = load float, float* %306
%308 = fpext float %307 to double
%309 = load double, double* %18
%310 = load float*, float** %4
%311 = load i32, i32* %7
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float, float* %310, i64 %312
%314 = load float, float* %313
%315 = fpext float %314 to double
%316 = load double, double* %14
%317 = fmul double %315, %316
%318 = fneg double %317
%319 = call double @llvm.fmuladd.f64(double %308, double %309, double %318)
%320 = fptrunc double %319 to float
store float %320, float* %11
%321 = load float, float* %10
%322 = load float*, float** %4
%323 = load i32, i32* %7
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %322, i64 %324
store float %321, float* %325
%326 = load float, float* %11
%327 = load float*, float** %4
%328 = load i32, i32* %7
%329 = add nsw i32 %328, 1
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %327, i64 %330
store float %326, float* %331
br label %332
332: ; preds = %266
%333 = load i32, i32* %7
%334 = add nsw i32 %333, 2
store i32 %334, i32* %7
br label %262
335: ; preds = %262
%336 = load float*, float** %4
%337 = load i32, i32* %5
%338 = sext i32 %337 to i64
store i32 1, i32* %7
br label %339
339: ; preds = %418, %335
%340 = load i32, i32* %7
%341 = load i32, i32* %5
%342 = sdiv i32 %341, 2
%343 = icmp sle i32 %340, %342
br i1 %343, label %344, label %421
344: ; preds = %339
%345 = load float*, float** %4
%346 = load i32, i32* %7
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %345, i64 %347
%349 = load float, float* %348
%350 = load float*, float** %4
%351 = load i32, i32* %5
%352 = load i32, i32* %7
%353 = sub nsw i32 %351, %352
%354 = add nsw i32 %353, 1
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds float, float* %350, i64 %355
%357 = load float, float* %356
%358 = fadd float %349, %357
store float %358, float* %10
%359 = load double, double* %15
%360 = fdiv double 5.000000e-01, %359
%361 = load float*, float** %4
%362 = load i32, i32* %7
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float, float* %361, i64 %363
%365 = load float, float* %364
%366 = load float*, float** %4
%367 = load i32, i32* %5
%368 = load i32, i32* %7
%369 = sub nsw i32 %367, %368
%370 = add nsw i32 %369, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds float, float* %366, i64 %371
%373 = load float, float* %372
%374 = fsub float %365, %373
%375 = fpext float %374 to double
%376 = fmul double %360, %375
%377 = fptrunc double %376 to float
store float %377, float* %11
%378 = load float, float* %10
%379 = load float, float* %11
%380 = fadd float %378, %379
%381 = fpext float %380 to double
%382 = fmul double 5.000000e-01, %381
%383 = fptrunc double %382 to float
%384 = load float*, float** %4
%385 = load i32, i32* %7
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
store float %383, float* %387
%388 = load float, float* %10
%389 = load float, float* %11
%390 = fsub float %388, %389
%391 = fpext float %390 to double
%392 = fmul double 5.000000e-01, %391
%393 = fptrunc double %392 to float
%394 = load float*, float** %4
%395 = load i32, i32* %5
%396 = load i32, i32* %7
%397 = sub nsw i32 %395, %396
%398 = add nsw i32 %397, 1
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float, float* %394, i64 %399
store float %393, float* %400
%401 = load double, double* %19
store double %401, double* %20
%402 = load double, double* %17
%403 = load double, double* %15
%404 = load double, double* %16
%405 = fmul double %403, %404
%406 = fneg double %405
%407 = call double @llvm.fmuladd.f64(double %401, double %402, double %406)
%408 = load double, double* %19
%409 = fadd double %407, %408
store double %409, double* %19
%410 = load double, double* %15
%411 = load double, double* %17
%412 = load double, double* %20
%413 = load double, double* %16
%414 = fmul double %412, %413
%415 = call double @llvm.fmuladd.f64(double %410, double %411, double %414)
%416 = load double, double* %15
%417 = fadd double %415, %416
store double %417, double* %15
br label %418
418: ; preds = %344
%419 = load i32, i32* %7
%420 = add nsw i32 %419, 1
store i32 %420, i32* %7
br label %339
421: ; preds = %339
br label %422
422: ; preds = %421, %222
br label %423
423: ; preds = %422, %221
ret void
}

LLVM IR (-O2):
define void @cosft2(float* %0, i32 %1, i32 %2) {
%4 = sitofp i32 %1 to double
%5 = fdiv double 0x3FF921FB54442D18, %4
%6 = tail call double @cos(double %5)
%7 = tail call double @sin(double %5)
%8 = fmul double %7, -2.000000e+00
%9 = fmul double %7, %8
%10 = fmul double %5, 2.000000e+00
%11 = tail call double @sin(double %10)
switch i32 %2, label %199 [
i32 1, label %12
i32 -1, label %100
]
12: ; preds = %3
%13 = icmp slt i32 %1, 2
br i1 %13, label %14, label %16
14: ; preds = %12
%15 = sext i32 %1 to i64
tail call void @realft(float* %0, i64 %15, i32 1)
br label %199
16: ; preds = %12
%17 = lshr i32 %1, 1
%18 = add nuw i32 %1, 1
%19 = add nuw nsw i32 %17, 1
%20 = zext i32 %19 to i64
%21 = insertelement <2 x double> poison, double %6, i64 0
%22 = insertelement <2 x double> %21, double %7, i64 1
%23 = insertelement <2 x double> poison, double %9, i64 0
%24 = shufflevector <2 x double> %23, <2 x double> poison, <2 x i32> zeroinitializer
%25 = insertelement <2 x double> poison, double %11, i64 0
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> zeroinitializer
br label %27
27: ; preds = %16, %27
%28 = phi i64 [ 1, %16 ], [ %52, %27 ]
%29 = phi <2 x double> [ %22, %16 ], [ %51, %27 ]
%30 = getelementptr inbounds float, float* %0, i64 %28
%31 = load float, float* %30
%32 = trunc i64 %28 to i32
%33 = sub i32 %18, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = load float, float* %35
%37 = fadd float %31, %36
%38 = fmul float %37, 5.000000e-01
%39 = fsub float %31, %36
%40 = fpext float %39 to double
%41 = extractelement <2 x double> %29, i64 1
%42 = fmul double %41, %40
%43 = fptrunc double %42 to float
%44 = fadd float %38, %43
store float %44, float* %30
%45 = fsub float %38, %43
store float %45, float* %35
%46 = fneg double %41
%47 = insertelement <2 x double> poison, double %46, i64 0
%48 = shufflevector <2 x double> %47, <2 x double> %29, <2 x i32> <i32 0, i32 2>
%49 = fmul <2 x double> %26, %48
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %29, <2 x double> %24, <2 x double> %49)
%51 = fadd <2 x double> %29, %50
%52 = add nuw nsw i64 %28, 1
%53 = icmp eq i64 %52, %20
br i1 %53, label %54, label %27
54: ; preds = %27
%55 = sext i32 %1 to i64
tail call void @realft(float* %0, i64 %55, i32 1)
%56 = icmp slt i32 %1, 3
br i1 %56, label %85, label %57
57: ; preds = %54, %57
%58 = phi i64 [ %83, %57 ], [ 3, %54 ]
%59 = phi <2 x double> [ %66, %57 ], [ <double 1.000000e+00, double 0.000000e+00>, %54 ]
%60 = extractelement <2 x double> %59, i64 1
%61 = fneg double %60
%62 = insertelement <2 x double> poison, double %61, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> %59, <2 x i32> <i32 0, i32 2>
%64 = fmul <2 x double> %26, %63
%65 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %59, <2 x double> %24, <2 x double> %64)
%66 = fadd <2 x double> %59, %65
%67 = getelementptr inbounds float, float* %0, i64 %58
%68 = load float, float* %67
%69 = fpext float %68 to double
%70 = add nuw nsw i64 %58, 1
%71 = getelementptr inbounds float, float* %0, i64 %70
%72 = load float, float* %71
%73 = fpext float %72 to double
%74 = extractelement <2 x double> %66, i64 1
%75 = fneg double %74
%76 = fmul double %75, %73
%77 = extractelement <2 x double> %66, i64 0
%78 = tail call double @llvm.fmuladd.f64(double %69, double %77, double %76)
%79 = fptrunc double %78 to float
%80 = fmul double %74, %69
%81 = tail call double @llvm.fmuladd.f64(double %73, double %77, double %80)
%82 = fptrunc double %81 to float
store float %79, float* %67
store float %82, float* %71
%83 = add nuw nsw i64 %58, 2
%84 = icmp sgt i64 %83, %55
br i1 %84, label %85, label %57
85: ; preds = %57, %54
%86 = icmp sgt i32 %1, 1
br i1 %86, label %87, label %199
87: ; preds = %85
%88 = getelementptr inbounds float, float* %0, i64 2
%89 = load float, float* %88
%90 = fmul float %89, 5.000000e-01
br label %91
91: ; preds = %87, %91
%92 = phi i32 [ %98, %91 ], [ %1, %87 ]
%93 = phi float [ %97, %91 ], [ %90, %87 ]
%94 = zext i32 %92 to i64
%95 = getelementptr inbounds float, float* %0, i64 %94
%96 = load float, float* %95
%97 = fadd float %93, %96
store float %93, float* %95
%98 = add nsw i32 %92, -2
%99 = icmp ugt i32 %92, 3
br i1 %99, label %91, label %199
100: ; preds = %3
%101 = sext i32 %1 to i64
%102 = getelementptr inbounds float, float* %0, i64 %101
%103 = load float, float* %102
%104 = icmp sgt i32 %1, 3
br i1 %104, label %105, label %120
105: ; preds = %100
%106 = zext i32 %1 to i64
%107 = getelementptr inbounds float, float* %0, i64 %106
%108 = load float, float* %107
br label %109
109: ; preds = %105, %109
%110 = phi float [ %115, %109 ], [ %108, %105 ]
%111 = phi i32 [ %112, %109 ], [ %1, %105 ]
%112 = add nsw i32 %111, -2
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds float, float* %0, i64 %113
%115 = load float, float* %114
%116 = zext i32 %111 to i64
%117 = getelementptr inbounds float, float* %0, i64 %116
%118 = fsub float %115, %110
store float %118, float* %117
%119 = icmp ugt i32 %111, 5
br i1 %119, label %109, label %120
120: ; preds = %109, %100
%121 = fmul float %103, 2.000000e+00
%122 = getelementptr inbounds float, float* %0, i64 2
store float %121, float* %122
%123 = icmp slt i32 %1, 3
br i1 %123, label %157, label %124
124: ; preds = %120
%125 = insertelement <2 x double> poison, double %11, i64 0
%126 = shufflevector <2 x double> %125, <2 x double> poison, <2 x i32> zeroinitializer
%127 = insertelement <2 x double> poison, double %9, i64 0
%128 = shufflevector <2 x double> %127, <2 x double> poison, <2 x i32> zeroinitializer
br label %129
129: ; preds = %124, %129
%130 = phi i64 [ %155, %129 ], [ 3, %124 ]
%131 = phi <2 x double> [ %138, %129 ], [ <double 1.000000e+00, double 0.000000e+00>, %124 ]
%132 = extractelement <2 x double> %131, i64 1
%133 = fneg double %132
%134 = insertelement <2 x double> poison, double %133, i64 0
%135 = shufflevector <2 x double> %134, <2 x double> %131, <2 x i32> <i32 0, i32 2>
%136 = fmul <2 x double> %126, %135
%137 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %131, <2 x double> %128, <2 x double> %136)
%138 = fadd <2 x double> %131, %137
%139 = getelementptr inbounds float, float* %0, i64 %130
%140 = load float, float* %139
%141 = fpext float %140 to double
%142 = add nuw nsw i64 %130, 1
%143 = getelementptr inbounds float, float* %0, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = extractelement <2 x double> %138, i64 1
%147 = fmul double %146, %145
%148 = extractelement <2 x double> %138, i64 0
%149 = tail call double @llvm.fmuladd.f64(double %141, double %148, double %147)
%150 = fptrunc double %149 to float
%151 = fneg double %146
%152 = fmul double %151, %141
%153 = tail call double @llvm.fmuladd.f64(double %145, double %148, double %152)
%154 = fptrunc double %153 to float
store float %150, float* %139
store float %154, float* %143
%155 = add nuw nsw i64 %130, 2
%156 = icmp sgt i64 %155, %101
br i1 %156, label %157, label %129
157: ; preds = %129, %120
tail call void @realft(float* %0, i64 %101, i32 -1)
%158 = icmp slt i32 %1, 2
br i1 %158, label %199, label %159
159: ; preds = %157
%160 = lshr i32 %1, 1
%161 = add nuw i32 %1, 1
%162 = add nuw nsw i32 %160, 1
%163 = zext i32 %162 to i64
%164 = insertelement <2 x double> poison, double %6, i64 0
%165 = insertelement <2 x double> %164, double %7, i64 1
%166 = insertelement <2 x double> poison, double %9, i64 0
%167 = shufflevector <2 x double> %166, <2 x double> poison, <2 x i32> zeroinitializer
%168 = insertelement <2 x double> poison, double %11, i64 0
%169 = shufflevector <2 x double> %168, <2 x double> poison, <2 x i32> zeroinitializer
br label %170
170: ; preds = %159, %170
%171 = phi i64 [ 1, %159 ], [ %197, %170 ]
%172 = phi <2 x double> [ %165, %159 ], [ %196, %170 ]
%173 = getelementptr inbounds float, float* %0, i64 %171
%174 = load float, float* %173
%175 = trunc i64 %171 to i32
%176 = sub i32 %161, %175
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %0, i64 %177
%179 = load float, float* %178
%180 = fadd float %174, %179
%181 = extractelement <2 x double> %172, i64 1
%182 = fdiv double 5.000000e-01, %181
%183 = fsub float %174, %179
%184 = fpext float %183 to double
%185 = fmul double %182, %184
%186 = fptrunc double %185 to float
%187 = fadd float %180, %186
%188 = fmul float %187, 5.000000e-01
store float %188, float* %173
%189 = fsub float %180, %186
%190 = fmul float %189, 5.000000e-01
store float %190, float* %178
%191 = fneg double %181
%192 = insertelement <2 x double> poison, double %191, i64 0
%193 = shufflevector <2 x double> %192, <2 x double> %172, <2 x i32> <i32 0, i32 2>
%194 = fmul <2 x double> %169, %193
%195 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %172, <2 x double> %167, <2 x double> %194)
%196 = fadd <2 x double> %172, %195
%197 = add nuw nsw i64 %171, 1
%198 = icmp eq i64 %197, %163
br i1 %198, label %199, label %170
199: ; preds = %170, %91, %14, %157, %85, %3
ret void
}