#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 uint32_t;
typedef int uint16_t;
typedef int /*<<< orphan*/ pseudo_hdr;

/* Variables and functions */
int htonl(int);
int /*<<< orphan*/ memcpy(int **, int *, int);
int /*<<< orphan*/ memset(int **, int /*<<< orphan*/, int);
uint16_t rfc1071_ckecksum(uint8_t *src, uint8_t *dst, uint16_t nxt_hdr,
                          uint16_t *payload, int count) {
  struct __attribute__((packed)) {
    uint8_t src[16];
    uint8_t dst[16];
    uint32_t length;
    uint8_t zeros[3];
    uint8_t next_header;
  } pseudo_hdr;
  uint16_t *php = (uint16_t *)&pseudo_hdr;
  uint32_t sum = 0;
  int c = sizeof(pseudo_hdr);
  memcpy(&pseudo_hdr.src, src, 16);
  memcpy(&pseudo_hdr.dst, dst, 16);
  pseudo_hdr.length = htonl(count);
  memset(&pseudo_hdr.zeros, 0, 3);
  pseudo_hdr.next_header = nxt_hdr;
  while (c > 1) {
    sum += *(uint16_t *)php++;
    c -= 2;
  }
  while (count > 1) {
    sum += *(uint16_t *)payload++;
    count -= 2;
  }
  if (count > 0)
    sum += *(uint8_t *)payload;
  while (sum >> 16)
    sum = (sum & 0xffff) + (sum >> 16);
  return ~sum;
}


x86 assembly (clang, -O0):
<rfc1071_ckecksum>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
lea    -0xb8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0xc4(%rbp)
movl   $0x94,-0xc8(%rbp)
lea    -0xb8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
lea    -0xb8(%rbp),%rdi
add    $0x40,%rdi
mov    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x24(%rbp),%edi
call   1030 <htonl@plt>
mov    %eax,-0x38(%rbp)
lea    -0xb8(%rbp),%rdi
add    $0x84,%rdi
xor    %esi,%esi
mov    $0x3,%edx
call   1040 <memset@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0xc8(%rbp)
jle    120d <rfc1071_ckecksum+0xdd>
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xc0(%rbp)
mov    (%rax),%eax
add    -0xc4(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xc8(%rbp)
jmp    11c9 <rfc1071_ckecksum+0x99>
jmp    1212 <rfc1071_ckecksum+0xe2>
cmpl   $0x1,-0x24(%rbp)
jle    1247 <rfc1071_ckecksum+0x117>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%eax
add    -0xc4(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1212 <rfc1071_ckecksum+0xe2>
cmpl   $0x0,-0x24(%rbp)
jle    1263 <rfc1071_ckecksum+0x133>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
add    -0xc4(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    1268 <rfc1071_ckecksum+0x138>
mov    -0xc4(%rbp),%eax
sar    $0x10,%eax
cmp    $0x0,%eax
je     129b <rfc1071_ckecksum+0x16b>
mov    -0xc4(%rbp),%eax
and    $0xffff,%eax
mov    -0xc4(%rbp),%ecx
sar    $0x10,%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
jmp    1268 <rfc1071_ckecksum+0x138>
mov    -0xc4(%rbp),%eax
xor    $0xffffffff,%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rfc1071_ckecksum>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x98,%rsp
mov    %r8d,%ebp
mov    %rcx,%rbx
mov    %edx,%r14d
mov    %rsi,%r15
mov    %rdi,%rsi
mov    %rsp,%rdi
mov    $0x10,%edx
call   1050 <memcpy@plt>
lea    0x40(%rsp),%rdi
mov    %r15,%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    %ebp,%edi
call   1030 <htonl@plt>
mov    %eax,0x80(%rsp)
lea    0x84(%rsp),%rdi
xor    %r15d,%r15d
xor    %esi,%esi
mov    $0x3,%edx
call   1040 <memset@plt>
mov    %r14d,0x90(%rsp)
movdqa 0x10(%rsp),%xmm0
paddd  (%rsp),%xmm0
paddd  0x20(%rsp),%xmm0
paddd  0x30(%rsp),%xmm0
paddd  0x40(%rsp),%xmm0
paddd  0x50(%rsp),%xmm0
paddd  0x60(%rsp),%xmm0
paddd  0x70(%rsp),%xmm0
paddd  0x80(%rsp),%xmm0
paddd  0x90(%rsp),%xmm0
paddd  0xa0(%rsp),%xmm0
paddd  0xb0(%rsp),%xmm0
paddd  0xc0(%rsp),%xmm0
paddd  0xd0(%rsp),%xmm0
paddd  0xe0(%rsp),%xmm0
paddd  0xf0(%rsp),%xmm0
paddd  0x100(%rsp),%xmm0
paddd  0x110(%rsp),%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
add    0x120(%rsp),%eax
add    0x124(%rsp),%eax
cmp    $0x2,%ebp
jl     1370 <rfc1071_ckecksum+0x240>
mov    %ebp,%ecx
sub    $0x3,%ecx
cmovb  %r15d,%ecx
add    $0x1,%ecx
cmp    $0xe,%ecx
jb     1352 <rfc1071_ckecksum+0x222>
shr    %ecx
add    $0x1,%ecx
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x18,%rsi
jae    1293 <rfc1071_ckecksum+0x163>
pxor   %xmm1,%xmm1
xor    %esi,%esi
jmp    12f9 <rfc1071_ckecksum+0x1c9>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm1,%xmm1
xor    %esi,%esi
nopl   (%rax)
movdqu (%rbx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rsi,4),%xmm1
movdqu 0x30(%rbx,%rsi,4),%xmm3
movdqu 0x40(%rbx,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbx,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbx,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbx,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    12a0 <rfc1071_ckecksum+0x170>
lea    (%rdx,%rdx,1),%r8d
test   %rax,%rax
je     132c <rfc1071_ckecksum+0x1fc>
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rax
xor    %edi,%edi
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rax
jne    1310 <rfc1071_ckecksum+0x1e0>
paddd  %xmm1,%xmm0
sub    %r8d,%ebp
lea    (%rbx,%rdx,4),%rbx
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rcx,%rdx
je     1370 <rfc1071_ckecksum+0x240>
mov    %ebp,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rbx),%eax
add    $0x4,%rbx
lea    -0x2(%rcx),%ebp
cmp    $0x3,%ecx
mov    %ebp,%ecx
ja     1360 <rfc1071_ckecksum+0x230>
cmp    $0x1,%ebp
jne    1377 <rfc1071_ckecksum+0x247>
add    (%rbx),%eax
cmp    $0x10000,%eax
jb     1391 <rfc1071_ckecksum+0x261>
xchg   %ax,%ax
mov    %eax,%ecx
sar    $0x10,%ecx
movzwl %ax,%eax
add    %ecx,%eax
cmp    $0xffff,%eax
ja     1380 <rfc1071_ckecksum+0x250>
not    %eax
add    $0x98,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.anon = type { [16 x i32], [16 x i32], i32, [3 x i32], i32 }
define i32 @rfc1071_ckecksum(i32* %0, i32* %1, i32 %2, i32* %3, i32 %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca %struct.anon
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
store i32* %0, i32** %6
store i32* %1, i32** %7
store i32 %2, i32* %8
store i32* %3, i32** %9
store i32 %4, i32* %10
%15 = bitcast %struct.anon* %11 to i32*
store i32* %15, i32** %12
store i32 0, i32* %13
store i32 148, i32* %14
%16 = getelementptr inbounds %struct.anon, %struct.anon* %11, i32 0, i32 0
%17 = bitcast [16 x i32]* %16 to i32**
%18 = load i32*, i32** %6
%19 = call i32 @memcpy(i32** %17, i32* %18, i32 16)
%20 = getelementptr inbounds %struct.anon, %struct.anon* %11, i32 0, i32 1
%21 = bitcast [16 x i32]* %20 to i32**
%22 = load i32*, i32** %7
%23 = call i32 @memcpy(i32** %21, i32* %22, i32 16)
%24 = load i32, i32* %10
%25 = call i32 @htonl(i32 %24)
%26 = getelementptr inbounds %struct.anon, %struct.anon* %11, i32 0, i32 2
store i32 %25, i32* %26
%27 = getelementptr inbounds %struct.anon, %struct.anon* %11, i32 0, i32 3
%28 = bitcast [3 x i32]* %27 to i32**
%29 = call i32 @memset(i32** %28, i32 0, i32 3)
%30 = load i32, i32* %8
%31 = getelementptr inbounds %struct.anon, %struct.anon* %11, i32 0, i32 4
store i32 %30, i32* %31
br label %32
32: ; preds = %35, %5
%33 = load i32, i32* %14
%34 = icmp sgt i32 %33, 1
br i1 %34, label %35, label %43
35: ; preds = %32
%36 = load i32*, i32** %12
%37 = getelementptr inbounds i32, i32* %36, i32 1
store i32* %37, i32** %12
%38 = load i32, i32* %36
%39 = load i32, i32* %13
%40 = add nsw i32 %39, %38
store i32 %40, i32* %13
%41 = load i32, i32* %14
%42 = sub nsw i32 %41, 2
store i32 %42, i32* %14
br label %32
43: ; preds = %32
br label %44
44: ; preds = %47, %43
%45 = load i32, i32* %10
%46 = icmp sgt i32 %45, 1
br i1 %46, label %47, label %55
47: ; preds = %44
%48 = load i32*, i32** %9
%49 = getelementptr inbounds i32, i32* %48, i32 1
store i32* %49, i32** %9
%50 = load i32, i32* %48
%51 = load i32, i32* %13
%52 = add nsw i32 %51, %50
store i32 %52, i32* %13
%53 = load i32, i32* %10
%54 = sub nsw i32 %53, 2
store i32 %54, i32* %10
br label %44
55: ; preds = %44
%56 = load i32, i32* %10
%57 = icmp sgt i32 %56, 0
br i1 %57, label %58, label %63
58: ; preds = %55
%59 = load i32*, i32** %9
%60 = load i32, i32* %59
%61 = load i32, i32* %13
%62 = add nsw i32 %61, %60
store i32 %62, i32* %13
br label %63
63: ; preds = %58, %55
br label %64
64: ; preds = %68, %63
%65 = load i32, i32* %13
%66 = ashr i32 %65, 16
%67 = icmp ne i32 %66, 0
br i1 %67, label %68, label %74
68: ; preds = %64
%69 = load i32, i32* %13
%70 = and i32 %69, 65535
%71 = load i32, i32* %13
%72 = ashr i32 %71, 16
%73 = add nsw i32 %70, %72
store i32 %73, i32* %13
br label %64
74: ; preds = %64
%75 = load i32, i32* %13
%76 = xor i32 %75, -1
ret i32 %76
}

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