#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 cos(int);
float sqrt(float);
void RCFilter(short int *in, short int np, float cutoff, float timebase) {
  short i;
  float a, b, y;
  a = 2 - cos(2 * 3.1415926535897932384626433832795 * cutoff * timebase);
  if (a != 1) {
    a = a - sqrt(a * a - 1);
    b = 1 - a;
    y = b * in[0];
    for (i = 0; i < np; i++)
      in[i] = y = b * in[i] + a * y;
    y *= b;
    for (i = np - 1; i >= 0; i--)
      in[i] = y = b * in[i] + a * y;
  }
}


x86 assembly (clang, -O0):
<RCFilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %si,%ax
mov    %rdi,-0x8(%rbp)
mov    %ax,-0xa(%rbp)
movss  %xmm0,-0x10(%rbp)
movss  %xmm1,-0x14(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeba(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1030 <cos@plt>
mov    %eax,%ecx
mov    $0x2,%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  0xe79(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    119b <RCFilter+0x7b>
jp     119b <RCFilter+0x7b>
jmp    12ee <RCFilter+0x1ce>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xe49(%rip),%xmm1
addss  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xe23(%rip),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movswl (%rax),%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movw   $0x0,-0x16(%rbp)
movswl -0x16(%rbp),%eax
movswl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    126c <RCFilter+0x14c>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movswq -0x16(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm2
movss  -0x1c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movswq -0x16(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x16(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x16(%rbp)
jmp    1206 <RCFilter+0xe6>
movss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movswl -0xa(%rbp),%eax
sub    $0x1,%eax
mov    %ax,-0x16(%rbp)
movswl -0x16(%rbp),%eax
cmp    $0x0,%eax
jl     12e9 <RCFilter+0x1c9>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movswq -0x16(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm2
movss  -0x1c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movswq -0x16(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x16(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x16(%rbp)
jmp    1286 <RCFilter+0x166>
jmp    12ee <RCFilter+0x1ce>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RCFilter>:
push   %r14
push   %rbx
push   %rax
mov    %esi,%ebx
mov    %rdi,%r14
cvtss2sd %xmm0,%xmm0
mulsd  0xecb(%rip),%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
call   1030 <cos@plt>
cmp    $0x1,%eax
je     1324 <RCFilter+0x204>
mov    $0x2,%ecx
sub    %eax,%ecx
cvtsi2ss %ecx,%xmm4
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
addss  0xe9f(%rip),%xmm0
xorpd  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1178 <RCFilter+0x58>
sqrtss %xmm0,%xmm0
jmp    1189 <RCFilter+0x69>
movss  %xmm4,0x4(%rsp)
call   1040 <sqrt@plt>
movss  0x4(%rsp),%xmm4
subss  %xmm0,%xmm4
movswl (%r14),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0xe6c(%rip),%xmm0
subss  %xmm4,%xmm0
mulss  %xmm0,%xmm1
test   %bx,%bx
jle    127c <RCFilter+0x15c>
cwtl
cvtsi2ss %eax,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm4,%xmm3
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
cvttss2si %xmm1,%eax
mov    %ax,(%r14)
cmp    $0x1,%bx
je     127c <RCFilter+0x15c>
movzwl %bx,%ecx
add    $0xffffffffffffffff,%rcx
cmp    $0x2,%bx
jne    11ee <RCFilter+0xce>
mov    $0x1,%eax
jmp    1256 <RCFilter+0x136>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%eax
nopl   (%rax)
movswl (%r14,%rax,2),%esi
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
cvttss2si %xmm2,%esi
mov    %si,(%r14,%rax,2)
movswl 0x2(%r14,%rax,2),%esi
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
mulss  %xmm4,%xmm2
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
cvttss2si %xmm1,%esi
mov    %si,0x2(%r14,%rax,2)
lea    (%rdx,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    1200 <RCFilter+0xe0>
test   $0x1,%cl
je     127c <RCFilter+0x15c>
movswl (%r14,%rax,2),%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm2
addss  %xmm2,%xmm1
cvttss2si %xmm1,%ecx
mov    %cx,(%r14,%rax,2)
mov    %ebx,%eax
add    $0xffff,%ax
js     1324 <RCFilter+0x204>
mulss  %xmm0,%xmm1
test   $0x1,%bl
jne    129d <RCFilter+0x17d>
mov    %eax,%ebx
test   %ax,%ax
jne    12d0 <RCFilter+0x1b0>
jmp    1324 <RCFilter+0x204>
movzwl %ax,%ecx
movswl (%r14,%rcx,2),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm2
addss  %xmm2,%xmm1
cvttss2si %xmm1,%edx
mov    %dx,(%r14,%rcx,2)
add    $0xfffffffe,%ebx
test   %ax,%ax
je     1324 <RCFilter+0x204>
nopl   0x0(%rax)
movzwl %bx,%eax
movswl (%r14,%rax,2),%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
cvttss2si %xmm2,%ecx
mov    %cx,(%r14,%rax,2)
lea    -0x1(%rbx),%ecx
movzwl %cx,%ecx
movswl (%r14,%rcx,2),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm4,%xmm2
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
cvttss2si %xmm1,%edx
mov    %dx,(%r14,%rcx,2)
add    $0xfffffffe,%ebx
cmp    $0x1,%ax
jg     12d0 <RCFilter+0x1b0>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @RCFilter(i16* %0, i16 signext %1, float %2, float %3) {
%5 = alloca i16*
%6 = alloca i16
%7 = alloca float
%8 = alloca float
%9 = alloca i16
%10 = alloca float
%11 = alloca float
%12 = alloca float
store i16* %0, i16** %5
store i16 %1, i16* %6
store float %2, float* %7
store float %3, float* %8
%13 = load float, float* %7
%14 = fpext float %13 to double
%15 = fmul double 0x401921FB54442D18, %14
%16 = load float, float* %8
%17 = fpext float %16 to double
%18 = fmul double %15, %17
%19 = fptosi double %18 to i32
%20 = call i32 @cos(i32 %19)
%21 = sub nsw i32 2, %20
%22 = sitofp i32 %21 to float
store float %22, float* %10
%23 = load float, float* %10
%24 = fcmp une float %23, 1.000000e+00
br i1 %24, label %25, label %102
25: ; preds = %4
%26 = load float, float* %10
%27 = load float, float* %10
%28 = load float, float* %10
%29 = call float @llvm.fmuladd.f32(float %27, float %28, float -1.000000e+00)
%30 = call float @sqrt(float %29)
%31 = fsub float %26, %30
store float %31, float* %10
%32 = load float, float* %10
%33 = fsub float 1.000000e+00, %32
store float %33, float* %11
%34 = load float, float* %11
%35 = load i16*, i16** %5
%36 = getelementptr inbounds i16, i16* %35, i64 0
%37 = load i16, i16* %36
%38 = sext i16 %37 to i32
%39 = sitofp i32 %38 to float
%40 = fmul float %34, %39
store float %40, float* %12
store i16 0, i16* %9
br label %41
41: ; preds = %65, %25
%42 = load i16, i16* %9
%43 = sext i16 %42 to i32
%44 = load i16, i16* %6
%45 = sext i16 %44 to i32
%46 = icmp slt i32 %43, %45
br i1 %46, label %47, label %68
47: ; preds = %41
%48 = load float, float* %11
%49 = load i16*, i16** %5
%50 = load i16, i16* %9
%51 = sext i16 %50 to i64
%52 = getelementptr inbounds i16, i16* %49, i64 %51
%53 = load i16, i16* %52
%54 = sext i16 %53 to i32
%55 = sitofp i32 %54 to float
%56 = load float, float* %10
%57 = load float, float* %12
%58 = fmul float %56, %57
%59 = call float @llvm.fmuladd.f32(float %48, float %55, float %58)
store float %59, float* %12
%60 = fptosi float %59 to i16
%61 = load i16*, i16** %5
%62 = load i16, i16* %9
%63 = sext i16 %62 to i64
%64 = getelementptr inbounds i16, i16* %61, i64 %63
store i16 %60, i16* %64
br label %65
65: ; preds = %47
%66 = load i16, i16* %9
%67 = add i16 %66, 1
store i16 %67, i16* %9
br label %41
68: ; preds = %41
%69 = load float, float* %11
%70 = load float, float* %12
%71 = fmul float %70, %69
store float %71, float* %12
%72 = load i16, i16* %6
%73 = sext i16 %72 to i32
%74 = sub nsw i32 %73, 1
%75 = trunc i32 %74 to i16
store i16 %75, i16* %9
br label %76
76: ; preds = %98, %68
%77 = load i16, i16* %9
%78 = sext i16 %77 to i32
%79 = icmp sge i32 %78, 0
br i1 %79, label %80, label %101
80: ; preds = %76
%81 = load float, float* %11
%82 = load i16*, i16** %5
%83 = load i16, i16* %9
%84 = sext i16 %83 to i64
%85 = getelementptr inbounds i16, i16* %82, i64 %84
%86 = load i16, i16* %85
%87 = sext i16 %86 to i32
%88 = sitofp i32 %87 to float
%89 = load float, float* %10
%90 = load float, float* %12
%91 = fmul float %89, %90
%92 = call float @llvm.fmuladd.f32(float %81, float %88, float %91)
store float %92, float* %12
%93 = fptosi float %92 to i16
%94 = load i16*, i16** %5
%95 = load i16, i16* %9
%96 = sext i16 %95 to i64
%97 = getelementptr inbounds i16, i16* %94, i64 %96
store i16 %93, i16* %97
br label %98
98: ; preds = %80
%99 = load i16, i16* %9
%100 = add i16 %99, -1
store i16 %100, i16* %9
br label %76
101: ; preds = %76
br label %102
102: ; preds = %101, %4
ret void
}

LLVM IR (-O2):
define void @RCFilter(i16* nocapture %0, i16 signext %1, float %2, float %3) {
%5 = fpext float %2 to double
%6 = fmul double %5, 0x401921FB54442D18
%7 = fpext float %3 to double
%8 = fmul double %6, %7
%9 = fptosi double %8 to i32
%10 = tail call i32 @cos(i32 %9)
%11 = sub nsw i32 2, %10
%12 = sitofp i32 %11 to float
%13 = icmp eq i32 %10, 1
br i1 %13, label %112, label %14
14: ; preds = %4
%15 = tail call float @llvm.fmuladd.f32(float %12, float %12, float -1.000000e+00)
%16 = tail call float @sqrt(float %15)
%17 = fsub float %12, %16
%18 = fsub float 1.000000e+00, %17
%19 = load i16, i16* %0
%20 = sitofp i16 %19 to float
%21 = fmul float %18, %20
%22 = icmp sgt i16 %1, 0
br i1 %22, label %23, label %71
23: ; preds = %14
%24 = sitofp i16 %19 to float
%25 = fmul float %17, %21
%26 = tail call float @llvm.fmuladd.f32(float %18, float %24, float %25)
%27 = fptosi float %26 to i16
store i16 %27, i16* %0
%28 = icmp eq i16 %1, 1
br i1 %28, label %71, label %29
29: ; preds = %23
%30 = zext i16 %1 to i64
%31 = add nsw i64 %30, -1
%32 = and i64 %31, 1
%33 = icmp eq i16 %1, 2
br i1 %33, label %58, label %34
34: ; preds = %29
%35 = and i64 %31, -2
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 1, %34 ], [ %55, %36 ]
%38 = phi float [ %26, %34 ], [ %53, %36 ]
%39 = phi i64 [ 0, %34 ], [ %56, %36 ]
%40 = getelementptr inbounds i16, i16* %0, i64 %37
%41 = load i16, i16* %40
%42 = getelementptr inbounds i16, i16* %0, i64 %37
%43 = sitofp i16 %41 to float
%44 = fmul float %17, %38
%45 = tail call float @llvm.fmuladd.f32(float %18, float %43, float %44)
%46 = fptosi float %45 to i16
store i16 %46, i16* %42
%47 = add nuw nsw i64 %37, 1
%48 = getelementptr inbounds i16, i16* %0, i64 %47
%49 = load i16, i16* %48
%50 = getelementptr inbounds i16, i16* %0, i64 %47
%51 = sitofp i16 %49 to float
%52 = fmul float %17, %45
%53 = tail call float @llvm.fmuladd.f32(float %18, float %51, float %52)
%54 = fptosi float %53 to i16
store i16 %54, i16* %50
%55 = add nuw nsw i64 %37, 2
%56 = add nuw nsw i64 %39, 2
%57 = icmp eq i64 %56, %35
br i1 %57, label %58, label %36
58: ; preds = %36, %29
%59 = phi float [ undef, %29 ], [ %53, %36 ]
%60 = phi i64 [ 1, %29 ], [ %55, %36 ]
%61 = phi float [ %26, %29 ], [ %53, %36 ]
%62 = icmp eq i64 %32, 0
br i1 %62, label %71, label %63
63: ; preds = %58
%64 = getelementptr inbounds i16, i16* %0, i64 %60
%65 = load i16, i16* %64
%66 = getelementptr inbounds i16, i16* %0, i64 %60
%67 = sitofp i16 %65 to float
%68 = fmul float %17, %61
%69 = tail call float @llvm.fmuladd.f32(float %18, float %67, float %68)
%70 = fptosi float %69 to i16
store i16 %70, i16* %66
br label %71
71: ; preds = %63, %58, %23, %14
%72 = phi float [ %21, %14 ], [ %26, %23 ], [ %59, %58 ], [ %69, %63 ]
%73 = add i16 %1, -1
%74 = icmp sgt i16 %73, -1
br i1 %74, label %75, label %112
75: ; preds = %71
%76 = fmul float %18, %72
%77 = and i16 %1, 1
%78 = icmp eq i16 %77, 0
br i1 %78, label %88, label %79
79: ; preds = %75
%80 = zext i16 %73 to i64
%81 = getelementptr inbounds i16, i16* %0, i64 %80
%82 = load i16, i16* %81
%83 = sitofp i16 %82 to float
%84 = fmul float %17, %76
%85 = tail call float @llvm.fmuladd.f32(float %18, float %83, float %84)
%86 = fptosi float %85 to i16
store i16 %86, i16* %81
%87 = add i16 %1, -2
br label %88
88: ; preds = %79, %75
%89 = phi i16 [ %73, %75 ], [ %87, %79 ]
%90 = phi float [ %76, %75 ], [ %85, %79 ]
%91 = icmp eq i16 %73, 0
br i1 %91, label %112, label %92
92: ; preds = %88, %92
%93 = phi i16 [ %110, %92 ], [ %89, %88 ]
%94 = phi float [ %108, %92 ], [ %90, %88 ]
%95 = zext i16 %93 to i64
%96 = getelementptr inbounds i16, i16* %0, i64 %95
%97 = load i16, i16* %96
%98 = sitofp i16 %97 to float
%99 = fmul float %17, %94
%100 = tail call float @llvm.fmuladd.f32(float %18, float %98, float %99)
%101 = fptosi float %100 to i16
store i16 %101, i16* %96
%102 = add nsw i16 %93, -1
%103 = zext i16 %102 to i64
%104 = getelementptr inbounds i16, i16* %0, i64 %103
%105 = load i16, i16* %104
%106 = sitofp i16 %105 to float
%107 = fmul float %17, %100
%108 = tail call float @llvm.fmuladd.f32(float %18, float %106, float %107)
%109 = fptosi float %108 to i16
store i16 %109, i16* %104
%110 = add nsw i16 %93, -2
%111 = icmp sgt i16 %93, 1
br i1 %111, label %92, label %112
112: ; preds = %88, %92, %71, %4
ret void
}