#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 /*<<< orphan*/ uint16_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int checksum(int /*<<< orphan*/ *, int);
int /*<<< orphan*/ memset(char *, int, int);
int main(void) {
  char buffer[32];
  memset(buffer, 0, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xffff);
  assert(checksum((uint16_t *)buffer, 2) == 0xffff);
  assert(checksum((uint16_t *)buffer, 4) == 0xffff);
  assert(checksum((uint16_t *)buffer, 8) == 0xffff);
  assert(checksum((uint16_t *)buffer, 16) == 0xffff);
  assert(checksum((uint16_t *)buffer, 32) == 0xffff);
  memset(buffer, 0xff, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xff00);
  assert(checksum((uint16_t *)buffer, 2) == 0x0000);
  assert(checksum((uint16_t *)buffer, 4) == 0x0000);
  assert(checksum((uint16_t *)buffer, 8) == 0x0000);
  assert(checksum((uint16_t *)buffer, 16) == 0x0000);
  assert(checksum((uint16_t *)buffer, 32) == 0x0000);
  memset(buffer, 0x01, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xfffe);
  assert(checksum((uint16_t *)buffer, 2) == 0xfefe);
  assert(checksum((uint16_t *)buffer, 4) == 0xfdfd);
  assert(checksum((uint16_t *)buffer, 8) == 0xfbfb);
  assert(checksum((uint16_t *)buffer, 16) == 0xf7f7);
  assert(checksum((uint16_t *)buffer, 32) == 0xefef);
  memset(buffer, 0x11, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xffee);
  assert(checksum((uint16_t *)buffer, 2) == 0xeeee);
  assert(checksum((uint16_t *)buffer, 4) == 0xdddd);
  assert(checksum((uint16_t *)buffer, 8) == 0xbbbb);
  assert(checksum((uint16_t *)buffer, 16) == 0x7777);
  assert(checksum((uint16_t *)buffer, 32) == 0xeeee);
  memset(buffer, 0xaa, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xff55);
  assert(checksum((uint16_t *)buffer, 2) == 0x5555);
  assert(checksum((uint16_t *)buffer, 4) == 0xaaaa);
  assert(checksum((uint16_t *)buffer, 8) == 0x5555);
  assert(checksum((uint16_t *)buffer, 16) == 0xaaaa);
  assert(checksum((uint16_t *)buffer, 32) == 0x5555);
  memset(buffer, 0x93, 32);
  assert(checksum((uint16_t *)buffer, 1) == 0xff6c);
  assert(checksum((uint16_t *)buffer, 2) == 0x6c6c);
  assert(checksum((uint16_t *)buffer, 4) == 0xd8d8);
  assert(checksum((uint16_t *)buffer, 8) == 0xb1b1);
  assert(checksum((uint16_t *)buffer, 16) == 0x6363);
  assert(checksum((uint16_t *)buffer, 32) == 0xc6c6);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0xffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0xff,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xff00,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xfffe,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0xfefe,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0xfdfd,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0xfbfb,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0xf7f7,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0xefef,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x11,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xffee,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0xeeee,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0xdddd,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0xbbbb,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0x7777,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0xeeee,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0xaa,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xff55,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0x5555,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0xaaaa,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0x5555,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0xaaaa,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0x5555,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x93,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
cmp    $0xff6c,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
cmp    $0x6c6c,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
cmp    $0xd8d8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
cmp    $0xb1b1,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
cmp    $0x6363,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x30(%rbp),%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
cmp    $0xc6c6,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x20,%rsp
mov    %rsp,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffff,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0xff,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xff00,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xfffe,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xfefe,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xfdfd,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xfbfb,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xf7f7,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xefef,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x11,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xffee,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xeeee,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xdddd,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xbbbb,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x7777,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xeeee,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0xaa,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xff55,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x5555,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xaaaa,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x5555,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xaaaa,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x5555,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x93,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xff6c,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x6c6c,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xd8d8,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xb1b1,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x10,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0x6363,%eax
sete   %dil
call   1050 <assert@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <checksum@plt>
xor    %edi,%edi
cmp    $0xc6c6,%eax
sete   %dil
call   1050 <assert@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca [32 x i8]
store i32 0, i32* %1
%3 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%4 = call i32 @memset(i8* %3, i32 0, i32 32)
%5 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%6 = bitcast i8* %5 to i32*
%7 = call i32 @checksum(i32* %6, i32 1)
%8 = icmp eq i32 %7, 65535
%9 = zext i1 %8 to i32
%10 = call i32 @assert(i32 %9)
%11 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%12 = bitcast i8* %11 to i32*
%13 = call i32 @checksum(i32* %12, i32 2)
%14 = icmp eq i32 %13, 65535
%15 = zext i1 %14 to i32
%16 = call i32 @assert(i32 %15)
%17 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%18 = bitcast i8* %17 to i32*
%19 = call i32 @checksum(i32* %18, i32 4)
%20 = icmp eq i32 %19, 65535
%21 = zext i1 %20 to i32
%22 = call i32 @assert(i32 %21)
%23 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%24 = bitcast i8* %23 to i32*
%25 = call i32 @checksum(i32* %24, i32 8)
%26 = icmp eq i32 %25, 65535
%27 = zext i1 %26 to i32
%28 = call i32 @assert(i32 %27)
%29 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%30 = bitcast i8* %29 to i32*
%31 = call i32 @checksum(i32* %30, i32 16)
%32 = icmp eq i32 %31, 65535
%33 = zext i1 %32 to i32
%34 = call i32 @assert(i32 %33)
%35 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%36 = bitcast i8* %35 to i32*
%37 = call i32 @checksum(i32* %36, i32 32)
%38 = icmp eq i32 %37, 65535
%39 = zext i1 %38 to i32
%40 = call i32 @assert(i32 %39)
%41 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%42 = call i32 @memset(i8* %41, i32 255, i32 32)
%43 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%44 = bitcast i8* %43 to i32*
%45 = call i32 @checksum(i32* %44, i32 1)
%46 = icmp eq i32 %45, 65280
%47 = zext i1 %46 to i32
%48 = call i32 @assert(i32 %47)
%49 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%50 = bitcast i8* %49 to i32*
%51 = call i32 @checksum(i32* %50, i32 2)
%52 = icmp eq i32 %51, 0
%53 = zext i1 %52 to i32
%54 = call i32 @assert(i32 %53)
%55 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%56 = bitcast i8* %55 to i32*
%57 = call i32 @checksum(i32* %56, i32 4)
%58 = icmp eq i32 %57, 0
%59 = zext i1 %58 to i32
%60 = call i32 @assert(i32 %59)
%61 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%62 = bitcast i8* %61 to i32*
%63 = call i32 @checksum(i32* %62, i32 8)
%64 = icmp eq i32 %63, 0
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
%67 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%68 = bitcast i8* %67 to i32*
%69 = call i32 @checksum(i32* %68, i32 16)
%70 = icmp eq i32 %69, 0
%71 = zext i1 %70 to i32
%72 = call i32 @assert(i32 %71)
%73 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%74 = bitcast i8* %73 to i32*
%75 = call i32 @checksum(i32* %74, i32 32)
%76 = icmp eq i32 %75, 0
%77 = zext i1 %76 to i32
%78 = call i32 @assert(i32 %77)
%79 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%80 = call i32 @memset(i8* %79, i32 1, i32 32)
%81 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%82 = bitcast i8* %81 to i32*
%83 = call i32 @checksum(i32* %82, i32 1)
%84 = icmp eq i32 %83, 65534
%85 = zext i1 %84 to i32
%86 = call i32 @assert(i32 %85)
%87 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%88 = bitcast i8* %87 to i32*
%89 = call i32 @checksum(i32* %88, i32 2)
%90 = icmp eq i32 %89, 65278
%91 = zext i1 %90 to i32
%92 = call i32 @assert(i32 %91)
%93 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%94 = bitcast i8* %93 to i32*
%95 = call i32 @checksum(i32* %94, i32 4)
%96 = icmp eq i32 %95, 65021
%97 = zext i1 %96 to i32
%98 = call i32 @assert(i32 %97)
%99 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%100 = bitcast i8* %99 to i32*
%101 = call i32 @checksum(i32* %100, i32 8)
%102 = icmp eq i32 %101, 64507
%103 = zext i1 %102 to i32
%104 = call i32 @assert(i32 %103)
%105 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%106 = bitcast i8* %105 to i32*
%107 = call i32 @checksum(i32* %106, i32 16)
%108 = icmp eq i32 %107, 63479
%109 = zext i1 %108 to i32
%110 = call i32 @assert(i32 %109)
%111 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%112 = bitcast i8* %111 to i32*
%113 = call i32 @checksum(i32* %112, i32 32)
%114 = icmp eq i32 %113, 61423
%115 = zext i1 %114 to i32
%116 = call i32 @assert(i32 %115)
%117 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%118 = call i32 @memset(i8* %117, i32 17, i32 32)
%119 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%120 = bitcast i8* %119 to i32*
%121 = call i32 @checksum(i32* %120, i32 1)
%122 = icmp eq i32 %121, 65518
%123 = zext i1 %122 to i32
%124 = call i32 @assert(i32 %123)
%125 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%126 = bitcast i8* %125 to i32*
%127 = call i32 @checksum(i32* %126, i32 2)
%128 = icmp eq i32 %127, 61166
%129 = zext i1 %128 to i32
%130 = call i32 @assert(i32 %129)
%131 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%132 = bitcast i8* %131 to i32*
%133 = call i32 @checksum(i32* %132, i32 4)
%134 = icmp eq i32 %133, 56797
%135 = zext i1 %134 to i32
%136 = call i32 @assert(i32 %135)
%137 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%138 = bitcast i8* %137 to i32*
%139 = call i32 @checksum(i32* %138, i32 8)
%140 = icmp eq i32 %139, 48059
%141 = zext i1 %140 to i32
%142 = call i32 @assert(i32 %141)
%143 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%144 = bitcast i8* %143 to i32*
%145 = call i32 @checksum(i32* %144, i32 16)
%146 = icmp eq i32 %145, 30583
%147 = zext i1 %146 to i32
%148 = call i32 @assert(i32 %147)
%149 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%150 = bitcast i8* %149 to i32*
%151 = call i32 @checksum(i32* %150, i32 32)
%152 = icmp eq i32 %151, 61166
%153 = zext i1 %152 to i32
%154 = call i32 @assert(i32 %153)
%155 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%156 = call i32 @memset(i8* %155, i32 170, i32 32)
%157 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%158 = bitcast i8* %157 to i32*
%159 = call i32 @checksum(i32* %158, i32 1)
%160 = icmp eq i32 %159, 65365
%161 = zext i1 %160 to i32
%162 = call i32 @assert(i32 %161)
%163 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%164 = bitcast i8* %163 to i32*
%165 = call i32 @checksum(i32* %164, i32 2)
%166 = icmp eq i32 %165, 21845
%167 = zext i1 %166 to i32
%168 = call i32 @assert(i32 %167)
%169 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%170 = bitcast i8* %169 to i32*
%171 = call i32 @checksum(i32* %170, i32 4)
%172 = icmp eq i32 %171, 43690
%173 = zext i1 %172 to i32
%174 = call i32 @assert(i32 %173)
%175 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%176 = bitcast i8* %175 to i32*
%177 = call i32 @checksum(i32* %176, i32 8)
%178 = icmp eq i32 %177, 21845
%179 = zext i1 %178 to i32
%180 = call i32 @assert(i32 %179)
%181 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%182 = bitcast i8* %181 to i32*
%183 = call i32 @checksum(i32* %182, i32 16)
%184 = icmp eq i32 %183, 43690
%185 = zext i1 %184 to i32
%186 = call i32 @assert(i32 %185)
%187 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%188 = bitcast i8* %187 to i32*
%189 = call i32 @checksum(i32* %188, i32 32)
%190 = icmp eq i32 %189, 21845
%191 = zext i1 %190 to i32
%192 = call i32 @assert(i32 %191)
%193 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%194 = call i32 @memset(i8* %193, i32 147, i32 32)
%195 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%196 = bitcast i8* %195 to i32*
%197 = call i32 @checksum(i32* %196, i32 1)
%198 = icmp eq i32 %197, 65388
%199 = zext i1 %198 to i32
%200 = call i32 @assert(i32 %199)
%201 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%202 = bitcast i8* %201 to i32*
%203 = call i32 @checksum(i32* %202, i32 2)
%204 = icmp eq i32 %203, 27756
%205 = zext i1 %204 to i32
%206 = call i32 @assert(i32 %205)
%207 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%208 = bitcast i8* %207 to i32*
%209 = call i32 @checksum(i32* %208, i32 4)
%210 = icmp eq i32 %209, 55512
%211 = zext i1 %210 to i32
%212 = call i32 @assert(i32 %211)
%213 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%214 = bitcast i8* %213 to i32*
%215 = call i32 @checksum(i32* %214, i32 8)
%216 = icmp eq i32 %215, 45489
%217 = zext i1 %216 to i32
%218 = call i32 @assert(i32 %217)
%219 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%220 = bitcast i8* %219 to i32*
%221 = call i32 @checksum(i32* %220, i32 16)
%222 = icmp eq i32 %221, 25443
%223 = zext i1 %222 to i32
%224 = call i32 @assert(i32 %223)
%225 = getelementptr inbounds [32 x i8], [32 x i8]* %2, i64 0, i64 0
%226 = bitcast i8* %225 to i32*
%227 = call i32 @checksum(i32* %226, i32 32)
%228 = icmp eq i32 %227, 50886
%229 = zext i1 %228 to i32
%230 = call i32 @assert(i32 %229)
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca [32 x i8]
%2 = getelementptr inbounds [32 x i8], [32 x i8]* %1, i64 0, i64 0
%3 = call i32 @memset(i8* %2, i32 0, i32 32)
%4 = bitcast [32 x i8]* %1 to i32*
%5 = call i32 @checksum(i32* %4, i32 1)
%6 = icmp eq i32 %5, 65535
%7 = zext i1 %6 to i32
%8 = call i32 @assert(i32 %7)
%9 = call i32 @checksum(i32* %4, i32 2)
%10 = icmp eq i32 %9, 65535
%11 = zext i1 %10 to i32
%12 = call i32 @assert(i32 %11)
%13 = call i32 @checksum(i32* %4, i32 4)
%14 = icmp eq i32 %13, 65535
%15 = zext i1 %14 to i32
%16 = call i32 @assert(i32 %15)
%17 = call i32 @checksum(i32* %4, i32 8)
%18 = icmp eq i32 %17, 65535
%19 = zext i1 %18 to i32
%20 = call i32 @assert(i32 %19)
%21 = call i32 @checksum(i32* %4, i32 16)
%22 = icmp eq i32 %21, 65535
%23 = zext i1 %22 to i32
%24 = call i32 @assert(i32 %23)
%25 = call i32 @checksum(i32* %4, i32 32)
%26 = icmp eq i32 %25, 65535
%27 = zext i1 %26 to i32
%28 = call i32 @assert(i32 %27)
%29 = call i32 @memset(i8* %2, i32 255, i32 32)
%30 = call i32 @checksum(i32* %4, i32 1)
%31 = icmp eq i32 %30, 65280
%32 = zext i1 %31 to i32
%33 = call i32 @assert(i32 %32)
%34 = call i32 @checksum(i32* %4, i32 2)
%35 = icmp eq i32 %34, 0
%36 = zext i1 %35 to i32
%37 = call i32 @assert(i32 %36)
%38 = call i32 @checksum(i32* %4, i32 4)
%39 = icmp eq i32 %38, 0
%40 = zext i1 %39 to i32
%41 = call i32 @assert(i32 %40)
%42 = call i32 @checksum(i32* %4, i32 8)
%43 = icmp eq i32 %42, 0
%44 = zext i1 %43 to i32
%45 = call i32 @assert(i32 %44)
%46 = call i32 @checksum(i32* %4, i32 16)
%47 = icmp eq i32 %46, 0
%48 = zext i1 %47 to i32
%49 = call i32 @assert(i32 %48)
%50 = call i32 @checksum(i32* %4, i32 32)
%51 = icmp eq i32 %50, 0
%52 = zext i1 %51 to i32
%53 = call i32 @assert(i32 %52)
%54 = call i32 @memset(i8* %2, i32 1, i32 32)
%55 = call i32 @checksum(i32* %4, i32 1)
%56 = icmp eq i32 %55, 65534
%57 = zext i1 %56 to i32
%58 = call i32 @assert(i32 %57)
%59 = call i32 @checksum(i32* %4, i32 2)
%60 = icmp eq i32 %59, 65278
%61 = zext i1 %60 to i32
%62 = call i32 @assert(i32 %61)
%63 = call i32 @checksum(i32* %4, i32 4)
%64 = icmp eq i32 %63, 65021
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
%67 = call i32 @checksum(i32* %4, i32 8)
%68 = icmp eq i32 %67, 64507
%69 = zext i1 %68 to i32
%70 = call i32 @assert(i32 %69)
%71 = call i32 @checksum(i32* %4, i32 16)
%72 = icmp eq i32 %71, 63479
%73 = zext i1 %72 to i32
%74 = call i32 @assert(i32 %73)
%75 = call i32 @checksum(i32* %4, i32 32)
%76 = icmp eq i32 %75, 61423
%77 = zext i1 %76 to i32
%78 = call i32 @assert(i32 %77)
%79 = call i32 @memset(i8* %2, i32 17, i32 32)
%80 = call i32 @checksum(i32* %4, i32 1)
%81 = icmp eq i32 %80, 65518
%82 = zext i1 %81 to i32
%83 = call i32 @assert(i32 %82)
%84 = call i32 @checksum(i32* %4, i32 2)
%85 = icmp eq i32 %84, 61166
%86 = zext i1 %85 to i32
%87 = call i32 @assert(i32 %86)
%88 = call i32 @checksum(i32* %4, i32 4)
%89 = icmp eq i32 %88, 56797
%90 = zext i1 %89 to i32
%91 = call i32 @assert(i32 %90)
%92 = call i32 @checksum(i32* %4, i32 8)
%93 = icmp eq i32 %92, 48059
%94 = zext i1 %93 to i32
%95 = call i32 @assert(i32 %94)
%96 = call i32 @checksum(i32* %4, i32 16)
%97 = icmp eq i32 %96, 30583
%98 = zext i1 %97 to i32
%99 = call i32 @assert(i32 %98)
%100 = call i32 @checksum(i32* %4, i32 32)
%101 = icmp eq i32 %100, 61166
%102 = zext i1 %101 to i32
%103 = call i32 @assert(i32 %102)
%104 = call i32 @memset(i8* %2, i32 170, i32 32)
%105 = call i32 @checksum(i32* %4, i32 1)
%106 = icmp eq i32 %105, 65365
%107 = zext i1 %106 to i32
%108 = call i32 @assert(i32 %107)
%109 = call i32 @checksum(i32* %4, i32 2)
%110 = icmp eq i32 %109, 21845
%111 = zext i1 %110 to i32
%112 = call i32 @assert(i32 %111)
%113 = call i32 @checksum(i32* %4, i32 4)
%114 = icmp eq i32 %113, 43690
%115 = zext i1 %114 to i32
%116 = call i32 @assert(i32 %115)
%117 = call i32 @checksum(i32* %4, i32 8)
%118 = icmp eq i32 %117, 21845
%119 = zext i1 %118 to i32
%120 = call i32 @assert(i32 %119)
%121 = call i32 @checksum(i32* %4, i32 16)
%122 = icmp eq i32 %121, 43690
%123 = zext i1 %122 to i32
%124 = call i32 @assert(i32 %123)
%125 = call i32 @checksum(i32* %4, i32 32)
%126 = icmp eq i32 %125, 21845
%127 = zext i1 %126 to i32
%128 = call i32 @assert(i32 %127)
%129 = call i32 @memset(i8* %2, i32 147, i32 32)
%130 = call i32 @checksum(i32* %4, i32 1)
%131 = icmp eq i32 %130, 65388
%132 = zext i1 %131 to i32
%133 = call i32 @assert(i32 %132)
%134 = call i32 @checksum(i32* %4, i32 2)
%135 = icmp eq i32 %134, 27756
%136 = zext i1 %135 to i32
%137 = call i32 @assert(i32 %136)
%138 = call i32 @checksum(i32* %4, i32 4)
%139 = icmp eq i32 %138, 55512
%140 = zext i1 %139 to i32
%141 = call i32 @assert(i32 %140)
%142 = call i32 @checksum(i32* %4, i32 8)
%143 = icmp eq i32 %142, 45489
%144 = zext i1 %143 to i32
%145 = call i32 @assert(i32 %144)
%146 = call i32 @checksum(i32* %4, i32 16)
%147 = icmp eq i32 %146, 25443
%148 = zext i1 %147 to i32
%149 = call i32 @assert(i32 %148)
%150 = call i32 @checksum(i32* %4, i32 32)
%151 = icmp eq i32 %150, 50886
%152 = zext i1 %151 to i32
%153 = call i32 @assert(i32 %152)
ret i32 0
}