#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 */
typedef int uint8_t;

/* Variables and functions */
float filterApplyAveragef(float input, uint8_t averageCount,
                          float averageState[12]) {
  int count;
  float averageSum = 0.0f;
  for (count = averageCount - 1; count > 0; count--)
    averageState[count] = averageState[count - 1];
  averageState[0] = input;
  for (count = 0; count < averageCount; count++)
    averageSum += averageState[count];
  return averageSum / averageCount;
}


x86 assembly (clang, -O0):
<filterApplyAveragef>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1158 <filterApplyAveragef+0x58>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1121 <filterApplyAveragef+0x21>
movss  -0x4(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    119d <filterApplyAveragef+0x9d>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116c <filterApplyAveragef+0x6c>
movss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<filterApplyAveragef>:
push   %r15
push   %r14
push   %rbx
mov    %edi,%r10d
cmp    $0x2,%edi
jl     1163 <filterApplyAveragef+0x63>
mov    $0xfffffffe,%ecx
xor    %eax,%eax
mov    %r10,%rdx
sub    $0x2,%rdx
mov    $0x0,%r11d
cmovae %rdx,%r11
add    $0x1,%r11
cmp    $0x8,%r11
jae    11ad <filterApplyAveragef+0xad>
mov    %r10,%rax
add    %rax,%rcx
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
mov    %ecx,%edx
movss  (%rsi,%rdx,4),%xmm1
mov    %eax,%edx
movss  %xmm1,(%rsi,%rdx,4)
add    $0xffffffffffffffff,%rcx
lea    -0x1(%rax),%rdx
add    $0x1,%rax
cmp    $0x2,%rax
mov    %rdx,%rax
ja     1140 <filterApplyAveragef+0x40>
movss  %xmm0,(%rsi)
test   %edi,%edi
jle    11a5 <filterApplyAveragef+0xa5>
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
cmp    $0x1,%edi
je     138e <filterApplyAveragef+0x28e>
lea    -0x1(%r10),%rdx
add    $0xfffffffffffffffe,%r10
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x7,%r10
jae    131d <filterApplyAveragef+0x21d>
mov    $0x1,%eax
test   %rcx,%rcx
jne    1372 <filterApplyAveragef+0x272>
jmp    138e <filterApplyAveragef+0x28e>
xorps  %xmm0,%xmm0
jmp    138e <filterApplyAveragef+0x28e>
mov    %r10d,%edx
sub    $0x2,%edx
cmovb  %eax,%edx
mov    %r10,%rbx
sub    $0x2,%rbx
cmovae %rbx,%rax
lea    -0x1(%rdi),%r8d
cmp    %edx,%r8d
jb     112f <filterApplyAveragef+0x2f>
mov    %rax,%rbx
shr    $0x20,%rbx
jne    112f <filterApplyAveragef+0x2f>
lea    -0x2(%rdi),%r9d
cmp    %edx,%r9d
jb     112f <filterApplyAveragef+0x2f>
test   %rbx,%rbx
jne    112f <filterApplyAveragef+0x2f>
lea    (%rsi,%r8,4),%rdx
shl    $0x2,%rax
mov    %rdx,%rbx
sub    %rax,%rbx
cmp    %rdx,%rbx
ja     112f <filterApplyAveragef+0x2f>
xor    %edx,%edx
test   %dl,%dl
jne    112f <filterApplyAveragef+0x2f>
lea    (%rsi,%r9,4),%rdx
mov    %rdx,%rbx
sub    %rax,%rbx
cmp    %rdx,%rbx
ja     112f <filterApplyAveragef+0x2f>
xor    %eax,%eax
test   %al,%al
jne    112f <filterApplyAveragef+0x2f>
cmp    $0x2,%r10
mov    $0x2,%eax
cmovb  %r10,%rax
lea    (%rax,%r8,1),%rdx
sub    %r10,%rdx
lea    (%rsi,%rdx,4),%rdx
lea    (%rsi,%r9,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%rdx
jae    126f <filterApplyAveragef+0x16f>
lea    (%rsi,%r8,4),%rdx
add    $0x4,%rdx
add    %r9,%rax
sub    %r10,%rax
lea    (%rsi,%rax,4),%rax
cmp    %rdx,%rax
jb     112f <filterApplyAveragef+0x2f>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     139f <filterApplyAveragef+0x29f>
mov    %r9,%r15
and    $0xfffffffffffffffe,%r15
lea    (%rcx,%r10,1),%rbx
add    $0xfffffffffffffff8,%rbx
xor    %r14d,%r14d
lea    0x9(%rbx),%eax
lea    0x8(%rbx),%edx
movups -0x1c(%rsi,%rdx,4),%xmm1
movups -0xc(%rsi,%rdx,4),%xmm2
movups %xmm2,-0xc(%rsi,%rax,4)
movups %xmm1,-0x1c(%rsi,%rax,4)
mov    %ebx,%eax
lea    0x1(%rbx),%edx
movups -0x1c(%rsi,%rax,4),%xmm1
movups -0xc(%rsi,%rax,4),%xmm2
movups %xmm2,-0xc(%rsi,%rdx,4)
movups %xmm1,-0x1c(%rsi,%rdx,4)
add    $0x10,%r14
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%r15
jne    12a0 <filterApplyAveragef+0x1a0>
test   $0x1,%r9b
je     1309 <filterApplyAveragef+0x209>
mov    %r10d,%eax
sub    %r14d,%eax
lea    (%rcx,%rax,1),%edx
add    %ecx,%eax
add    $0x1,%eax
movups -0x1c(%rsi,%rdx,4),%xmm1
movups -0xc(%rsi,%rdx,4),%xmm2
movups %xmm2,-0xc(%rsi,%rax,4)
movups %xmm1,-0x1c(%rsi,%rax,4)
cmp    %r8,%r11
je     1163 <filterApplyAveragef+0x63>
mov    %r10,%rax
sub    %r8,%rax
jmp    1132 <filterApplyAveragef+0x32>
and    $0xfffffffffffffff8,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  0x4(%rsi,%rax,4),%xmm0
addss  0x8(%rsi,%rax,4),%xmm0
addss  0xc(%rsi,%rax,4),%xmm0
addss  0x10(%rsi,%rax,4),%xmm0
addss  0x14(%rsi,%rax,4),%xmm0
addss  0x18(%rsi,%rax,4),%xmm0
addss  0x1c(%rsi,%rax,4),%xmm0
addss  0x20(%rsi,%rax,4),%xmm0
add    $0x8,%rax
cmp    %rax,%rdx
jne    1330 <filterApplyAveragef+0x230>
add    $0x1,%rax
test   %rcx,%rcx
je     138e <filterApplyAveragef+0x28e>
lea    (%rsi,%rax,4),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addss  (%rax,%rdx,4),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1380 <filterApplyAveragef+0x280>
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
divss  %xmm1,%xmm0
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %r14d,%r14d
test   $0x1,%r9b
jne    12e7 <filterApplyAveragef+0x1e7>
jmp    1309 <filterApplyAveragef+0x209>

LLVM IR (-O0):
define float @filterApplyAveragef(float %0, i32 %1, float* %2) {
%4 = alloca float
%5 = alloca i32
%6 = alloca float*
%7 = alloca i32
%8 = alloca float
store float %0, float* %4
store i32 %1, i32* %5
store float* %2, float** %6
store float 0.000000e+00, float* %8
%9 = load i32, i32* %5
%10 = sub nsw i32 %9, 1
store i32 %10, i32* %7
br label %11
11: ; preds = %25, %3
%12 = load i32, i32* %7
%13 = icmp sgt i32 %12, 0
br i1 %13, label %14, label %28
14: ; preds = %11
%15 = load float*, float** %6
%16 = load i32, i32* %7
%17 = sub nsw i32 %16, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds float, float* %15, i64 %18
%20 = load float, float* %19
%21 = load float*, float** %6
%22 = load i32, i32* %7
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %21, i64 %23
store float %20, float* %24
br label %25
25: ; preds = %14
%26 = load i32, i32* %7
%27 = add nsw i32 %26, -1
store i32 %27, i32* %7
br label %11
28: ; preds = %11
%29 = load float, float* %4
%30 = load float*, float** %6
%31 = getelementptr inbounds float, float* %30, i64 0
store float %29, float* %31
store i32 0, i32* %7
br label %32
32: ; preds = %44, %28
%33 = load i32, i32* %7
%34 = load i32, i32* %5
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %47
36: ; preds = %32
%37 = load float*, float** %6
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %37, i64 %39
%41 = load float, float* %40
%42 = load float, float* %8
%43 = fadd float %42, %41
store float %43, float* %8
br label %44
44: ; preds = %36
%45 = load i32, i32* %7
%46 = add nsw i32 %45, 1
store i32 %46, i32* %7
br label %32
47: ; preds = %32
%48 = load float, float* %8
%49 = load i32, i32* %5
%50 = sitofp i32 %49 to float
%51 = fdiv float %48, %50
ret float %51
}

LLVM IR (-O2):
define float @filterApplyAveragef(float %0, i32 %1, float* nocapture %2) {
%4 = icmp sgt i32 %1, 1
br i1 %4, label %5, label %158
5: ; preds = %3
%6 = zext i32 %1 to i64
%7 = add nuw nsw i64 %6, 1
%8 = call i64 @llvm.umin.i64(i64 %6, i64 2)
%9 = sub nsw i64 %7, %8
%10 = icmp ult i64 %9, 8
br i1 %10, label %146, label %11
11: ; preds = %5
%12 = call i64 @llvm.umin.i64(i64 %6, i64 2)
%13 = sub nsw i64 %6, %12
%14 = add i32 %1, -1
%15 = trunc i64 %13 to i32
%16 = icmp ult i32 %14, %15
%17 = icmp ugt i64 %13, 4294967295
%18 = or i1 %16, %17
%19 = add i32 %1, -2
%20 = trunc i64 %13 to i32
%21 = icmp ult i32 %19, %20
%22 = icmp ugt i64 %13, 4294967295
%23 = or i1 %21, %22
%24 = zext i32 %14 to i64
%25 = getelementptr float, float* %2, i64 %24
%26 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %13, i64 4)
%27 = extractvalue { i64, i1 } %26, 0
%28 = extractvalue { i64, i1 } %26, 1
%29 = bitcast float* %25 to i8*
%30 = sub i64 0, %27
%31 = getelementptr i8, i8* %29, i64 %30
%32 = icmp ugt i8* %31, %29
%33 = or i1 %32, %28
%34 = zext i32 %19 to i64
%35 = getelementptr float, float* %2, i64 %34
%36 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %13, i64 4)
%37 = extractvalue { i64, i1 } %36, 0
%38 = extractvalue { i64, i1 } %36, 1
%39 = bitcast float* %35 to i8*
%40 = sub i64 0, %37
%41 = getelementptr i8, i8* %39, i64 %40
%42 = icmp ugt i8* %41, %39
%43 = or i1 %42, %38
%44 = or i1 %18, %23
%45 = or i1 %44, %33
%46 = or i1 %45, %43
br i1 %46, label %146, label %47
47: ; preds = %11
%48 = call i64 @llvm.umin.i64(i64 %6, i64 2)
%49 = add i32 %1, -1
%50 = zext i32 %49 to i64
%51 = add nuw nsw i64 %48, %50
%52 = sub nsw i64 %51, %6
%53 = getelementptr float, float* %2, i64 %52
%54 = add nuw nsw i64 %50, 1
%55 = getelementptr float, float* %2, i64 %54
%56 = add i32 %1, -2
%57 = zext i32 %56 to i64
%58 = add nuw nsw i64 %48, %57
%59 = sub nsw i64 %58, %6
%60 = getelementptr float, float* %2, i64 %59
%61 = add nuw nsw i64 %57, 1
%62 = getelementptr float, float* %2, i64 %61
%63 = icmp ult float* %53, %62
%64 = icmp ult float* %60, %55
%65 = and i1 %63, %64
br i1 %65, label %146, label %66
66: ; preds = %47
%67 = and i64 %9, -8
%68 = sub nsw i64 %6, %67
%69 = add nsw i64 %67, -8
%70 = lshr exact i64 %69, 3
%71 = add nuw nsw i64 %70, 1
%72 = and i64 %71, 1
%73 = icmp eq i64 %69, 0
br i1 %73, label %121, label %74
74: ; preds = %66
%75 = and i64 %71, 4611686018427387902
br label %76
76: ; preds = %76, %74
%77 = phi i64 [ 0, %74 ], [ %118, %76 ]
%78 = phi i64 [ 0, %74 ], [ %119, %76 ]
%79 = sub i64 %6, %77
%80 = add i64 %79, 4294967295
%81 = add nuw i64 %79, 4294967294
%82 = and i64 %81, 4294967295
%83 = getelementptr inbounds float, float* %2, i64 %82
%84 = getelementptr inbounds float, float* %83, i64 -3
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = getelementptr inbounds float, float* %83, i64 -4
%88 = getelementptr inbounds float, float* %87, i64 -3
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = and i64 %80, 4294967295
%92 = getelementptr inbounds float, float* %2, i64 %91
%93 = getelementptr inbounds float, float* %92, i64 -3
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> %86, <4 x float>* %94
%95 = getelementptr inbounds float, float* %92, i64 -4
%96 = getelementptr inbounds float, float* %95, i64 -3
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %90, <4 x float>* %97
%98 = or i64 %77, 8
%99 = sub i64 %6, %98
%100 = add i64 %99, 4294967295
%101 = add nuw i64 %99, 4294967294
%102 = and i64 %101, 4294967295
%103 = getelementptr inbounds float, float* %2, i64 %102
%104 = getelementptr inbounds float, float* %103, i64 -3
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = getelementptr inbounds float, float* %103, i64 -4
%108 = getelementptr inbounds float, float* %107, i64 -3
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = and i64 %100, 4294967295
%112 = getelementptr inbounds float, float* %2, i64 %111
%113 = getelementptr inbounds float, float* %112, i64 -3
%114 = bitcast float* %113 to <4 x float>*
store <4 x float> %106, <4 x float>* %114
%115 = getelementptr inbounds float, float* %112, i64 -4
%116 = getelementptr inbounds float, float* %115, i64 -3
%117 = bitcast float* %116 to <4 x float>*
store <4 x float> %110, <4 x float>* %117
%118 = add nuw i64 %77, 16
%119 = add i64 %78, 2
%120 = icmp eq i64 %119, %75
br i1 %120, label %121, label %76
121: ; preds = %76, %66
%122 = phi i64 [ 0, %66 ], [ %118, %76 ]
%123 = icmp eq i64 %72, 0
br i1 %123, label %144, label %124
124: ; preds = %121
%125 = sub i64 %6, %122
%126 = add i64 %125, 4294967295
%127 = add nuw i64 %125, 4294967294
%128 = and i64 %127, 4294967295
%129 = getelementptr inbounds float, float* %2, i64 %128
%130 = getelementptr inbounds float, float* %129, i64 -3
%131 = bitcast float* %130 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = getelementptr inbounds float, float* %129, i64 -4
%134 = getelementptr inbounds float, float* %133, i64 -3
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = and i64 %126, 4294967295
%138 = getelementptr inbounds float, float* %2, i64 %137
%139 = getelementptr inbounds float, float* %138, i64 -3
%140 = bitcast float* %139 to <4 x float>*
store <4 x float> %132, <4 x float>* %140
%141 = getelementptr inbounds float, float* %138, i64 -4
%142 = getelementptr inbounds float, float* %141, i64 -3
%143 = bitcast float* %142 to <4 x float>*
store <4 x float> %136, <4 x float>* %143
br label %144
144: ; preds = %121, %124
%145 = icmp eq i64 %9, %67
br i1 %145, label %158, label %146
146: ; preds = %47, %11, %5, %144
%147 = phi i64 [ %6, %47 ], [ %6, %11 ], [ %6, %5 ], [ %68, %144 ]
br label %148
148: ; preds = %146, %148
%149 = phi i64 [ %150, %148 ], [ %147, %146 ]
%150 = add nsw i64 %149, -1
%151 = add nuw i64 %149, 4294967294
%152 = and i64 %151, 4294967295
%153 = getelementptr inbounds float, float* %2, i64 %152
%154 = load float, float* %153
%155 = and i64 %150, 4294967295
%156 = getelementptr inbounds float, float* %2, i64 %155
store float %154, float* %156
%157 = icmp ugt i64 %149, 2
br i1 %157, label %148, label %158
158: ; preds = %148, %144, %3
store float %0, float* %2
%159 = icmp sgt i32 %1, 0
br i1 %159, label %160, label %224
160: ; preds = %158
%161 = zext i32 %1 to i64
%162 = fadd float %0, 0.000000e+00
%163 = icmp eq i32 %1, 1
br i1 %163, label %224, label %164
164: ; preds = %160
%165 = add nsw i64 %161, -1
%166 = add nsw i64 %161, -2
%167 = and i64 %165, 7
%168 = icmp ult i64 %166, 7
br i1 %168, label %209, label %169
169: ; preds = %164
%170 = and i64 %165, -8
br label %171
171: ; preds = %171, %169
%172 = phi i64 [ 1, %169 ], [ %206, %171 ]
%173 = phi float [ %162, %169 ], [ %205, %171 ]
%174 = phi i64 [ 0, %169 ], [ %207, %171 ]
%175 = getelementptr inbounds float, float* %2, i64 %172
%176 = load float, float* %175
%177 = fadd float %173, %176
%178 = add nuw nsw i64 %172, 1
%179 = getelementptr inbounds float, float* %2, i64 %178
%180 = load float, float* %179
%181 = fadd float %177, %180
%182 = add nuw nsw i64 %172, 2
%183 = getelementptr inbounds float, float* %2, i64 %182
%184 = load float, float* %183
%185 = fadd float %181, %184
%186 = add nuw nsw i64 %172, 3
%187 = getelementptr inbounds float, float* %2, i64 %186
%188 = load float, float* %187
%189 = fadd float %185, %188
%190 = add nuw nsw i64 %172, 4
%191 = getelementptr inbounds float, float* %2, i64 %190
%192 = load float, float* %191
%193 = fadd float %189, %192
%194 = add nuw nsw i64 %172, 5
%195 = getelementptr inbounds float, float* %2, i64 %194
%196 = load float, float* %195
%197 = fadd float %193, %196
%198 = add nuw nsw i64 %172, 6
%199 = getelementptr inbounds float, float* %2, i64 %198
%200 = load float, float* %199
%201 = fadd float %197, %200
%202 = add nuw nsw i64 %172, 7
%203 = getelementptr inbounds float, float* %2, i64 %202
%204 = load float, float* %203
%205 = fadd float %201, %204
%206 = add nuw nsw i64 %172, 8
%207 = add i64 %174, 8
%208 = icmp eq i64 %207, %170
br i1 %208, label %209, label %171
209: ; preds = %171, %164
%210 = phi float [ undef, %164 ], [ %205, %171 ]
%211 = phi i64 [ 1, %164 ], [ %206, %171 ]
%212 = phi float [ %162, %164 ], [ %205, %171 ]
%213 = icmp eq i64 %167, 0
br i1 %213, label %224, label %214
214: ; preds = %209, %214
%215 = phi i64 [ %221, %214 ], [ %211, %209 ]
%216 = phi float [ %220, %214 ], [ %212, %209 ]
%217 = phi i64 [ %222, %214 ], [ 0, %209 ]
%218 = getelementptr inbounds float, float* %2, i64 %215
%219 = load float, float* %218
%220 = fadd float %216, %219
%221 = add nuw nsw i64 %215, 1
%222 = add i64 %217, 1
%223 = icmp eq i64 %222, %167
br i1 %223, label %224, label %214
224: ; preds = %209, %214, %160, %158
%225 = phi float [ 0.000000e+00, %158 ], [ %162, %160 ], [ %210, %209 ], [ %220, %214 ]
%226 = sitofp i32 %1 to float
%227 = fdiv float %225, %226
ret float %227
}