#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 */
int /*<<< orphan*/ R16SRFFT(float *, float *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, float *, float *, float *, float *, float *,
                         float *, float *, float *, float *, float *, float *,
                         float *, float *, float *, float *, float *);
void main() {
  float data[16];
  float output[16];
  float zero = 0;
  printf("\ntype 16 point input vector\n");
  scanf("%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", &data[0], &data[1],
        &data[2], &data[3], &data[4], &data[5], &data[6], &data[7], &data[8],
        &data[9], &data[10], &data[11], &data[12], &data[13], &data[14],
        &data[15]);
  R16SRFFT(data, output);
  printf("\nresult is:\n");
  printf("k,\t\tReal Part\t\tImaginary Part\n");
  printf("0\t\t%.9f\t\t%.9f\n", output[0], zero);
  printf("1\t\t%.9f\t\t%.9f\n", output[1], output[9]);
  printf("2\t\t%.9f\t\t%.9f\n", output[2], output[10]);
  printf("3\t\t%.9f\t\t%.9f\n", output[3], output[11]);
  printf("4\t\t%.9f\t\t%.9f\n", output[4], output[12]);
  printf("5\t\t%.9f\t\t%.9f\n", output[5], output[13]);
  printf("6\t\t%.9f\t\t%.9f\n", output[6], output[14]);
  printf("7\t\t%.9f\t\t%.9f\n", output[7], output[15]);
  printf("8\t\t%.9f\t\t%.9f\n", output[8], zero);
  printf("9\t\t%.9f\t\t%.9f\n", output[7], -output[15]);
  printf("10\t\t%.9f\t\t%.9f\n", output[6], -output[14]);
  printf("11\t\t%.9f\t\t%.9f\n", output[5], -output[13]);
  printf("12\t\t%.9f\t\t%.9f\n", output[4], -output[12]);
  printf("13\t\t%.9f\t\t%.9f\n", output[3], -output[11]);
  printf("14\t\t%.9f\t\t%.9f\n", output[2], -output[9]);
  printf("15\t\t%.9f\t\t%.9f\n", output[1], -output[8]);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
lea    0xeaa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x70(%rbp),%rsi
lea    -0x70(%rbp),%rdx
add    $0x4,%rdx
lea    -0x70(%rbp),%rcx
add    $0x8,%rcx
lea    -0x70(%rbp),%r8
add    $0xc,%r8
lea    -0x70(%rbp),%r9
add    $0x10,%r9
lea    -0x70(%rbp),%rax
add    $0x14,%rax
lea    -0x70(%rbp),%rdi
add    $0x18,%rdi
mov    %rdi,-0xd0(%rbp)
lea    -0x70(%rbp),%rdi
add    $0x1c,%rdi
mov    %rdi,-0xc8(%rbp)
lea    -0x70(%rbp),%r13
add    $0x20,%r13
lea    -0x70(%rbp),%r12
add    $0x24,%r12
lea    -0x70(%rbp),%r15
add    $0x28,%r15
lea    -0x70(%rbp),%r14
add    $0x2c,%r14
lea    -0x70(%rbp),%rbx
add    $0x30,%rbx
lea    -0x70(%rbp),%r11
add    $0x34,%r11
lea    -0x70(%rbp),%r10
add    $0x38,%r10
lea    -0x70(%rbp),%rdi
add    $0x3c,%rdi
mov    %rdi,-0xc0(%rbp)
lea    0xe28(%rip),%rdi
mov    %rax,(%rsp)
mov    -0xd0(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xc8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xc0(%rbp),%rax
mov    %r13,0x18(%rsp)
mov    %r12,0x20(%rsp)
mov    %r15,0x28(%rsp)
mov    %r14,0x30(%rsp)
mov    %rbx,0x38(%rsp)
mov    %r11,0x40(%rsp)
mov    %r10,0x48(%rsp)
mov    %rax,0x50(%rsp)
call   1050 <scanf@plt>
lea    -0x70(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
call   1040 <R16SRFFT@plt>
lea    0xdf1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdf0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xb4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xe26(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xe10(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x88(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xdfa(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x84(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xde4(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x80(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xdd1(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x7c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xdbe(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x78(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xd0e(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcfa(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xb4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xce3(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x74(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcc2(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x78(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xca1(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x7c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc81(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x80(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc61(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc3e(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc1b(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xbf8(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
lea    0xf84(%rip),%rdi
call   1030 <puts@plt>
lea    0x44(%rsp),%rdx
lea    0x48(%rsp),%rcx
lea    0x4c(%rsp),%r8
lea    0x50(%rsp),%r9
lea    0x60(%rsp),%r15
lea    0x64(%rsp),%r12
lea    0x68(%rsp),%r13
lea    0x6c(%rsp),%rax
lea    0x70(%rsp),%rbp
lea    0x74(%rsp),%r10
lea    0x78(%rsp),%r11
lea    0x7c(%rsp),%r14
sub    $0x8,%rsp
lea    0xe6c(%rip),%rdi
lea    0x48(%rsp),%rbx
mov    %rbx,%rsi
push   %r14
push   %r11
push   %r10
push   %rbp
push   %rax
push   %r13
push   %r12
push   %r15
lea    0xa4(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
lea    0xac(%rsp),%rax
push   %rax
call   1060 <scanf@plt>
add    $0x60,%rsp
mov    %rsp,%rsi
mov    %rbx,%rdi
call   1050 <R16SRFFT@plt>
lea    0xf08(%rip),%rdi
call   1030 <puts@plt>
lea    0xf08(%rip),%rdi
call   1030 <puts@plt>
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe6c(%rip),%rdi
xorps  %xmm1,%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x4(%rsp),%xmm0
movss  0x24(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xe57(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x8(%rsp),%xmm0
movss  0x28(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xe45(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0xc(%rsp),%xmm0
movss  0x2c(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xe33(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x10(%rsp),%xmm0
movss  0x30(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xe21(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x14(%rsp),%xmm0
movss  0x34(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xe0f(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x18(%rsp),%xmm0
movss  0x38(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xd60(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x1c(%rsp),%xmm0
movss  0x3c(%rsp),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xd4d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd44(%rip),%rdi
xorps  %xmm1,%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x3c(%rsp),%xmm1
xorps  0xcc5(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xd27(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x38(%rsp),%xmm1
xorps  0xc9c(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xd0d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x34(%rsp),%xmm1
xorps  0xc73(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcf4(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x30(%rsp),%xmm1
xorps  0xc4a(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcdb(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2c(%rsp),%xmm1
xorps  0xc21(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xcc2(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x24(%rsp),%xmm1
xorps  0xbf8(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xca9(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x20(%rsp),%xmm1
xorps  0xbcf(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc90(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [29 x i8] c"\0Atype 16 point input vector\0A\00"
@.str.1 = [48 x i8] c"%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\00"
@.str.2 = [13 x i8] c"\0Aresult is:\0A\00"
@.str.3 = [31 x i8] c"k,\09\09Real Part\09\09Imaginary Part\0A\00"
@.str.4 = [15 x i8] c"0\09\09%.9f\09\09%.9f\0A\00"
@.str.5 = [15 x i8] c"1\09\09%.9f\09\09%.9f\0A\00"
@.str.6 = [15 x i8] c"2\09\09%.9f\09\09%.9f\0A\00"
@.str.7 = [15 x i8] c"3\09\09%.9f\09\09%.9f\0A\00"
@.str.8 = [15 x i8] c"4\09\09%.9f\09\09%.9f\0A\00"
@.str.9 = [15 x i8] c"5\09\09%.9f\09\09%.9f\0A\00"
@.str.10 = [15 x i8] c"6\09\09%.9f\09\09%.9f\0A\00"
@.str.11 = [15 x i8] c"7\09\09%.9f\09\09%.9f\0A\00"
@.str.12 = [15 x i8] c"8\09\09%.9f\09\09%.9f\0A\00"
@.str.13 = [15 x i8] c"9\09\09%.9f\09\09%.9f\0A\00"
@.str.14 = [16 x i8] c"10\09\09%.9f\09\09%.9f\0A\00"
@.str.15 = [16 x i8] c"11\09\09%.9f\09\09%.9f\0A\00"
@.str.16 = [16 x i8] c"12\09\09%.9f\09\09%.9f\0A\00"
@.str.17 = [16 x i8] c"13\09\09%.9f\09\09%.9f\0A\00"
@.str.18 = [16 x i8] c"14\09\09%.9f\09\09%.9f\0A\00"
@.str.19 = [16 x i8] c"15\09\09%.9f\09\09%.9f\0A\00"
define void @main() {
%1 = alloca [16 x float]
%2 = alloca [16 x float]
%3 = alloca float
store float 0.000000e+00, float* %3
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
%5 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 0
%6 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 1
%7 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 2
%8 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 3
%9 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 4
%10 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 5
%11 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 6
%12 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 7
%13 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 8
%14 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 9
%15 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 10
%16 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 11
%17 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 12
%18 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 13
%19 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 14
%20 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 15
%21 = call i32 @scanf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0), float* %5, float* %6, float* %7, float* %8, float* %9, float* %10, float* %11, float* %12, float* %13, float* %14, float* %15, float* %16, float* %17, float* %18, float* %19, float* %20)
%22 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 0
%23 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
%24 = call i32 @R16SRFFT(float* %22, float* %23)
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0))
%27 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
%28 = load float, float* %27
%29 = fpext float %28 to double
%30 = load float, float* %3
%31 = fpext float %30 to double
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %29, double %31)
%33 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 1
%34 = load float, float* %33
%35 = fpext float %34 to double
%36 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 9
%37 = load float, float* %36
%38 = fpext float %37 to double
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %35, double %38)
%40 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 2
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 10
%44 = load float, float* %43
%45 = fpext float %44 to double
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), double %42, double %45)
%47 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 3
%48 = load float, float* %47
%49 = fpext float %48 to double
%50 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 11
%51 = load float, float* %50
%52 = fpext float %51 to double
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %49, double %52)
%54 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 4
%55 = load float, float* %54
%56 = fpext float %55 to double
%57 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 12
%58 = load float, float* %57
%59 = fpext float %58 to double
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %56, double %59)
%61 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 5
%62 = load float, float* %61
%63 = fpext float %62 to double
%64 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 13
%65 = load float, float* %64
%66 = fpext float %65 to double
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), double %63, double %66)
%68 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 6
%69 = load float, float* %68
%70 = fpext float %69 to double
%71 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 14
%72 = load float, float* %71
%73 = fpext float %72 to double
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), double %70, double %73)
%75 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 7
%76 = load float, float* %75
%77 = fpext float %76 to double
%78 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 15
%79 = load float, float* %78
%80 = fpext float %79 to double
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.11, i64 0, i64 0), double %77, double %80)
%82 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 8
%83 = load float, float* %82
%84 = fpext float %83 to double
%85 = load float, float* %3
%86 = fpext float %85 to double
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.12, i64 0, i64 0), double %84, double %86)
%88 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 7
%89 = load float, float* %88
%90 = fpext float %89 to double
%91 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 15
%92 = load float, float* %91
%93 = fneg float %92
%94 = fpext float %93 to double
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.13, i64 0, i64 0), double %90, double %94)
%96 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 6
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 14
%100 = load float, float* %99
%101 = fneg float %100
%102 = fpext float %101 to double
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.14, i64 0, i64 0), double %98, double %102)
%104 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 5
%105 = load float, float* %104
%106 = fpext float %105 to double
%107 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 13
%108 = load float, float* %107
%109 = fneg float %108
%110 = fpext float %109 to double
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.15, i64 0, i64 0), double %106, double %110)
%112 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 4
%113 = load float, float* %112
%114 = fpext float %113 to double
%115 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 12
%116 = load float, float* %115
%117 = fneg float %116
%118 = fpext float %117 to double
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), double %114, double %118)
%120 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 3
%121 = load float, float* %120
%122 = fpext float %121 to double
%123 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 11
%124 = load float, float* %123
%125 = fneg float %124
%126 = fpext float %125 to double
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.17, i64 0, i64 0), double %122, double %126)
%128 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 2
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 9
%132 = load float, float* %131
%133 = fneg float %132
%134 = fpext float %133 to double
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.18, i64 0, i64 0), double %130, double %134)
%136 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 1
%137 = load float, float* %136
%138 = fpext float %137 to double
%139 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 8
%140 = load float, float* %139
%141 = fneg float %140
%142 = fpext float %141 to double
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.19, i64 0, i64 0), double %138, double %142)
ret void
}

LLVM IR (-O2):
@.str.1 = [48 x i8] c"%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\00"
@.str.4 = [15 x i8] c"0\09\09%.9f\09\09%.9f\0A\00"
@.str.5 = [15 x i8] c"1\09\09%.9f\09\09%.9f\0A\00"
@.str.6 = [15 x i8] c"2\09\09%.9f\09\09%.9f\0A\00"
@.str.7 = [15 x i8] c"3\09\09%.9f\09\09%.9f\0A\00"
@.str.8 = [15 x i8] c"4\09\09%.9f\09\09%.9f\0A\00"
@.str.9 = [15 x i8] c"5\09\09%.9f\09\09%.9f\0A\00"
@.str.10 = [15 x i8] c"6\09\09%.9f\09\09%.9f\0A\00"
@.str.11 = [15 x i8] c"7\09\09%.9f\09\09%.9f\0A\00"
@.str.12 = [15 x i8] c"8\09\09%.9f\09\09%.9f\0A\00"
@.str.13 = [15 x i8] c"9\09\09%.9f\09\09%.9f\0A\00"
@.str.14 = [16 x i8] c"10\09\09%.9f\09\09%.9f\0A\00"
@.str.15 = [16 x i8] c"11\09\09%.9f\09\09%.9f\0A\00"
@.str.16 = [16 x i8] c"12\09\09%.9f\09\09%.9f\0A\00"
@.str.17 = [16 x i8] c"13\09\09%.9f\09\09%.9f\0A\00"
@.str.18 = [16 x i8] c"14\09\09%.9f\09\09%.9f\0A\00"
@.str.19 = [16 x i8] c"15\09\09%.9f\09\09%.9f\0A\00"
@str = [28 x i8] c"\0Atype 16 point input vector\00"
@str.20 = [12 x i8] c"\0Aresult is:\00"
@str.21 = [30 x i8] c"k,\09\09Real Part\09\09Imaginary Part\00"
define void @main() {
%1 = alloca [16 x float]
%2 = alloca [16 x float]
%3 = bitcast [16 x float]* %1 to i8*
%4 = bitcast [16 x float]* %2 to i8*
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%6 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 0
%7 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 1
%8 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 2
%9 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 3
%10 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 4
%11 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 5
%12 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 6
%13 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 7
%14 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 8
%15 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 9
%16 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 10
%17 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 11
%18 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 12
%19 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 13
%20 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 14
%21 = getelementptr inbounds [16 x float], [16 x float]* %1, i64 0, i64 15
%22 = call i32 @scanf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0), float* %6, float* %7, float* %8, float* %9, float* %10, float* %11, float* %12, float* %13, float* %14, float* %15, float* %16, float* %17, float* %18, float* %19, float* %20, float* %21)
%23 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
%24 = call i32 @R16SRFFT(float* %6, float* %23)
%25 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.20, i64 0, i64 0))
%26 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.21, i64 0, i64 0))
%27 = load float, float* %23
%28 = fpext float %27 to double
%29 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %28, double 0.000000e+00)
%30 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 1
%31 = load float, float* %30
%32 = fpext float %31 to double
%33 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 9
%34 = load float, float* %33
%35 = fpext float %34 to double
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %32, double %35)
%37 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 2
%38 = load float, float* %37
%39 = fpext float %38 to double
%40 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 10
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), double %39, double %42)
%44 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 3
%45 = load float, float* %44
%46 = fpext float %45 to double
%47 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 11
%48 = load float, float* %47
%49 = fpext float %48 to double
%50 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %46, double %49)
%51 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 4
%52 = load float, float* %51
%53 = fpext float %52 to double
%54 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 12
%55 = load float, float* %54
%56 = fpext float %55 to double
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), double %53, double %56)
%58 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 5
%59 = load float, float* %58
%60 = fpext float %59 to double
%61 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 13
%62 = load float, float* %61
%63 = fpext float %62 to double
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), double %60, double %63)
%65 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 6
%66 = load float, float* %65
%67 = fpext float %66 to double
%68 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 14
%69 = load float, float* %68
%70 = fpext float %69 to double
%71 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), double %67, double %70)
%72 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 7
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 15
%76 = load float, float* %75
%77 = fpext float %76 to double
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.11, i64 0, i64 0), double %74, double %77)
%79 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 8
%80 = load float, float* %79
%81 = fpext float %80 to double
%82 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.12, i64 0, i64 0), double %81, double 0.000000e+00)
%83 = load float, float* %72
%84 = fpext float %83 to double
%85 = load float, float* %75
%86 = fneg float %85
%87 = fpext float %86 to double
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.13, i64 0, i64 0), double %84, double %87)
%89 = load float, float* %65
%90 = fpext float %89 to double
%91 = load float, float* %68
%92 = fneg float %91
%93 = fpext float %92 to double
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.14, i64 0, i64 0), double %90, double %93)
%95 = load float, float* %58
%96 = fpext float %95 to double
%97 = load float, float* %61
%98 = fneg float %97
%99 = fpext float %98 to double
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.15, i64 0, i64 0), double %96, double %99)
%101 = load float, float* %51
%102 = fpext float %101 to double
%103 = load float, float* %54
%104 = fneg float %103
%105 = fpext float %104 to double
%106 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), double %102, double %105)
%107 = load float, float* %44
%108 = fpext float %107 to double
%109 = load float, float* %47
%110 = fneg float %109
%111 = fpext float %110 to double
%112 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.17, i64 0, i64 0), double %108, double %111)
%113 = load float, float* %37
%114 = fpext float %113 to double
%115 = load float, float* %33
%116 = fneg float %115
%117 = fpext float %116 to double
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.18, i64 0, i64 0), double %114, double %117)
%119 = load float, float* %30
%120 = fpext float %119 to double
%121 = load float, float* %79
%122 = fneg float %121
%123 = fpext float %122 to double
%124 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.19, i64 0, i64 0), double %120, double %123)
ret void
}