#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;
typedef int int32_t;

/* Variables and functions */
int32_t filterApplyAverage(int32_t input, uint8_t averageCount,
                           int32_t averageState[12]) {
  int count;
  int32_t averageSum = 0;
  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):
<filterApplyAverage>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1151 <filterApplyAverage+0x51>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    111e <filterApplyAverage+0x1e>
mov    -0x4(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    118c <filterApplyAverage+0x8c>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1161 <filterApplyAverage+0x61>
mov    -0x18(%rbp),%eax
cltd
idivl  -0x8(%rbp)
pop    %rbp
ret

x86 assembly (clang, -O2):
<filterApplyAverage>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,%eax
mov    %esi,%r9d
cmp    $0x2,%esi
jl     1170 <filterApplyAverage+0x70>
mov    $0xfffffffe,%r13d
xor    %r15d,%r15d
mov    %r9,%rbx
sub    $0x2,%rbx
mov    $0x0,%r8d
cmovae %rbx,%r8
add    $0x1,%r8
cmp    $0x8,%r8
jae    11cf <filterApplyAverage+0xcf>
mov    %r9,%rcx
add    %rcx,%r13
add    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%ebx
mov    (%rdx,%rbx,4),%ebx
mov    %ecx,%edi
mov    %ebx,(%rdx,%rdi,4)
add    $0xffffffffffffffff,%r13
lea    -0x1(%rcx),%rdi
add    $0x1,%rcx
cmp    $0x2,%rcx
mov    %rdi,%rcx
ja     1150 <filterApplyAverage+0x50>
mov    %eax,(%rdx)
test   %esi,%esi
jle    11c8 <filterApplyAverage+0xc8>
cmp    $0x1,%esi
je     142c <filterApplyAverage+0x32c>
lea    -0x1(%r9),%r8
mov    $0x1,%edi
cmp    $0x8,%r8
jb     1420 <filterApplyAverage+0x320>
mov    %r8,%rdi
and    $0xfffffffffffffff8,%rdi
movd   %eax,%xmm0
lea    -0x8(%rdi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    135d <filterApplyAverage+0x25d>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
jmp    13ca <filterApplyAverage+0x2ca>
xor    %eax,%eax
jmp    142c <filterApplyAverage+0x32c>
mov    %r9d,%ebx
sub    $0x2,%ebx
cmovb  %r15d,%ebx
mov    %r9,%rcx
sub    $0x2,%rcx
cmovae %rcx,%r15
lea    -0x1(%rsi),%r10d
cmp    %ebx,%r10d
jb     113b <filterApplyAverage+0x3b>
mov    %r15,%r14
shr    $0x20,%r14
jne    113b <filterApplyAverage+0x3b>
lea    -0x2(%rsi),%r11d
cmp    %ebx,%r11d
jb     113b <filterApplyAverage+0x3b>
test   %r14,%r14
jne    113b <filterApplyAverage+0x3b>
lea    (%rdx,%r10,4),%rcx
shl    $0x2,%r15
mov    %rcx,%rbx
sub    %r15,%rbx
cmp    %rcx,%rbx
ja     113b <filterApplyAverage+0x3b>
xor    %ecx,%ecx
test   %cl,%cl
jne    113b <filterApplyAverage+0x3b>
lea    (%rdx,%r11,4),%rcx
mov    %rcx,%rbx
sub    %r15,%rbx
cmp    %rcx,%rbx
ja     113b <filterApplyAverage+0x3b>
xor    %ecx,%ecx
test   %cl,%cl
jne    113b <filterApplyAverage+0x3b>
cmp    $0x2,%r9
mov    $0x2,%ecx
cmovb  %r9,%rcx
lea    (%rcx,%r10,1),%rbx
sub    %r9,%rbx
lea    (%rdx,%rbx,4),%r14
lea    (%rdx,%r11,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%r14
jae    1292 <filterApplyAverage+0x192>
lea    (%rdx,%r10,4),%rbx
add    $0x4,%rbx
add    %r11,%rcx
sub    %r9,%rcx
lea    (%rdx,%rcx,4),%rcx
cmp    %rbx,%rcx
jb     113b <filterApplyAverage+0x3b>
mov    %r8,%r10
and    $0xfffffffffffffff8,%r10
lea    -0x8(%r10),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1439 <filterApplyAverage+0x339>
movabs $0x3ffffffffffffffc,%r15
ff ff 3f
or     $0x2,%r15
and    %r11,%r15
lea    (%r9,%r13,1),%rcx
add    $0xfffffffffffffff8,%rcx
xor    %r14d,%r14d
nopl   (%rax)
lea    0x9(%rcx),%r12d
lea    0x8(%rcx),%ebx
movups -0x1c(%rdx,%rbx,4),%xmm0
movups -0xc(%rdx,%rbx,4),%xmm1
movups %xmm1,-0xc(%rdx,%r12,4)
movups %xmm0,-0x1c(%rdx,%r12,4)
mov    %ecx,%ebx
lea    0x1(%rcx),%r12d
movdqu -0x1c(%rdx,%rbx,4),%xmm0
movdqu -0xc(%rdx,%rbx,4),%xmm1
movdqu %xmm1,-0xc(%rdx,%r12,4)
movdqu %xmm0,-0x1c(%rdx,%r12,4)
add    $0x10,%r14
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%r15
jne    12d0 <filterApplyAverage+0x1d0>
test   $0x1,%r11b
je     1349 <filterApplyAverage+0x249>
mov    %r9d,%ecx
sub    %r14d,%ecx
lea    (%rcx,%r13,1),%ebx
add    %r13d,%ecx
add    $0x1,%ecx
movdqu -0x1c(%rdx,%rbx,4),%xmm0
movdqu -0xc(%rdx,%rbx,4),%xmm1
movdqu %xmm1,-0xc(%rdx,%rcx,4)
movdqu %xmm0,-0x1c(%rdx,%rcx,4)
cmp    %r10,%r8
je     1170 <filterApplyAverage+0x70>
mov    %r9,%rcx
sub    %r10,%rcx
jmp    113e <filterApplyAverage+0x3e>
and    $0xfffffffffffffffc,%rax
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movdqu 0x4(%rdx,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x14(%rdx,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x24(%rdx,%rcx,4),%xmm1
movdqu 0x34(%rdx,%rcx,4),%xmm3
movdqu 0x44(%rdx,%rcx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x54(%rdx,%rcx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x64(%rdx,%rcx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x74(%rdx,%rcx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    1370 <filterApplyAverage+0x270>
test   %r10,%r10
je     13f9 <filterApplyAverage+0x2f9>
nop
lea    0x0(,%rcx,4),%rax
or     $0x4,%rax
movdqu (%rdx,%rax,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdx,%rax,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x8,%rcx
add    $0xffffffffffffffff,%r10
jne    13d0 <filterApplyAverage+0x2d0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rdi,%r8
je     142c <filterApplyAverage+0x32c>
or     $0x1,%rdi
nopl   0x0(%rax)
add    (%rdx,%rdi,4),%eax
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1420 <filterApplyAverage+0x320>
cltd
idiv   %esi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xor    %r14d,%r14d
test   $0x1,%r11b
jne    1321 <filterApplyAverage+0x221>
jmp    1349 <filterApplyAverage+0x249>

LLVM IR (-O0):
define i32 @filterApplyAverage(i32 %0, i32 %1, i32* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i32* %2, i32** %6
store i32 0, i32* %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 i32*, i32** %6
%16 = load i32, i32* %7
%17 = sub nsw i32 %16, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i32, i32* %15, i64 %18
%20 = load i32, i32* %19
%21 = load i32*, i32** %6
%22 = load i32, i32* %7
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
store i32 %20, i32* %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 i32, i32* %4
%30 = load i32*, i32** %6
%31 = getelementptr inbounds i32, i32* %30, i64 0
store i32 %29, i32* %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 i32*, i32** %6
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %37, i64 %39
%41 = load i32, i32* %40
%42 = load i32, i32* %8
%43 = add nsw i32 %42, %41
store i32 %43, i32* %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 i32, i32* %8
%49 = load i32, i32* %5
%50 = sdiv i32 %48, %49
ret i32 %50
}

LLVM IR (-O2):
define i32 @filterApplyAverage(i32 %0, i32 %1, i32* 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 i32, i32* %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 i32* %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 i32, i32* %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 i32* %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 i32, i32* %2, i64 %52
%54 = add nuw nsw i64 %50, 1
%55 = getelementptr i32, i32* %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 i32, i32* %2, i64 %59
%61 = add nuw nsw i64 %57, 1
%62 = getelementptr i32, i32* %2, i64 %61
%63 = icmp ult i32* %53, %62
%64 = icmp ult i32* %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 i32, i32* %2, i64 %82
%84 = getelementptr inbounds i32, i32* %83, i64 -3
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr inbounds i32, i32* %83, i64 -4
%88 = getelementptr inbounds i32, i32* %87, i64 -3
%89 = bitcast i32* %88 to <4 x i32>*
%90 = load <4 x i32>, <4 x i32>* %89
%91 = and i64 %80, 4294967295
%92 = getelementptr inbounds i32, i32* %2, i64 %91
%93 = getelementptr inbounds i32, i32* %92, i64 -3
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %86, <4 x i32>* %94
%95 = getelementptr inbounds i32, i32* %92, i64 -4
%96 = getelementptr inbounds i32, i32* %95, i64 -3
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> %90, <4 x i32>* %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 i32, i32* %2, i64 %102
%104 = getelementptr inbounds i32, i32* %103, i64 -3
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = getelementptr inbounds i32, i32* %103, i64 -4
%108 = getelementptr inbounds i32, i32* %107, i64 -3
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = and i64 %100, 4294967295
%112 = getelementptr inbounds i32, i32* %2, i64 %111
%113 = getelementptr inbounds i32, i32* %112, i64 -3
%114 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %106, <4 x i32>* %114
%115 = getelementptr inbounds i32, i32* %112, i64 -4
%116 = getelementptr inbounds i32, i32* %115, i64 -3
%117 = bitcast i32* %116 to <4 x i32>*
store <4 x i32> %110, <4 x i32>* %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 i32, i32* %2, i64 %128
%130 = getelementptr inbounds i32, i32* %129, i64 -3
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = getelementptr inbounds i32, i32* %129, i64 -4
%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 = and i64 %126, 4294967295
%138 = getelementptr inbounds i32, i32* %2, i64 %137
%139 = getelementptr inbounds i32, i32* %138, i64 -3
%140 = bitcast i32* %139 to <4 x i32>*
store <4 x i32> %132, <4 x i32>* %140
%141 = getelementptr inbounds i32, i32* %138, i64 -4
%142 = getelementptr inbounds i32, i32* %141, i64 -3
%143 = bitcast i32* %142 to <4 x i32>*
store <4 x i32> %136, <4 x i32>* %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 i32, i32* %2, i64 %152
%154 = load i32, i32* %153
%155 = and i64 %150, 4294967295
%156 = getelementptr inbounds i32, i32* %2, i64 %155
store i32 %154, i32* %156
%157 = icmp ugt i64 %149, 2
br i1 %157, label %148, label %158
158: ; preds = %148, %144, %3
store i32 %0, i32* %2
%159 = icmp sgt i32 %1, 0
br i1 %159, label %160, label %262
160: ; preds = %158
%161 = zext i32 %1 to i64
%162 = icmp eq i32 %1, 1
br i1 %162, label %262, label %163
163: ; preds = %160
%164 = add nsw i64 %161, -1
%165 = icmp ult i64 %164, 8
br i1 %165, label %251, label %166
166: ; preds = %163
%167 = and i64 %164, -8
%168 = or i64 %167, 1
%169 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %0, i64 0
%170 = add nsw i64 %167, -8
%171 = lshr exact i64 %170, 3
%172 = add nuw nsw i64 %171, 1
%173 = and i64 %172, 3
%174 = icmp ult i64 %170, 24
br i1 %174, label %221, label %175
175: ; preds = %166
%176 = and i64 %172, 4611686018427387900
br label %177
177: ; preds = %177, %175
%178 = phi i64 [ 0, %175 ], [ %218, %177 ]
%179 = phi <4 x i32> [ %169, %175 ], [ %216, %177 ]
%180 = phi <4 x i32> [ zeroinitializer, %175 ], [ %217, %177 ]
%181 = phi i64 [ 0, %175 ], [ %219, %177 ]
%182 = or i64 %178, 1
%183 = getelementptr inbounds i32, i32* %2, i64 %182
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = getelementptr inbounds i32, i32* %183, i64 4
%187 = bitcast i32* %186 to <4 x i32>*
%188 = load <4 x i32>, <4 x i32>* %187
%189 = add <4 x i32> %185, %179
%190 = add <4 x i32> %188, %180
%191 = or i64 %178, 9
%192 = getelementptr inbounds i32, i32* %2, i64 %191
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %192, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = add <4 x i32> %194, %189
%199 = add <4 x i32> %197, %190
%200 = or i64 %178, 17
%201 = getelementptr inbounds i32, i32* %2, i64 %200
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %201, i64 4
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = add <4 x i32> %203, %198
%208 = add <4 x i32> %206, %199
%209 = or i64 %178, 25
%210 = getelementptr inbounds i32, i32* %2, i64 %209
%211 = bitcast i32* %210 to <4 x i32>*
%212 = load <4 x i32>, <4 x i32>* %211
%213 = getelementptr inbounds i32, i32* %210, i64 4
%214 = bitcast i32* %213 to <4 x i32>*
%215 = load <4 x i32>, <4 x i32>* %214
%216 = add <4 x i32> %212, %207
%217 = add <4 x i32> %215, %208
%218 = add nuw i64 %178, 32
%219 = add i64 %181, 4
%220 = icmp eq i64 %219, %176
br i1 %220, label %221, label %177
221: ; preds = %177, %166
%222 = phi <4 x i32> [ undef, %166 ], [ %216, %177 ]
%223 = phi <4 x i32> [ undef, %166 ], [ %217, %177 ]
%224 = phi i64 [ 0, %166 ], [ %218, %177 ]
%225 = phi <4 x i32> [ %169, %166 ], [ %216, %177 ]
%226 = phi <4 x i32> [ zeroinitializer, %166 ], [ %217, %177 ]
%227 = icmp eq i64 %173, 0
br i1 %227, label %245, label %228
228: ; preds = %221, %228
%229 = phi i64 [ %242, %228 ], [ %224, %221 ]
%230 = phi <4 x i32> [ %240, %228 ], [ %225, %221 ]
%231 = phi <4 x i32> [ %241, %228 ], [ %226, %221 ]
%232 = phi i64 [ %243, %228 ], [ 0, %221 ]
%233 = or i64 %229, 1
%234 = getelementptr inbounds i32, i32* %2, i64 %233
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = getelementptr inbounds i32, i32* %234, i64 4
%238 = bitcast i32* %237 to <4 x i32>*
%239 = load <4 x i32>, <4 x i32>* %238
%240 = add <4 x i32> %236, %230
%241 = add <4 x i32> %239, %231
%242 = add nuw i64 %229, 8
%243 = add i64 %232, 1
%244 = icmp eq i64 %243, %173
br i1 %244, label %245, label %228
245: ; preds = %228, %221
%246 = phi <4 x i32> [ %222, %221 ], [ %240, %228 ]
%247 = phi <4 x i32> [ %223, %221 ], [ %241, %228 ]
%248 = add <4 x i32> %247, %246
%249 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %248)
%250 = icmp eq i64 %164, %167
br i1 %250, label %262, label %251
251: ; preds = %163, %245
%252 = phi i64 [ 1, %163 ], [ %168, %245 ]
%253 = phi i32 [ %0, %163 ], [ %249, %245 ]
br label %254
254: ; preds = %251, %254
%255 = phi i64 [ %260, %254 ], [ %252, %251 ]
%256 = phi i32 [ %259, %254 ], [ %253, %251 ]
%257 = getelementptr inbounds i32, i32* %2, i64 %255
%258 = load i32, i32* %257
%259 = add nsw i32 %258, %256
%260 = add nuw nsw i64 %255, 1
%261 = icmp eq i64 %260, %161
br i1 %261, label %262, label %254
262: ; preds = %254, %160, %245, %158
%263 = phi i32 [ 0, %158 ], [ %0, %160 ], [ %249, %245 ], [ %259, %254 ]
%264 = sdiv i32 %263, %1
ret i32 %264
}