#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*/ memset(int *, int /*<<< orphan*/, int);
void average_filter(int *data, int length, int buffersize) {
  int buffer[4][buffersize];
  int new_array[length];
  int i, j;
  int mean, whichch;
  if (buffersize == 0)
    return;
  for (i = 0; i < 4; i++)
    memset(buffer[i], 0, buffersize * sizeof(int));
  for (i = 0; i < length; i++) {
    whichch = i % 4;
    if (buffersize > 1) {
      for (j = (buffersize - 1); j > 0; j--)
        buffer[whichch][j] = buffer[whichch][j - 1];
    }
    buffer[whichch][0] = data[i];
    mean = 0;
    for (j = 0; j < buffersize; j++)
      mean += buffer[whichch][j];
    new_array[i] = mean / buffersize;
  }
  for (i = 0; i < length; i++)
    data[i] = new_array[i];
}


x86 assembly (clang, -O0):
<average_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %rax,-0x58(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x18(%rbp)
mov    %rax,%rdx
shl    $0x4,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
cmpl   $0x0,-0x10(%rbp)
jne    117e <average_filter+0x6e>
movl   $0x1,-0x3c(%rbp)
jmp    131c <average_filter+0x20c>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    11c5 <average_filter+0xb5>
mov    -0x50(%rbp),%rdi
mov    -0x58(%rbp),%rcx
movslq -0x2c(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1185 <average_filter+0x75>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12de <average_filter+0x1ce>
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x38(%rbp)
cmpl   $0x1,-0x10(%rbp)
jle    1252 <average_filter+0x142>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    124d <average_filter+0x13d>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rsi
movslq -0x38(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x38(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    11f9 <average_filter+0xe9>
jmp    1252 <average_filter+0x142>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rsi
mov    -0x8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x38(%rbp),%rcx
imul   %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12bc <average_filter+0x1ac>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rdx
movslq -0x38(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    127e <average_filter+0x16e>
mov    -0x34(%rbp),%eax
cltd
idivl  -0x10(%rbp)
mov    %eax,%edx
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cc <average_filter+0xbc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1315 <average_filter+0x205>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12e5 <average_filter+0x1d5>
movl   $0x0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<average_filter>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %edx,%r15d
mov    %edx,%r12d
mov    %rsp,%r13
mov    %r12,%rax
shl    $0x4,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %esi,%ecx
mov    %rsp,%rdx
lea    0xf(,%rcx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x70(%rbp)
mov    %rdx,%rsp
test   %r15d,%r15d
je     15ef <average_filter+0x4cf>
mov    %rdi,%r8
lea    0x0(,%r15,4),%ebx
xor    %r14d,%r14d
mov    %r13,%rdi
mov    %esi,-0x30(%rbp)
xor    %esi,%esi
mov    %ebx,%edx
mov    %r8,-0x40(%rbp)
mov    %rcx,-0x38(%rbp)
call   1030 <memset@plt>
lea    0x0(,%r12,4),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1030 <memset@plt>
lea    0x0(,%r12,8),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1030 <memset@plt>
lea    (%r12,%r12,2),%rax
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1030 <memset@plt>
mov    -0x38(%rbp),%r9
mov    -0x40(%rbp),%rdi
cmpl   $0x0,-0x30(%rbp)
jle    15ef <average_filter+0x4cf>
lea    -0x1(%r12),%r8
lea    -0x2(%r12),%rax
lea    -0x1(%r15),%ecx
lea    -0x2(%r15),%r10d
lea    0x0(,%rcx,4),%rsi
add    %r13,%rsi
mov    %rsi,-0x58(%rbp)
lea    0x0(%r13,%r10,4),%rsi
mov    %rsi,-0x60(%rbp)
lea    0x8(%r13,%rcx,4),%rsi
mov    %rsi,-0xb0(%rbp)
lea    0x8(%r13,%r10,4),%rsi
mov    %rsi,-0x98(%rbp)
lea    -0x9(%r12),%rsi
mov    %rsi,-0x50(%rbp)
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
cmp    %eax,%ecx
setb   %r11b
mov    %rax,%rsi
shr    $0x20,%rsi
setne  %dl
or     %dl,%r11b
cmp    %eax,%r10d
setb   %cl
or     %dl,%cl
mov    $0x4,%edx
mul    %rdx
mov    %rax,%r10
seto   -0x29(%rbp)
neg    %r10
or     %r11b,%cl
mov    %cl,-0x2a(%rbp)
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %r12,%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
and    %rbx,%rax
mov    %rax,-0x80(%rbp)
mov    %ebx,%eax
and    $0x3,%eax
mov    %rax,-0x68(%rbp)
mov    %rbx,%rax
mov    %rbx,-0x90(%rbp)
and    $0xfffffffffffffffc,%rbx
mov    %rbx,-0xa8(%rbp)
mov    $0xfffffffe,%eax
mov    %rcx,-0x48(%rbp)
add    $0x1,%rcx
mov    %rcx,-0xb8(%rbp)
lea    -0x8(%r12,%rax,1),%rax
mov    %rax,-0x78(%rbp)
lea    0x74(%r13),%rax
mov    %rax,-0xa0(%rbp)
jmp    12f9 <average_filter+0x1d9>
nop
cltd
idiv   %r15d
mov    -0x70(%rbp),%rcx
mov    %eax,(%rcx,%r14,4)
add    $0x1,%r14
cmp    %r9,%r14
je     15d9 <average_filter+0x4b9>
mov    %r14d,%ecx
and    $0x3,%ecx
mov    %r12,%r11
imul   %rcx,%r11
lea    0x0(,%r11,4),%rdx
add    %r13,%rdx
cmp    $0x2,%r15d
jl     134f <average_filter+0x22f>
mov    %r12,%rax
cmp    $0x8,%r8
jae    13a0 <average_filter+0x280>
mov    $0xfffffffe,%ecx
add    %rax,%rcx
add    $0xffffffffffffffff,%rax
mov    %ecx,%esi
mov    (%rdx,%rsi,4),%esi
mov    %eax,%ebx
mov    %esi,(%rdx,%rbx,4)
add    $0xffffffffffffffff,%rcx
lea    -0x1(%rax),%rsi
add    $0x1,%rax
cmp    $0x2,%rax
mov    %rsi,%rax
jg     1330 <average_filter+0x210>
mov    (%rdi,%r14,4),%ecx
mov    %ecx,0x0(%r13,%r11,4)
mov    $0x0,%eax
test   %r15d,%r15d
cmovg  %ecx,%eax
jle    12e0 <average_filter+0x1c0>
cmp    $0x1,%r15d
je     12e0 <average_filter+0x1c0>
mov    $0x1,%esi
cmp    $0x8,%r8
jb     1516 <average_filter+0x3f6>
movd   %ecx,%xmm0
cmpq   $0x18,-0x50(%rbp)
jae    1437 <average_filter+0x317>
pxor   %xmm1,%xmm1
xor    %eax,%eax
jmp    14a9 <average_filter+0x389>
nopl   0x0(%rax)
mov    -0x58(%rbp),%rax
lea    (%rax,%r11,4),%rax
mov    -0x60(%rbp),%rsi
lea    (%rsi,%r11,4),%rsi
lea    (%rax,%r10,1),%rbx
cmp    %rax,%rbx
seta   %al
or     -0x29(%rbp),%al
lea    (%rsi,%r10,1),%rbx
cmp    %rsi,%rbx
seta   %bl
or     -0x2a(%rbp),%al
mov    %r12,%rax
jne    1324 <average_filter+0x204>
or     -0x29(%rbp),%bl
mov    %r12,%rax
jne    1324 <average_filter+0x204>
lea    -0x4(,%rcx,4),%rcx
ff
imul   %r12,%rcx
mov    -0xb0(%rbp),%rax
add    %rcx,%rax
mov    -0x60(%rbp),%rsi
lea    (%rsi,%r11,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rax
jae    1425 <average_filter+0x305>
add    -0x98(%rbp),%rcx
mov    -0x58(%rbp),%rax
lea    (%rax,%r11,4),%rsi
add    $0x4,%rsi
mov    %r12,%rax
cmp    %rsi,%rcx
jb     1324 <average_filter+0x204>
cmpq   $0x8,-0x50(%rbp)
jae    1531 <average_filter+0x411>
xor    %eax,%eax
jmp    1588 <average_filter+0x468>
mov    -0xa0(%rbp),%rax
lea    (%rax,%r11,4),%rsi
pxor   %xmm1,%xmm1
mov    -0xa8(%rbp),%rcx
xor    %eax,%eax
nop
movdqu -0x70(%rsi,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rsi,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rsi,%rax,4),%xmm1
movdqu -0x40(%rsi,%rax,4),%xmm3
movdqu -0x30(%rsi,%rax,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rsi,%rax,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rsi,%rax,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rsi,%rax,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1450 <average_filter+0x330>
cmpq   $0x0,-0x68(%rbp)
je     14e9 <average_filter+0x3c9>
mov    -0x68(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x0(,%rax,4),%rsi
or     $0x4,%rsi
movdqu (%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
jne    14c0 <average_filter+0x3a0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    -0xb8(%rbp),%rsi
mov    %ecx,%eax
cmp    -0x48(%rbp),%r8
je     12e0 <average_filter+0x1c0>
mov    %ecx,%eax
nopl   0x0(%rax,%rax,1)
add    (%rdx,%rsi,4),%eax
add    $0x1,%rsi
cmp    %rsi,%r12
jne    1520 <average_filter+0x400>
jmp    12e0 <average_filter+0x1c0>
mov    -0x80(%rbp),%rcx
mov    -0x78(%rbp),%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    0x9(%rdi),%ebx
lea    0x8(%rdi),%r9d
movups -0x1c(%rdx,%r9,4),%xmm0
movups -0xc(%rdx,%r9,4),%xmm1
movups %xmm1,-0xc(%rdx,%rbx,4)
movups %xmm0,-0x1c(%rdx,%rbx,4)
mov    %edi,%ebx
lea    0x1(%rdi),%esi
movdqu -0x1c(%rdx,%rbx,4),%xmm0
movdqu -0xc(%rdx,%rbx,4),%xmm1
movdqu %xmm1,-0xc(%rdx,%rsi,4)
movdqu %xmm0,-0x1c(%rdx,%rsi,4)
add    $0x10,%rax
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1540 <average_filter+0x420>
testb  $0x1,-0x90(%rbp)
je     15bb <average_filter+0x49b>
mov    %r12d,%ecx
sub    %eax,%ecx
mov    $0xfffffffe,%esi
lea    (%rsi,%rcx,1),%eax
add    %esi,%ecx
add    $0x1,%ecx
movdqu -0x1c(%rdx,%rax,4),%xmm0
movdqu -0xc(%rdx,%rax,4),%xmm1
movdqu %xmm1,-0xc(%rdx,%rcx,4)
movdqu %xmm0,-0x1c(%rdx,%rcx,4)
mov    -0x88(%rbp),%rax
cmp    -0x48(%rbp),%r8
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%r9
jne    1324 <average_filter+0x204>
jmp    134f <average_filter+0x22f>
cmpl   $0x0,-0x30(%rbp)
jle    15ef <average_filter+0x4cf>
shl    $0x2,%r9
mov    -0x70(%rbp),%rsi
mov    %r9,%rdx
call   1040 <memcpy@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @average_filter(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%15 = load i32, i32* %6
%16 = zext i32 %15 to i64
%17 = call i8* @llvm.stacksave()
store i8* %17, i8** %7
%18 = mul nuw i64 4, %16
%19 = alloca i32, i64 %18
store i64 %16, i64* %8
%20 = load i32, i32* %5
%21 = zext i32 %20 to i64
%22 = alloca i32, i64 %21
store i64 %21, i64* %9
%23 = load i32, i32* %6
%24 = icmp eq i32 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %3
store i32 1, i32* %14
br label %137
26: ; preds = %3
store i32 0, i32* %10
br label %27
27: ; preds = %40, %26
%28 = load i32, i32* %10
%29 = icmp slt i32 %28, 4
br i1 %29, label %30, label %43
30: ; preds = %27
%31 = load i32, i32* %10
%32 = sext i32 %31 to i64
%33 = mul nsw i64 %32, %16
%34 = getelementptr inbounds i32, i32* %19, i64 %33
%35 = load i32, i32* %6
%36 = sext i32 %35 to i64
%37 = mul i64 %36, 4
%38 = trunc i64 %37 to i32
%39 = call i32 @memset(i32* %34, i32 0, i32 %38)
br label %40
40: ; preds = %30
%41 = load i32, i32* %10
%42 = add nsw i32 %41, 1
store i32 %42, i32* %10
br label %27
43: ; preds = %27
store i32 0, i32* %10
br label %44
44: ; preds = %116, %43
%45 = load i32, i32* %10
%46 = load i32, i32* %5
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %119
48: ; preds = %44
%49 = load i32, i32* %10
%50 = srem i32 %49, 4
store i32 %50, i32* %13
%51 = load i32, i32* %6
%52 = icmp sgt i32 %51, 1
br i1 %52, label %53, label %80
53: ; preds = %48
%54 = load i32, i32* %6
%55 = sub nsw i32 %54, 1
store i32 %55, i32* %11
br label %56
56: ; preds = %76, %53
%57 = load i32, i32* %11
%58 = icmp sgt i32 %57, 0
br i1 %58, label %59, label %79
59: ; preds = %56
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = mul nsw i64 %61, %16
%63 = getelementptr inbounds i32, i32* %19, i64 %62
%64 = load i32, i32* %11
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %63, i64 %66
%68 = load i32, i32* %67
%69 = load i32, i32* %13
%70 = sext i32 %69 to i64
%71 = mul nsw i64 %70, %16
%72 = getelementptr inbounds i32, i32* %19, i64 %71
%73 = load i32, i32* %11
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %72, i64 %74
store i32 %68, i32* %75
br label %76
76: ; preds = %59
%77 = load i32, i32* %11
%78 = add nsw i32 %77, -1
store i32 %78, i32* %11
br label %56
79: ; preds = %56
br label %80
80: ; preds = %79, %48
%81 = load i32*, i32** %4
%82 = load i32, i32* %10
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %81, i64 %83
%85 = load i32, i32* %84
%86 = load i32, i32* %13
%87 = sext i32 %86 to i64
%88 = mul nsw i64 %87, %16
%89 = getelementptr inbounds i32, i32* %19, i64 %88
%90 = getelementptr inbounds i32, i32* %89, i64 0
store i32 %85, i32* %90
store i32 0, i32* %12
store i32 0, i32* %11
br label %91
91: ; preds = %106, %80
%92 = load i32, i32* %11
%93 = load i32, i32* %6
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %109
95: ; preds = %91
%96 = load i32, i32* %13
%97 = sext i32 %96 to i64
%98 = mul nsw i64 %97, %16
%99 = getelementptr inbounds i32, i32* %19, i64 %98
%100 = load i32, i32* %11
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
%103 = load i32, i32* %102
%104 = load i32, i32* %12
%105 = add nsw i32 %104, %103
store i32 %105, i32* %12
br label %106
106: ; preds = %95
%107 = load i32, i32* %11
%108 = add nsw i32 %107, 1
store i32 %108, i32* %11
br label %91
109: ; preds = %91
%110 = load i32, i32* %12
%111 = load i32, i32* %6
%112 = sdiv i32 %110, %111
%113 = load i32, i32* %10
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i32, i32* %22, i64 %114
store i32 %112, i32* %115
br label %116
116: ; preds = %109
%117 = load i32, i32* %10
%118 = add nsw i32 %117, 1
store i32 %118, i32* %10
br label %44
119: ; preds = %44
store i32 0, i32* %10
br label %120
120: ; preds = %133, %119
%121 = load i32, i32* %10
%122 = load i32, i32* %5
%123 = icmp slt i32 %121, %122
br i1 %123, label %124, label %136
124: ; preds = %120
%125 = load i32, i32* %10
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %22, i64 %126
%128 = load i32, i32* %127
%129 = load i32*, i32** %4
%130 = load i32, i32* %10
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %129, i64 %131
store i32 %128, i32* %132
br label %133
133: ; preds = %124
%134 = load i32, i32* %10
%135 = add nsw i32 %134, 1
store i32 %135, i32* %10
br label %120
136: ; preds = %120
store i32 0, i32* %14
br label %137
137: ; preds = %136, %25
%138 = load i8*, i8** %7
%139 = load i32, i32* %14
switch i32 %139, label %141 [
i32 0, label %140
i32 1, label %140
]
140: ; preds = %137, %137
ret void
141: ; preds = %137
unreachable
}

LLVM IR (-O2):
define void @average_filter(i32* nocapture %0, i32 %1, i32 %2) {
%4 = bitcast i32* %0 to i8*
%5 = zext i32 %2 to i64
%6 = shl nuw nsw i64 %5, 2
%7 = alloca i32, i64 %6
%8 = zext i32 %1 to i64
%9 = alloca i32, i64 %8
%10 = bitcast i32* %9 to i8*
%11 = icmp eq i32 %2, 0
br i1 %11, label %305, label %12
12: ; preds = %3
%13 = shl i32 %2, 2
%14 = call i32 @memset(i32* %7, i32 0, i32 %13)
%15 = getelementptr inbounds i32, i32* %7, i64 %5
%16 = call i32 @memset(i32* %15, i32 0, i32 %13)
%17 = shl nuw nsw i64 %5, 1
%18 = getelementptr inbounds i32, i32* %7, i64 %17
%19 = call i32 @memset(i32* %18, i32 0, i32 %13)
%20 = mul nuw nsw i64 %5, 3
%21 = getelementptr inbounds i32, i32* %7, i64 %20
%22 = call i32 @memset(i32* %21, i32 0, i32 %13)
%23 = icmp sgt i32 %1, 0
br i1 %23, label %24, label %305
24: ; preds = %12
%25 = icmp sgt i32 %2, 1
%26 = icmp sgt i32 %2, 0
%27 = add nsw i64 %5, -1
%28 = add nsw i64 %5, -2
%29 = add i32 %2, -1
%30 = add i32 %2, -2
%31 = zext i32 %29 to i64
%32 = getelementptr i32, i32* %7, i64 %31
%33 = zext i32 %30 to i64
%34 = getelementptr i32, i32* %7, i64 %33
%35 = zext i32 %29 to i64
%36 = add nuw nsw i64 %35, 2
%37 = getelementptr i32, i32* %7, i64 %36
%38 = bitcast i32* %37 to i8*
%39 = add nuw nsw i64 %35, 1
%40 = getelementptr i32, i32* %7, i64 %39
%41 = add i32 %2, -2
%42 = zext i32 %41 to i64
%43 = add nuw nsw i64 %42, 2
%44 = getelementptr i32, i32* %7, i64 %43
%45 = bitcast i32* %44 to i8*
%46 = add nuw nsw i64 %42, 1
%47 = getelementptr i32, i32* %7, i64 %46
%48 = add nsw i64 %5, -1
%49 = add nsw i64 %5, -9
%50 = lshr i64 %49, 3
%51 = add nuw nsw i64 %50, 1
%52 = icmp ult i64 %48, 8
%53 = trunc i64 %28 to i32
%54 = icmp ult i32 %29, %53
%55 = icmp ugt i64 %28, 4294967295
%56 = or i1 %54, %55
%57 = trunc i64 %28 to i32
%58 = icmp ult i32 %30, %57
%59 = icmp ugt i64 %28, 4294967295
%60 = or i1 %58, %59
%61 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %28, i64 4)
%62 = extractvalue { i64, i1 } %61, 0
%63 = extractvalue { i64, i1 } %61, 1
%64 = sub i64 0, %62
%65 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %28, i64 4)
%66 = extractvalue { i64, i1 } %65, 0
%67 = extractvalue { i64, i1 } %65, 1
%68 = sub i64 0, %66
%69 = or i1 %56, %60
%70 = and i64 %48, -8
%71 = sub nsw i64 %5, %70
%72 = and i64 %51, 1
%73 = icmp ult i64 %49, 8
%74 = and i64 %51, 4611686018427387902
%75 = icmp eq i64 %72, 0
%76 = icmp eq i64 %48, %70
%77 = icmp eq i32 %2, 1
%78 = icmp ult i64 %27, 8
%79 = and i64 %27, -8
%80 = or i64 %79, 1
%81 = and i64 %51, 3
%82 = icmp ult i64 %49, 24
%83 = and i64 %51, 4611686018427387900
%84 = icmp eq i64 %81, 0
%85 = icmp eq i64 %27, %79
br label %89
86: ; preds = %299
br i1 %23, label %87, label %305
87: ; preds = %86
%88 = shl nuw nsw i64 %8, 2
br label %305
89: ; preds = %24, %299
%90 = phi i64 [ 0, %24 ], [ %303, %299 ]
%91 = and i64 %90, 3
%92 = shl nuw nsw i64 %91, 2
%93 = add nsw i64 %92, -4
%94 = mul nsw i64 %93, %5
%95 = getelementptr i8, i8* %38, i64 %94
%96 = mul nuw nsw i64 %91, %5
%97 = getelementptr i32, i32* %40, i64 %96
%98 = bitcast i32* %97 to i8*
%99 = getelementptr i8, i8* %45, i64 %94
%100 = getelementptr i32, i32* %47, i64 %96
%101 = bitcast i32* %100 to i8*
%102 = and i64 %90, 3
%103 = mul nuw nsw i64 %102, %5
%104 = getelementptr i32, i32* %32, i64 %103
%105 = bitcast i32* %104 to i8*
%106 = getelementptr i32, i32* %34, i64 %103
%107 = bitcast i32* %106 to i8*
%108 = and i64 %90, 3
%109 = mul nuw nsw i64 %108, %5
br i1 %25, label %110, label %206
110: ; preds = %89
%111 = getelementptr inbounds i32, i32* %7, i64 %109
br i1 %52, label %194, label %112
112: ; preds = %110
%113 = getelementptr i8, i8* %105, i64 %64
%114 = icmp ugt i8* %113, %105
%115 = or i1 %114, %63
%116 = getelementptr i8, i8* %107, i64 %68
%117 = icmp ugt i8* %116, %107
%118 = or i1 %117, %67
%119 = or i1 %69, %115
%120 = or i1 %119, %118
br i1 %120, label %194, label %121
121: ; preds = %112
%122 = icmp ult i8* %95, %101
%123 = icmp ult i8* %99, %98
%124 = and i1 %122, %123
br i1 %124, label %194, label %125
125: ; preds = %121
br i1 %73, label %171, label %126
126: ; preds = %125, %126
%127 = phi i64 [ %168, %126 ], [ 0, %125 ]
%128 = phi i64 [ %169, %126 ], [ 0, %125 ]
%129 = sub i64 %5, %127
%130 = add i64 %129, 4294967295
%131 = add i64 %129, 4294967294
%132 = and i64 %131, 4294967295
%133 = getelementptr inbounds i32, i32* %111, i64 %132
%134 = getelementptr inbounds i32, i32* %133, i64 -3
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = getelementptr inbounds i32, i32* %133, i64 -4
%138 = getelementptr inbounds i32, i32* %137, i64 -3
%139 = bitcast i32* %138 to <4 x i32>*
%140 = load <4 x i32>, <4 x i32>* %139
%141 = and i64 %130, 4294967295
%142 = getelementptr inbounds i32, i32* %111, i64 %141
%143 = getelementptr inbounds i32, i32* %142, i64 -3
%144 = bitcast i32* %143 to <4 x i32>*
store <4 x i32> %136, <4 x i32>* %144
%145 = getelementptr inbounds i32, i32* %142, i64 -4
%146 = getelementptr inbounds i32, i32* %145, i64 -3
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> %140, <4 x i32>* %147
%148 = or i64 %127, 8
%149 = sub i64 %5, %148
%150 = add i64 %149, 4294967295
%151 = add i64 %149, 4294967294
%152 = and i64 %151, 4294967295
%153 = getelementptr inbounds i32, i32* %111, i64 %152
%154 = getelementptr inbounds i32, i32* %153, i64 -3
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds i32, i32* %153, i64 -4
%158 = getelementptr inbounds i32, i32* %157, i64 -3
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = and i64 %150, 4294967295
%162 = getelementptr inbounds i32, i32* %111, i64 %161
%163 = getelementptr inbounds i32, i32* %162, i64 -3
%164 = bitcast i32* %163 to <4 x i32>*
store <4 x i32> %156, <4 x i32>* %164
%165 = getelementptr inbounds i32, i32* %162, i64 -4
%166 = getelementptr inbounds i32, i32* %165, i64 -3
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %160, <4 x i32>* %167
%168 = add nuw i64 %127, 16
%169 = add i64 %128, 2
%170 = icmp eq i64 %169, %74
br i1 %170, label %171, label %126
171: ; preds = %126, %125
%172 = phi i64 [ 0, %125 ], [ %168, %126 ]
br i1 %75, label %193, label %173
173: ; preds = %171
%174 = sub i64 %5, %172
%175 = add i64 %174, 4294967295
%176 = add i64 %174, 4294967294
%177 = and i64 %176, 4294967295
%178 = getelementptr inbounds i32, i32* %111, i64 %177
%179 = getelementptr inbounds i32, i32* %178, i64 -3
%180 = bitcast i32* %179 to <4 x i32>*
%181 = load <4 x i32>, <4 x i32>* %180
%182 = getelementptr inbounds i32, i32* %178, i64 -4
%183 = getelementptr inbounds i32, i32* %182, i64 -3
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = and i64 %175, 4294967295
%187 = getelementptr inbounds i32, i32* %111, i64 %186
%188 = getelementptr inbounds i32, i32* %187, i64 -3
%189 = bitcast i32* %188 to <4 x i32>*
store <4 x i32> %181, <4 x i32>* %189
%190 = getelementptr inbounds i32, i32* %187, i64 -4
%191 = getelementptr inbounds i32, i32* %190, i64 -3
%192 = bitcast i32* %191 to <4 x i32>*
store <4 x i32> %185, <4 x i32>* %192
br label %193
193: ; preds = %171, %173
br i1 %76, label %206, label %194
194: ; preds = %121, %112, %110, %193
%195 = phi i64 [ %5, %121 ], [ %5, %112 ], [ %5, %110 ], [ %71, %193 ]
br label %196
196: ; preds = %194, %196
%197 = phi i64 [ %198, %196 ], [ %195, %194 ]
%198 = add nsw i64 %197, -1
%199 = add i64 %197, 4294967294
%200 = and i64 %199, 4294967295
%201 = getelementptr inbounds i32, i32* %111, i64 %200
%202 = load i32, i32* %201
%203 = and i64 %198, 4294967295
%204 = getelementptr inbounds i32, i32* %111, i64 %203
store i32 %202, i32* %204
%205 = icmp sgt i64 %197, 2
br i1 %205, label %196, label %206
206: ; preds = %196, %193, %89
%207 = getelementptr inbounds i32, i32* %0, i64 %90
%208 = load i32, i32* %207
%209 = getelementptr inbounds i32, i32* %7, i64 %109
store i32 %208, i32* %209
%210 = xor i1 %26, true
%211 = or i1 %210, %77
%212 = select i1 %210, i32 0, i32 %208
br i1 %211, label %299, label %213
213: ; preds = %206
br i1 %78, label %288, label %214
214: ; preds = %213
%215 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %208, i64 0
br i1 %82, label %260, label %216
216: ; preds = %214, %216
%217 = phi i64 [ %257, %216 ], [ 0, %214 ]
%218 = phi <4 x i32> [ %255, %216 ], [ %215, %214 ]
%219 = phi <4 x i32> [ %256, %216 ], [ zeroinitializer, %214 ]
%220 = phi i64 [ %258, %216 ], [ 0, %214 ]
%221 = or i64 %217, 1
%222 = getelementptr inbounds i32, i32* %209, i64 %221
%223 = bitcast i32* %222 to <4 x i32>*
%224 = load <4 x i32>, <4 x i32>* %223
%225 = getelementptr inbounds i32, i32* %222, i64 4
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = add <4 x i32> %224, %218
%229 = add <4 x i32> %227, %219
%230 = or i64 %217, 9
%231 = getelementptr inbounds i32, i32* %209, i64 %230
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = getelementptr inbounds i32, i32* %231, i64 4
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = add <4 x i32> %233, %228
%238 = add <4 x i32> %236, %229
%239 = or i64 %217, 17
%240 = getelementptr inbounds i32, i32* %209, i64 %239
%241 = bitcast i32* %240 to <4 x i32>*
%242 = load <4 x i32>, <4 x i32>* %241
%243 = getelementptr inbounds i32, i32* %240, i64 4
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = add <4 x i32> %242, %237
%247 = add <4 x i32> %245, %238
%248 = or i64 %217, 25
%249 = getelementptr inbounds i32, i32* %209, i64 %248
%250 = bitcast i32* %249 to <4 x i32>*
%251 = load <4 x i32>, <4 x i32>* %250
%252 = getelementptr inbounds i32, i32* %249, i64 4
%253 = bitcast i32* %252 to <4 x i32>*
%254 = load <4 x i32>, <4 x i32>* %253
%255 = add <4 x i32> %251, %246
%256 = add <4 x i32> %254, %247
%257 = add nuw i64 %217, 32
%258 = add i64 %220, 4
%259 = icmp eq i64 %258, %83
br i1 %259, label %260, label %216
260: ; preds = %216, %214
%261 = phi <4 x i32> [ undef, %214 ], [ %255, %216 ]
%262 = phi <4 x i32> [ undef, %214 ], [ %256, %216 ]
%263 = phi i64 [ 0, %214 ], [ %257, %216 ]
%264 = phi <4 x i32> [ %215, %214 ], [ %255, %216 ]
%265 = phi <4 x i32> [ zeroinitializer, %214 ], [ %256, %216 ]
br i1 %84, label %283, label %266
266: ; preds = %260, %266
%267 = phi i64 [ %280, %266 ], [ %263, %260 ]
%268 = phi <4 x i32> [ %278, %266 ], [ %264, %260 ]
%269 = phi <4 x i32> [ %279, %266 ], [ %265, %260 ]
%270 = phi i64 [ %281, %266 ], [ 0, %260 ]
%271 = or i64 %267, 1
%272 = getelementptr inbounds i32, i32* %209, i64 %271
%273 = bitcast i32* %272 to <4 x i32>*
%274 = load <4 x i32>, <4 x i32>* %273
%275 = getelementptr inbounds i32, i32* %272, i64 4
%276 = bitcast i32* %275 to <4 x i32>*
%277 = load <4 x i32>, <4 x i32>* %276
%278 = add <4 x i32> %274, %268
%279 = add <4 x i32> %277, %269
%280 = add nuw i64 %267, 8
%281 = add i64 %270, 1
%282 = icmp eq i64 %281, %81
br i1 %282, label %283, label %266
283: ; preds = %266, %260
%284 = phi <4 x i32> [ %261, %260 ], [ %278, %266 ]
%285 = phi <4 x i32> [ %262, %260 ], [ %279, %266 ]
%286 = add <4 x i32> %285, %284
%287 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %286)
br i1 %85, label %299, label %288
288: ; preds = %213, %283
%289 = phi i64 [ 1, %213 ], [ %80, %283 ]
%290 = phi i32 [ %208, %213 ], [ %287, %283 ]
br label %291
291: ; preds = %288, %291
%292 = phi i64 [ %297, %291 ], [ %289, %288 ]
%293 = phi i32 [ %296, %291 ], [ %290, %288 ]
%294 = getelementptr inbounds i32, i32* %209, i64 %292
%295 = load i32, i32* %294
%296 = add nsw i32 %295, %293
%297 = add nuw nsw i64 %292, 1
%298 = icmp eq i64 %297, %5
br i1 %298, label %299, label %291
299: ; preds = %291, %206, %283
%300 = phi i32 [ %212, %206 ], [ %287, %283 ], [ %296, %291 ]
%301 = sdiv i32 %300, %2
%302 = getelementptr inbounds i32, i32* %9, i64 %90
store i32 %301, i32* %302
%303 = add nuw nsw i64 %90, 1
%304 = icmp eq i64 %303, %8
br i1 %304, label %86, label %89
305: ; preds = %12, %87, %86, %3
ret void
}