#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 */
float Izero(float);
scalar_t__ sqrt(float);
void CalculateKBDWindow(float *win, float alpha, int length) {
  int i;
  float IBeta;
  float tmp;
  float sum = 0.0;
  alpha *= 3.14159265359f;
  IBeta = 1.0f / Izero(alpha);
  for (i = 0; i < (length >> 1); i++) {
    tmp = 4.0f * (float)i / (float)length - 1.0f;
    win[i] = Izero(alpha * (float)sqrt(1.0f - tmp * tmp)) * IBeta;
    sum += win[i];
  }
  sum = 1.0f / sum;
  tmp = 0.0f;
  for (i = 0; i < (length >> 1); i++) {
    tmp += win[i];
    win[i] = (float)sqrt(tmp * sum);
  }
}


x86 assembly (clang, -O0):
<CalculateKBDWindow>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xec0(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0xc(%rbp),%xmm0
call   1030 <Izero@plt>
movaps %xmm0,%xmm1
movss  0xe9d(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jge    122f <CalculateKBDWindow+0x10f>
cvtsi2ssl -0x14(%rbp),%xmm1
movss  0xe77(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtsi2ssl -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  0xe5a(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xe24(%rip),%xmm1
addss  %xmm1,%xmm0
call   1040 <sqrt@plt>
movss  -0x24(%rbp),%xmm0
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
call   1030 <Izero@plt>
mulss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1173 <CalculateKBDWindow+0x53>
movss  0xdc9(%rip),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jge    12a7 <CalculateKBDWindow+0x187>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
call   1040 <sqrt@plt>
cvtsi2ss %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1250 <CalculateKBDWindow+0x130>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CalculateKBDWindow>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r14d
mov    %rdi,%rbx
mulss  0xec8(%rip),%xmm0
movss  %xmm0,0xc(%rsp)
call   1030 <Izero@plt>
cmp    $0x2,%r14d
jl     12d0 <CalculateKBDWindow+0x1b0>
movss  0xeaf(%rip),%xmm2
movaps %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
mov    %r14d,%eax
sar    %eax
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movss  %xmm0,0x10(%rsp)
cmp    $0x2,%eax
mov    $0x1,%r15d
cmovge %eax,%r15d
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movss  %xmm0,0x8(%rsp)
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
mulss  0xe63(%rip),%xmm1
divss  0x10(%rsp),%xmm1
addss  0xe59(%rip),%xmm1
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm2
movaps %xmm2,%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xc(%rsp),%xmm0
call   1030 <Izero@plt>
movss  0xe26(%rip),%xmm2
mulss  0x14(%rsp),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
movss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
movss  0x8(%rsp),%xmm0
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1190 <CalculateKBDWindow+0x70>
cmp    $0x2,%r14d
jl     12d0 <CalculateKBDWindow+0x1b0>
divss  %xmm0,%xmm2
cmp    $0x4,%r14d
jge    1226 <CalculateKBDWindow+0x106>
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    12ac <CalculateKBDWindow+0x18c>
mov    %r15d,%r14d
and    $0x7ffffffe,%r14d
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
movss  %xmm2,0xc(%rsp)
nopl   0x0(%rax,%rax,1)
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,0x8(%rsp)
mulss  0x8(%rsp),%xmm2
movaps %xmm2,%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
movss  0x8(%rsp),%xmm0
addss  0x4(%rbx,%rbp,4),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0xc(%rsp),%xmm0
mulss  0x8(%rsp),%xmm0
call   1040 <sqrt@plt>
movss  0xc(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x4(%rbx,%rbp,4)
movss  0x8(%rsp),%xmm0
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1240 <CalculateKBDWindow+0x120>
test   $0x1,%r15b
je     12d0 <CalculateKBDWindow+0x1b0>
addss  (%rbx,%rbp,4),%xmm0
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm0
call   1040 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x18,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @CalculateKBDWindow(float* %0, float %1, i32 %2) {
%4 = alloca float*
%5 = alloca float
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float
store float* %0, float** %4
store float %1, float* %5
store i32 %2, i32* %6
store float 0.000000e+00, float* %10
%11 = load float, float* %5
%12 = fmul float %11, 0x400921FB60000000
store float %12, float* %5
%13 = load float, float* %5
%14 = call float @Izero(float %13)
%15 = fdiv float 1.000000e+00, %14
store float %15, float* %8
store i32 0, i32* %7
br label %16
16: ; preds = %51, %3
%17 = load i32, i32* %7
%18 = load i32, i32* %6
%19 = ashr i32 %18, 1
%20 = icmp slt i32 %17, %19
br i1 %20, label %21, label %54
21: ; preds = %16
%22 = load i32, i32* %7
%23 = sitofp i32 %22 to float
%24 = fmul float 4.000000e+00, %23
%25 = load i32, i32* %6
%26 = sitofp i32 %25 to float
%27 = fdiv float %24, %26
%28 = fsub float %27, 1.000000e+00
store float %28, float* %9
%29 = load float, float* %5
%30 = load float, float* %9
%31 = load float, float* %9
%32 = fneg float %30
%33 = call float @llvm.fmuladd.f32(float %32, float %31, float 1.000000e+00)
%34 = call i64 @sqrt(float %33)
%35 = sitofp i64 %34 to float
%36 = fmul float %29, %35
%37 = call float @Izero(float %36)
%38 = load float, float* %8
%39 = fmul float %37, %38
%40 = load float*, float** %4
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float %39, float* %43
%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* %10
%50 = fadd float %49, %48
store float %50, float* %10
br label %51
51: ; preds = %21
%52 = load i32, i32* %7
%53 = add nsw i32 %52, 1
store i32 %53, i32* %7
br label %16
54: ; preds = %16
%55 = load float, float* %10
%56 = fdiv float 1.000000e+00, %55
store float %56, float* %10
store float 0.000000e+00, float* %9
store i32 0, i32* %7
br label %57
57: ; preds = %79, %54
%58 = load i32, i32* %7
%59 = load i32, i32* %6
%60 = ashr i32 %59, 1
%61 = icmp slt i32 %58, %60
br i1 %61, label %62, label %82
62: ; preds = %57
%63 = load float*, float** %4
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %63, i64 %65
%67 = load float, float* %66
%68 = load float, float* %9
%69 = fadd float %68, %67
store float %69, float* %9
%70 = load float, float* %9
%71 = load float, float* %10
%72 = fmul float %70, %71
%73 = call i64 @sqrt(float %72)
%74 = sitofp i64 %73 to float
%75 = load float*, float** %4
%76 = load i32, i32* %7
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
store float %74, float* %78
br label %79
79: ; preds = %62
%80 = load i32, i32* %7
%81 = add nsw i32 %80, 1
store i32 %81, i32* %7
br label %57
82: ; preds = %57
ret void
}

LLVM IR (-O2):
define void @CalculateKBDWindow(float* nocapture %0, float %1, i32 %2) {
%4 = fmul float %1, 0x400921FB60000000
%5 = tail call float @Izero(float %4)
%6 = fdiv float 1.000000e+00, %5
%7 = icmp sgt i32 %2, 1
br i1 %7, label %8, label %70
8: ; preds = %3
%9 = ashr i32 %2, 1
%10 = sitofp i32 %2 to float
%11 = call i32 @llvm.smax.i32(i32 %9, i32 1)
%12 = zext i32 %11 to i64
br label %13
13: ; preds = %8, %13
%14 = phi i64 [ 0, %8 ], [ %30, %13 ]
%15 = phi float [ 0.000000e+00, %8 ], [ %29, %13 ]
%16 = trunc i64 %14 to i32
%17 = sitofp i32 %16 to float
%18 = fmul float %17, 4.000000e+00
%19 = fdiv float %18, %10
%20 = fadd float %19, -1.000000e+00
%21 = fneg float %20
%22 = tail call float @llvm.fmuladd.f32(float %21, float %20, float 1.000000e+00)
%23 = tail call i64 @sqrt(float %22)
%24 = sitofp i64 %23 to float
%25 = fmul float %4, %24
%26 = tail call float @Izero(float %25)
%27 = fmul float %6, %26
%28 = getelementptr inbounds float, float* %0, i64 %14
store float %27, float* %28
%29 = fadd float %15, %27
%30 = add nuw nsw i64 %14, 1
%31 = icmp eq i64 %30, %12
br i1 %31, label %32, label %13
32: ; preds = %13
%33 = fdiv float 1.000000e+00, %29
br i1 %7, label %34, label %70
34: ; preds = %32
%35 = and i64 %12, 1
%36 = icmp slt i32 %2, 4
br i1 %36, label %59, label %37
37: ; preds = %34
%38 = and i64 %12, 2147483646
br label %39
39: ; preds = %39, %37
%40 = phi i64 [ 0, %37 ], [ %56, %39 ]
%41 = phi float [ 0.000000e+00, %37 ], [ %52, %39 ]
%42 = phi i64 [ 0, %37 ], [ %57, %39 ]
%43 = getelementptr inbounds float, float* %0, i64 %40
%44 = load float, float* %43
%45 = fadd float %41, %44
%46 = fmul float %33, %45
%47 = tail call i64 @sqrt(float %46)
%48 = sitofp i64 %47 to float
store float %48, float* %43
%49 = or i64 %40, 1
%50 = getelementptr inbounds float, float* %0, i64 %49
%51 = load float, float* %50
%52 = fadd float %45, %51
%53 = fmul float %33, %52
%54 = tail call i64 @sqrt(float %53)
%55 = sitofp i64 %54 to float
store float %55, float* %50
%56 = add nuw nsw i64 %40, 2
%57 = add i64 %42, 2
%58 = icmp eq i64 %57, %38
br i1 %58, label %59, label %39
59: ; preds = %39, %34
%60 = phi i64 [ 0, %34 ], [ %56, %39 ]
%61 = phi float [ 0.000000e+00, %34 ], [ %52, %39 ]
%62 = icmp eq i64 %35, 0
br i1 %62, label %70, label %63
63: ; preds = %59
%64 = getelementptr inbounds float, float* %0, i64 %60
%65 = load float, float* %64
%66 = fadd float %61, %65
%67 = fmul float %33, %66
%68 = tail call i64 @sqrt(float %67)
%69 = sitofp i64 %68 to float
store float %69, float* %64
br label %70
70: ; preds = %63, %59, %3, %32
ret void
}