#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 sin(long);
void rmean_and_taper(float data[], long int len, float del, int rmean,
                     float taperlen) {
  long i;
  float mean, fac;
  long talen;
  if (rmean) {
    mean = 0;
    for (i = 0; i < len; i++)
      mean += data[i] / len;
    for (i = 0; i < len; i++)
      data[i] -= mean;
  }
  if (taperlen > 0.0) {
    talen = (unsigned long int)(taperlen / del);
    if (talen > len / 2)
      talen = len / 2;
    for (i = 0; i < talen; i++) {
      fac = sin((i + 1) * 3.1415926535897 / (2. * (float)(talen + 1)));
      data[i] *= fac;
      data[len - i - 1] *= fac;
    }
  }
}


x86 assembly (clang, -O0):
<rmean_and_taper>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     11ce <rmean_and_taper+0xbe>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1187 <rmean_and_taper+0x77>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssq -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1147 <rmean_and_taper+0x37>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    11c9 <rmean_and_taper+0xb9>
movss  -0x2c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    118f <rmean_and_taper+0x7f>
jmp    11ce <rmean_and_taper+0xbe>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12ff <rmean_and_taper+0x1ef>
movss  -0x1c(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttss2si %xmm1,%rax
mov    %rax,%rdx
sar    $0x3f,%rdx
movss  0xdf7(%rip),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%rcx
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
jle    1254 <rmean_and_taper+0x144>
mov    -0x10(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    12fa <rmean_and_taper+0x1ea>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
cvtsi2sd %rax,%xmm0
movsd  0xd91(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
add    $0x1,%rax
cvtsi2ss %rax,%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xd6c(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rdi
call   1030 <sin@plt>
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    125c <rmean_and_taper+0x14c>
jmp    12ff <rmean_and_taper+0x1ef>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rmean_and_taper>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r12
mov    %rdi,%r14
test   %edx,%edx
je     1269 <rmean_and_taper+0x159>
test   %r12,%r12
jle    1269 <rmean_and_taper+0x159>
cvtsi2ss %r12,%xmm3
cmp    $0x1,%r12
jne    1141 <rmean_and_taper+0x31>
xorps  %xmm2,%xmm2
xor    %eax,%eax
jmp    1179 <rmean_and_taper+0x69>
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
xorps  %xmm4,%xmm4
xor    %eax,%eax
nopl   (%rax)
movss  (%r14,%rax,4),%xmm5
movss  0x4(%r14,%rax,4),%xmm2
divss  %xmm3,%xmm5
addss  %xmm4,%xmm5
divss  %xmm3,%xmm2
addss  %xmm5,%xmm2
add    $0x2,%rax
movaps %xmm2,%xmm4
cmp    %rax,%rcx
jne    1150 <rmean_and_taper+0x40>
test   $0x1,%r12b
je     118d <rmean_and_taper+0x7d>
movss  (%r14,%rax,4),%xmm4
divss  %xmm3,%xmm4
addss  %xmm4,%xmm2
test   %r12,%r12
jle    1269 <rmean_and_taper+0x159>
cmp    $0x8,%r12
jae    11a3 <rmean_and_taper+0x93>
xor    %eax,%eax
jmp    1250 <rmean_and_taper+0x140>
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1341 <rmean_and_taper+0x231>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r14,%rcx,4),%xmm4
movups 0x10(%r14,%rcx,4),%xmm5
movups 0x20(%r14,%rcx,4),%xmm6
movups 0x30(%r14,%rcx,4),%xmm7
subps  %xmm3,%xmm4
subps  %xmm3,%xmm5
movups %xmm4,(%r14,%rcx,4)
movups %xmm5,0x10(%r14,%rcx,4)
subps  %xmm3,%xmm6
subps  %xmm3,%xmm7
movups %xmm6,0x20(%r14,%rcx,4)
movups %xmm7,0x30(%r14,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    11e0 <rmean_and_taper+0xd0>
test   $0x1,%dl
je     1245 <rmean_and_taper+0x135>
movups (%r14,%rcx,4),%xmm4
movups 0x10(%r14,%rcx,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm3,%xmm5
movups %xmm4,(%r14,%rcx,4)
movups %xmm5,0x10(%r14,%rcx,4)
cmp    %r12,%rax
je     1269 <rmean_and_taper+0x159>
nopw   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%r12
jne    1250 <rmean_and_taper+0x140>
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
jbe    1335 <rmean_and_taper+0x225>
divss  %xmm0,%xmm1
cvttss2si %xmm1,%rax
mov    %rax,%rcx
subss  0xd77(%rip),%xmm1
sar    $0x3f,%rcx
cvttss2si %xmm1,%rdx
and    %rcx,%rdx
or     %rax,%rdx
mov    %r12,%r15
shr    $0x3f,%r15
add    %r12,%r15
sar    %r15
cmp    %rdx,%r15
cmovge %rdx,%r15
test   %r15,%r15
jle    1335 <rmean_and_taper+0x225>
lea    0x1(%r15),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
neg    %r15
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %rbx,%xmm0
mulsd  0xd18(%rip),%xmm0
divsd  (%rsp),%xmm0
cvttsd2si %xmm0,%rdi
call   1030 <sin@plt>
movss  -0x4(%r14,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r14,%rbx,4)
mulss  -0x4(%r14,%r12,4),%xmm0
movss  %xmm0,-0x4(%r14,%r12,4)
lea    (%r15,%rbx,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
add    $0xffffffffffffffff,%r12
cmp    $0x1,%rax
jne    12e0 <rmean_and_taper+0x1d0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    1229 <rmean_and_taper+0x119>
jmp    1245 <rmean_and_taper+0x135>

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

LLVM IR (-O2):
define void @rmean_and_taper(float* nocapture %0, i64 %1, float %2, i32 %3, float %4) {
%6 = icmp eq i32 %3, 0
br i1 %6, label %110, label %7
7: ; preds = %5
%8 = icmp sgt i64 %1, 0
br i1 %8, label %9, label %110
9: ; preds = %7
%10 = sitofp i64 %1 to float
%11 = and i64 %1, 1
%12 = icmp eq i64 %1, 1
br i1 %12, label %15, label %13
13: ; preds = %9
%14 = and i64 %1, -2
br label %87
15: ; preds = %87, %9
%16 = phi float [ undef, %9 ], [ %99, %87 ]
%17 = phi i64 [ 0, %9 ], [ %100, %87 ]
%18 = phi float [ 0.000000e+00, %9 ], [ %99, %87 ]
%19 = icmp eq i64 %11, 0
br i1 %19, label %25, label %20
20: ; preds = %15
%21 = getelementptr inbounds float, float* %0, i64 %17
%22 = load float, float* %21
%23 = fdiv float %22, %10
%24 = fadd float %18, %23
br label %25
25: ; preds = %15, %20
%26 = phi float [ %16, %15 ], [ %24, %20 ]
br i1 %8, label %27, label %110
27: ; preds = %25
%28 = icmp ult i64 %1, 8
br i1 %28, label %85, label %29
29: ; preds = %27
%30 = and i64 %1, -8
%31 = insertelement <4 x float> poison, float %26, i64 0
%32 = shufflevector <4 x float> %31, <4 x float> poison, <4 x i32> zeroinitializer
%33 = insertelement <4 x float> poison, float %26, i64 0
%34 = shufflevector <4 x float> %33, <4 x float> poison, <4 x i32> zeroinitializer
%35 = add i64 %30, -8
%36 = lshr exact i64 %35, 3
%37 = add nuw nsw i64 %36, 1
%38 = and i64 %37, 1
%39 = icmp eq i64 %35, 0
br i1 %39, label %69, label %40
40: ; preds = %29
%41 = and i64 %37, 4611686018427387902
br label %42
42: ; preds = %42, %40
%43 = phi i64 [ 0, %40 ], [ %66, %42 ]
%44 = phi i64 [ 0, %40 ], [ %67, %42 ]
%45 = getelementptr inbounds float, float* %0, i64 %43
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = getelementptr inbounds float, float* %45, i64 4
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = fsub <4 x float> %47, %32
%52 = fsub <4 x float> %50, %34
%53 = bitcast float* %45 to <4 x float>*
store <4 x float> %51, <4 x float>* %53
%54 = bitcast float* %48 to <4 x float>*
store <4 x float> %52, <4 x float>* %54
%55 = or i64 %43, 8
%56 = getelementptr inbounds float, float* %0, i64 %55
%57 = bitcast float* %56 to <4 x float>*
%58 = load <4 x float>, <4 x float>* %57
%59 = getelementptr inbounds float, float* %56, i64 4
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = fsub <4 x float> %58, %32
%63 = fsub <4 x float> %61, %34
%64 = bitcast float* %56 to <4 x float>*
store <4 x float> %62, <4 x float>* %64
%65 = bitcast float* %59 to <4 x float>*
store <4 x float> %63, <4 x float>* %65
%66 = add nuw i64 %43, 16
%67 = add i64 %44, 2
%68 = icmp eq i64 %67, %41
br i1 %68, label %69, label %42
69: ; preds = %42, %29
%70 = phi i64 [ 0, %29 ], [ %66, %42 ]
%71 = icmp eq i64 %38, 0
br i1 %71, label %83, label %72
72: ; preds = %69
%73 = getelementptr inbounds float, float* %0, i64 %70
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %73, i64 4
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = fsub <4 x float> %75, %32
%80 = fsub <4 x float> %78, %34
%81 = bitcast float* %73 to <4 x float>*
store <4 x float> %79, <4 x float>* %81
%82 = bitcast float* %76 to <4 x float>*
store <4 x float> %80, <4 x float>* %82
br label %83
83: ; preds = %69, %72
%84 = icmp eq i64 %30, %1
br i1 %84, label %110, label %85
85: ; preds = %27, %83
%86 = phi i64 [ 0, %27 ], [ %30, %83 ]
br label %103
87: ; preds = %87, %13
%88 = phi i64 [ 0, %13 ], [ %100, %87 ]
%89 = phi float [ 0.000000e+00, %13 ], [ %99, %87 ]
%90 = phi i64 [ 0, %13 ], [ %101, %87 ]
%91 = getelementptr inbounds float, float* %0, i64 %88
%92 = load float, float* %91
%93 = fdiv float %92, %10
%94 = fadd float %89, %93
%95 = or i64 %88, 1
%96 = getelementptr inbounds float, float* %0, i64 %95
%97 = load float, float* %96
%98 = fdiv float %97, %10
%99 = fadd float %94, %98
%100 = add nuw nsw i64 %88, 2
%101 = add i64 %90, 2
%102 = icmp eq i64 %101, %14
br i1 %102, label %15, label %87
103: ; preds = %85, %103
%104 = phi i64 [ %108, %103 ], [ %86, %85 ]
%105 = getelementptr inbounds float, float* %0, i64 %104
%106 = load float, float* %105
%107 = fsub float %106, %26
store float %107, float* %105
%108 = add nuw nsw i64 %104, 1
%109 = icmp eq i64 %108, %1
br i1 %109, label %110, label %103
110: ; preds = %103, %83, %7, %25, %5
%111 = fcmp ogt float %4, 0.000000e+00
br i1 %111, label %112, label %141
112: ; preds = %110
%113 = fdiv float %4, %2
%114 = fptoui float %113 to i64
%115 = sdiv i64 %1, 2
%116 = icmp slt i64 %115, %114
%117 = select i1 %116, i64 %115, i64 %114
%118 = icmp sgt i64 %117, 0
br i1 %118, label %119, label %141
119: ; preds = %112
%120 = add nuw nsw i64 %117, 1
%121 = sitofp i64 %120 to float
%122 = fpext float %121 to double
%123 = fmul double %122, 2.000000e+00
br label %124
124: ; preds = %119, %124
%125 = phi i64 [ 0, %119 ], [ %126, %124 ]
%126 = add nuw nsw i64 %125, 1
%127 = sitofp i64 %126 to double
%128 = fmul double %127, 0x400921FB54442C46
%129 = fdiv double %128, %123
%130 = fptosi double %129 to i64
%131 = tail call float @sin(i64 %130)
%132 = getelementptr inbounds float, float* %0, i64 %125
%133 = load float, float* %132
%134 = fmul float %131, %133
store float %134, float* %132
%135 = xor i64 %125, -1
%136 = add i64 %135, %1
%137 = getelementptr inbounds float, float* %0, i64 %136
%138 = load float, float* %137
%139 = fmul float %131, %138
store float %139, float* %137
%140 = icmp eq i64 %126, %117
br i1 %140, label %141, label %124
141: ; preds = %124, %112, %110
ret void
}