#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*/ sizes;
typedef int /*<<< orphan*/ randbuf;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ errno;
int /*<<< orphan*/ fillrand(unsigned char *, int);
int /*<<< orphan*/ free(unsigned char *);
unsigned char *malloc(size_t);
unsigned char *memzero(unsigned char *, size_t);
scalar_t__ nonzero(unsigned char *, size_t);
int main(void) {
  unsigned char *x = NULL;
  size_t sizes[] = {
      1, 2, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 1024, 2048,
  };
  size_t i, j, n;
  unsigned char *randbuf = NULL;
  randbuf = malloc(4096);
  assert(randbuf != NULL);
  x = randbuf;
  errno = 0;
  assert(memzero(x, 0) == x);
  assert(errno == 0);
  fillrand(randbuf, sizeof(randbuf));
  n = sizeof(sizes) / sizeof(size_t);
  for (i = 0; i < n; i++) {
    errno = 0;
    assert((x = malloc(sizes[i])) != NULL);
    assert(errno == 0);
    for (j = 0; j < sizes[i]; j++) {
      x[j] = randbuf[j];
    }
    memzero(x, sizes[i]);
    if (sizes[i] > 8) {
      memzero(x + 1, sizes[i] - 1);
      memzero(x + 2, sizes[i] - 2);
      memzero(x + 3, sizes[i] - 3);
      memzero(x + 4, sizes[i] - 4);
      memzero(x + 5, sizes[i] - 5);
      memzero(x + 6, sizes[i] - 6);
      memzero(x + 7, sizes[i] - 7);
    }
    assert(nonzero(x, sizes[i]) == 0);
    free(x);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x10(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xe68(%rip),%rsi
mov    $0x80,%edx
call   1080 <memcpy@plt>
movq   $0x0,-0xb0(%rbp)
mov    $0x1000,%edi
call   1090 <malloc@plt>
mov    %rax,-0xb0(%rbp)
cmpq   $0x0,-0xb0(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0xb0(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x2dfb(%rip),%rax
movq   $0x0,(%rax)
mov    -0x10(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <memzero@plt>
cmp    -0x10(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    0x2dcf(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0xb0(%rbp),%rdi
mov    $0x8,%esi
call   1060 <fillrand@plt>
movq   $0x10,-0xa8(%rbp)
movq   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0xa8(%rbp),%rax
jae    1460 <main+0x2f0>
mov    0x2d7c(%rip),%rax
movq   $0x0,(%rax)
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rdi
ff
call   1090 <malloc@plt>
mov    %rax,-0x10(%rbp)
cmp    $0x0,%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    0x2d45(%rip),%rax
cmpq   $0x0,(%rax)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
movq   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x98(%rbp),%rcx
cmp    -0x90(%rbp,%rcx,8),%rax
ff
jae    1309 <main+0x199>
mov    -0xb0(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    12b7 <main+0x147>
mov    -0x10(%rbp),%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
call   1050 <memzero@plt>
mov    -0x98(%rbp),%rax
cmpq   $0x8,-0x90(%rbp,%rax,8)
ff 08
jbe    1417 <main+0x2a7>
mov    -0x10(%rbp),%rdi
add    $0x1,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x1,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x2,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x2,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x3,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x3,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x4,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x4,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x5,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x5,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x6,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x6,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
add    $0x7,%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
sub    $0x7,%rsi
call   1050 <memzero@plt>
mov    -0x10(%rbp),%rdi
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
call   1040 <nonzero@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1249 <main+0xd9>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0x1000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
xor    %edi,%edi
test   %rax,%rax
setne  %dil
call   1070 <assert@plt>
mov    0x2e43(%rip),%r12
movq   $0x0,(%r12)
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memzero@plt>
xor    %edi,%edi
cmp    %r14,%rax
sete   %dil
call   1070 <assert@plt>
xor    %edi,%edi
cmpq   $0x0,(%r12)
sete   %dil
call   1070 <assert@plt>
mov    %r14,%rdi
mov    $0x8,%esi
call   1060 <fillrand@plt>
mov    $0xfffffffffffffffc,%r13
lea    0xe18(%rip),%rbp
jmp    1223 <main+0xb3>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %rbx,%rsi
call   1040 <nonzero@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1070 <assert@plt>
mov    %r15,%rdi
call   1030 <free@plt>
add    $0x1,%r13
add    $0x8,%rbp
cmp    $0xc,%r13
je     12e5 <main+0x175>
movq   $0x0,(%r12)
mov    0x0(%rbp),%rbx
mov    %rbx,%rdi
call   1090 <malloc@plt>
mov    %rax,%r15
xor    %edi,%edi
test   %rax,%rax
setne  %dil
call   1070 <assert@plt>
xor    %edi,%edi
cmpq   $0x0,(%r12)
sete   %dil
call   1070 <assert@plt>
cmp    $0x2,%rbx
mov    $0x1,%edx
cmovae %rbx,%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1080 <memcpy@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <memzero@plt>
cmp    $0xb,%r13
ja     11f0 <main+0x80>
lea    0x1(%r15),%rdi
lea    -0x1(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x2(%r15),%rdi
lea    -0x2(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x3(%r15),%rdi
lea    -0x3(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x4(%r15),%rdi
lea    -0x4(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x5(%r15),%rdi
lea    -0x5(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x6(%r15),%rdi
lea    -0x6(%rbx),%rsi
call   1050 <memzero@plt>
lea    0x7(%r15),%rdi
lea    -0x7(%rbx),%rsi
call   1050 <memzero@plt>
jmp    11f0 <main+0x80>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.main.sizes = [16 x i64] [i64 1, i64 2, i64 7, i64 8, i64 9, i64 15, i64 16, i64 17, i64 31, i64 32, i64 33, i64 63, i64 64, i64 65, i64 1024, i64 2048]
@errno = global i64 0
define i32 @main() {
%1 = tail call dereferenceable_or_null(4096) i8* @malloc(i64 4096)
%2 = icmp ne i8* %1, null
%3 = zext i1 %2 to i32
%4 = tail call i32 @assert(i32 %3)
store i64 0, i64* @errno
%5 = tail call i8* @memzero(i8* %1, i64 0)
%6 = icmp eq i8* %5, %1
%7 = zext i1 %6 to i32
%8 = tail call i32 @assert(i32 %7)
%9 = load i64, i64* @errno
%10 = icmp eq i64 %9, 0
%11 = zext i1 %10 to i32
%12 = tail call i32 @assert(i32 %11)
%13 = tail call i32 @fillrand(i8* %1, i32 8)
br label %14
14: ; preds = %0, %52
%15 = phi i64 [ 0, %0 ], [ %58, %52 ]
store i64 0, i64* @errno
%16 = getelementptr inbounds [16 x i64], [16 x i64]* @__const.main.sizes, i64 0, i64 %15
%17 = load i64, i64* %16
%18 = tail call i8* @malloc(i64 %17)
%19 = icmp ne i8* %18, null
%20 = zext i1 %19 to i32
%21 = tail call i32 @assert(i32 %20)
%22 = load i64, i64* @errno
%23 = icmp eq i64 %22, 0
%24 = zext i1 %23 to i32
%25 = tail call i32 @assert(i32 %24)
%26 = call i64 @llvm.umax.i64(i64 %17, i64 1)
%27 = tail call i8* @memzero(i8* %18, i64 %17)
%28 = add nsw i64 %15, -4
%29 = icmp ult i64 %28, 12
br i1 %29, label %30, label %52
30: ; preds = %14
%31 = getelementptr inbounds i8, i8* %18, i64 1
%32 = add i64 %17, -1
%33 = tail call i8* @memzero(i8* %31, i64 %32)
%34 = getelementptr inbounds i8, i8* %18, i64 2
%35 = add i64 %17, -2
%36 = tail call i8* @memzero(i8* %34, i64 %35)
%37 = getelementptr inbounds i8, i8* %18, i64 3
%38 = add i64 %17, -3
%39 = tail call i8* @memzero(i8* %37, i64 %38)
%40 = getelementptr inbounds i8, i8* %18, i64 4
%41 = add i64 %17, -4
%42 = tail call i8* @memzero(i8* %40, i64 %41)
%43 = getelementptr inbounds i8, i8* %18, i64 5
%44 = add i64 %17, -5
%45 = tail call i8* @memzero(i8* %43, i64 %44)
%46 = getelementptr inbounds i8, i8* %18, i64 6
%47 = add i64 %17, -6
%48 = tail call i8* @memzero(i8* %46, i64 %47)
%49 = getelementptr inbounds i8, i8* %18, i64 7
%50 = add i64 %17, -7
%51 = tail call i8* @memzero(i8* %49, i64 %50)
br label %52
52: ; preds = %30, %14
%53 = tail call i64 @nonzero(i8* %18, i64 %17)
%54 = icmp eq i64 %53, 0
%55 = zext i1 %54 to i32
%56 = tail call i32 @assert(i32 %55)
%57 = tail call i32 @free(i8* %18)
%58 = add nuw nsw i64 %15, 1
%59 = icmp eq i64 %58, 16
br i1 %59, label %60, label %14
60: ; preds = %52
ret i32 0
}