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


x86 assembly (clang, -O0):
<rftbsub>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
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    12cd <rftbsub+0x1cd>
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  0xe63(%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
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
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%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),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
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),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1163 <rftbsub+0x63>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<rftbsub>:
mov    %rdx,%r8
movss  0x4(%rsi),%xmm0
xorps  0xef1(%rip),%xmm0
movss  %xmm0,0x4(%rsi)
mov    %rdi,%r9
shr    %r9
lea    (%rdx,%rdx,1),%rax
mov    %rax,%rdx
or     %r9,%rdx
shr    $0x20,%rdx
je     113a <rftbsub+0x3a>
xor    %edx,%edx
div    %r9
cmp    $0x6,%rdi
jae    1149 <rftbsub+0x49>
jmp    11f0 <rftbsub+0xf0>
xor    %edx,%edx
div    %r9d
cmp    $0x6,%rdi
jb     11f0 <rftbsub+0xf0>
add    $0xffffffffffffffff,%rdi
mov    $0x2,%r11d
xor    %r10d,%r10d
movss  0xeb2(%rip),%xmm0
xchg   %ax,%ax
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 %xmm1,%xmm7
mulss  %xmm5,%xmm7
mulss  %xmm2,%xmm5
mulss  %xmm6,%xmm2
addss  %xmm2,%xmm7
mulss  %xmm1,%xmm6
subss  %xmm5,%xmm6
subss  %xmm7,%xmm3
movss  %xmm3,(%rsi,%r11,4)
movaps %xmm6,%xmm1
subss  %xmm4,%xmm1
movss  %xmm1,0x4(%rsi,%r11,4)
addss  -0x4(%rsi,%rdi,4),%xmm7
movss  %xmm7,-0x4(%rsi,%rdi,4)
subss  (%rsi,%rdi,4),%xmm6
movss  %xmm6,(%rsi,%rdi,4)
add    $0x2,%r11
add    $0xfffffffffffffffe,%rdi
cmp    %r9,%r11
jb     1160 <rftbsub+0x60>
movss  0x4(%rsi,%r9,4),%xmm0
xorps  0xe02(%rip),%xmm0
movss  %xmm0,0x4(%rsi,%r9,4)
ret

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

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