#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 */
void rftfsub(size_t n, float *a, size_t nc, float *c) {
  size_t j, k, kk, ks, m;
  float wkr, wki, xr, xi, yr, yi;
  m = n >> 1;
  ks = 2 * nc / m;
  kk = 0;
  for (j = 2; j < m; j += 2) {
    k = n - j;
    kk += ks;
    wkr = 0.5f - c[nc - kk];
    wki = c[kk];
    xr = a[j] - a[k];
    xi = a[j + 1] + a[k + 1];
    yr = wkr * xr - wki * xi;
    yi = wkr * xi + wki * xr;
    a[j] -= yr;
    a[j + 1] -= yi;
    a[k] += yr;
    a[k + 1] -= yi;
  }
}


x86 assembly (clang, -O0):
<rftfsub>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x1,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x48(%rbp)
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x2,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    12a6 <rftfsub+0x1a6>
mov    -0x8(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    -0x38(%rbp),%rcx
movss  0xe82(%rip),%xmm0
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1144 <rftfsub+0x44>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rftfsub>:
mov    %rdx,%r8
mov    %rdi,%r9
shr    %r9
lea    (%rdx,%rdx,1),%rax
mov    %rax,%rdx
or     %r9,%rdx
shr    $0x20,%rdx
je     1129 <rftfsub+0x29>
xor    %edx,%edx
div    %r9
cmp    $0x6,%rdi
jae    1138 <rftfsub+0x38>
jmp    11e1 <rftfsub+0xe1>
xor    %edx,%edx
div    %r9d
cmp    $0x6,%rdi
jb     11e1 <rftfsub+0xe1>
add    $0xffffffffffffffff,%rdi
mov    $0x2,%r11d
xor    %r10d,%r10d
movss  0xeb3(%rip),%xmm0
nopl   (%rax)
add    %rax,%r10
mov    %r8,%rdx
sub    %r10,%rdx
movaps %xmm0,%xmm1
subss  (%rcx,%rdx,4),%xmm1
movss  (%rcx,%r10,4),%xmm2
movss  (%rsi,%r11,4),%xmm3
movss  0x4(%rsi,%r11,4),%xmm4
movaps %xmm3,%xmm5
subss  -0x4(%rsi,%rdi,4),%xmm5
movss  (%rsi,%rdi,4),%xmm6
addss  %xmm4,%xmm6
movaps %xmm6,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm1,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm7,%xmm1
mulss  %xmm2,%xmm5
addss  %xmm5,%xmm6
subss  %xmm1,%xmm3
movss  %xmm3,(%rsi,%r11,4)
subss  %xmm6,%xmm4
movss  %xmm4,0x4(%rsi,%r11,4)
addss  -0x4(%rsi,%rdi,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rdi,4)
movss  (%rsi,%rdi,4),%xmm1
subss  %xmm6,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
add    $0x2,%r11
add    $0xfffffffffffffffe,%rdi
cmp    %r9,%r11
jb     1150 <rftfsub+0x50>
ret

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

LLVM IR (-O2):
define void @rftfsub(i64 %0, float* nocapture %1, i64 %2, float* nocapture %3) {
%5 = lshr i64 %0, 1
%6 = shl i64 %2, 1
%7 = udiv i64 %6, %5
%8 = icmp ugt i64 %0, 5
br i1 %8, label %9, label %45
9: ; preds = %4, %9
%10 = phi i64 [ %43, %9 ], [ 2, %4 ]
%11 = phi i64 [ %13, %9 ], [ 0, %4 ]
%12 = sub i64 %0, %10
%13 = add i64 %11, %7
%14 = sub i64 %2, %13
%15 = getelementptr inbounds float, float* %3, i64 %14
%16 = load float, float* %15
%17 = fsub float 5.000000e-01, %16
%18 = getelementptr inbounds float, float* %3, i64 %13
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %1, i64 %10
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %1, i64 %12
%23 = load float, float* %22
%24 = fsub float %21, %23
%25 = or i64 %10, 1
%26 = getelementptr inbounds float, float* %1, i64 %25
%27 = load float, float* %26
%28 = add i64 %12, 1
%29 = getelementptr inbounds float, float* %1, i64 %28
%30 = load float, float* %29
%31 = fadd float %27, %30
%32 = fneg float %19
%33 = fmul float %31, %32
%34 = tail call float @llvm.fmuladd.f32(float %17, float %24, float %33)
%35 = fmul float %19, %24
%36 = tail call float @llvm.fmuladd.f32(float %17, float %31, float %35)
%37 = fsub float %21, %34
store float %37, float* %20
%38 = fsub float %27, %36
store float %38, float* %26
%39 = load float, float* %22
%40 = fadd float %39, %34
store float %40, float* %22
%41 = load float, float* %29
%42 = fsub float %41, %36
store float %42, float* %29
%43 = add nuw i64 %10, 2
%44 = icmp ult i64 %43, %5
br i1 %44, label %9, label %45
45: ; preds = %9, %4
ret void
}