#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*/ assert(int);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int ofc_getCount();
int /*<<< orphan*/ stdout;
void test_malloc(void) {
  char *ptr;
  int i;
  do {
    fprintf(stdout, "#### malloc ####\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_01 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(8);
  for (i = 0; i < 16; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 8);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_02 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(1024);
  for (i = 0; i < 1032; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 8);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_03 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(256 * 1024);
  for (i = 0; i < (256 * 1024) + 8; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 8);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_04 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(11);
  for (i = 0; i < 16; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 5);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_05 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(11);
  for (i = 0; i < 20; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 9);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_06 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(0);
  if (ptr != NULL) {
    for (i = 0; i < 8; i++) {
      ptr[i] = 'z';
    }
  }
  free(ptr);
  if (ptr != NULL) {
    assert(ofc_getCount() == 8);
  }
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_07 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(24);
  for (i = 0; i < 32; i++) {
    ptr[i] = 'a';
  }
  free(ptr);
  assert(ofc_getCount() == 8);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_08 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(8);
  for (i = 0; i < 8; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 0);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_09 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(1024);
  for (i = 0; i < 1024; i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 0);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  do {
    fprintf(stdout, "[TEST] malloc_10 ...\n");
    fflush(stdout);
  } while (0);
  ptr = (char *)malloc(256 * 1024);
  for (i = 0; i < (256 * 1024); i++) {
    ptr[i] = 'z';
  }
  free(ptr);
  assert(ofc_getCount() == 0);
  do {
    fprintf(stdout, "passed\n");
    fflush(stdout);
  } while (0);
  return;
}


x86 assembly (clang, -O0):
<test_malloc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    0x2e71(%rip),%rax
mov    (%rax),%edi
lea    0xe88(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2e5c(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    1190 <test_malloc+0x30>
mov    0x2e49(%rip),%rax
mov    (%rax),%edi
lea    0xe72(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2e34(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x10,-0xc(%rbp)
jge    11ec <test_malloc+0x8c>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11c8 <test_malloc+0x68>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2dcd(%rip),%rax
mov    (%rax),%edi
lea    0xe0c(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2db8(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    1234 <test_malloc+0xd4>
mov    0x2da5(%rip),%rax
mov    (%rax),%edi
lea    0xdec(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2d90(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x400,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x408,-0xc(%rbp)
jge    1293 <test_malloc+0x133>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    126c <test_malloc+0x10c>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2d26(%rip),%rax
mov    (%rax),%edi
lea    0xd65(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2d11(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    12db <test_malloc+0x17b>
mov    0x2cfe(%rip),%rax
mov    (%rax),%edi
lea    0xd5b(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2ce9(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x40000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x40008,-0xc(%rbp)
jge    133a <test_malloc+0x1da>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1313 <test_malloc+0x1b3>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2c7f(%rip),%rax
mov    (%rax),%edi
lea    0xcbe(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2c6a(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    1382 <test_malloc+0x222>
mov    0x2c57(%rip),%rax
mov    (%rax),%edi
lea    0xcca(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2c42(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0xb,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x10,-0xc(%rbp)
jge    13de <test_malloc+0x27e>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13ba <test_malloc+0x25a>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x5,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2bdb(%rip),%rax
mov    (%rax),%edi
lea    0xc1a(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2bc6(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    1426 <test_malloc+0x2c6>
mov    0x2bb3(%rip),%rax
mov    (%rax),%edi
lea    0xc3c(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2b9e(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0xb,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x14,-0xc(%rbp)
jge    1482 <test_malloc+0x322>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    145e <test_malloc+0x2fe>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x9,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2b37(%rip),%rax
mov    (%rax),%edi
lea    0xb76(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2b22(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    14ca <test_malloc+0x36a>
mov    0x2b0f(%rip),%rax
mov    (%rax),%edi
lea    0xbae(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2afa(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
xor    %edi,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1533 <test_malloc+0x3d3>
movl   $0x0,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    152e <test_malloc+0x3ce>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    150a <test_malloc+0x3aa>
jmp    1533 <test_malloc+0x3d3>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x8(%rbp)
je     155e <test_malloc+0x3fe>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    1563 <test_malloc+0x403>
mov    0x2a76(%rip),%rax
mov    (%rax),%edi
lea    0xab5(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2a61(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    158b <test_malloc+0x42b>
mov    0x2a4e(%rip),%rax
mov    (%rax),%edi
lea    0xb03(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2a39(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x18,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x20,-0xc(%rbp)
jge    15e7 <test_malloc+0x487>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15c3 <test_malloc+0x463>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x29d2(%rip),%rax
mov    (%rax),%edi
lea    0xa11(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x29bd(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    162f <test_malloc+0x4cf>
mov    0x29aa(%rip),%rax
mov    (%rax),%edi
lea    0xa75(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2995(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    168b <test_malloc+0x52b>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1667 <test_malloc+0x507>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x292e(%rip),%rax
mov    (%rax),%edi
lea    0x96d(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2919(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    16d3 <test_malloc+0x573>
mov    0x2906(%rip),%rax
mov    (%rax),%edi
lea    0x9e7(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x28f1(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x400,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x400,-0xc(%rbp)
jge    1732 <test_malloc+0x5d2>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    170b <test_malloc+0x5ab>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x2887(%rip),%rax
mov    (%rax),%edi
lea    0x8c6(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2872(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
jmp    177a <test_malloc+0x61a>
mov    0x285f(%rip),%rax
mov    (%rax),%edi
lea    0x956(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x284a(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
mov    $0x40000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x40000,-0xc(%rbp)
jge    17d9 <test_malloc+0x679>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x7a,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    17b2 <test_malloc+0x652>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    $0x0,%al
call   1080 <ofc_getCount@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    0x27e0(%rip),%rax
mov    (%rax),%edi
lea    0x81f(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x27cb(%rip),%rax
mov    (%rax),%edi
call   1070 <fflush@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_malloc>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
movabs $0x7a7a7a7a7a7a7a7a,%r12
7a 7a 7a
mov    0x2e57(%rip),%r15
mov    (%r15),%edi
lea    0xe8d(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xe88(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x8,%edi
call   1070 <malloc@plt>
movaps 0xe38(%rip),%xmm0
movups %xmm0,(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
lea    0xe56(%rip),%r14
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xe44(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x400,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x408,%edx
mov    %rax,%rdi
mov    $0x7a,%esi
call   1040 <memset@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xdf4(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x40000,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x40008,%edx
mov    %rax,%rdi
mov    $0x7a,%esi
call   1040 <memset@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xda4(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0xb,%edi
call   1070 <malloc@plt>
movaps 0xd0a(%rip),%xmm0
movups %xmm0,(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x5,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xd5f(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0xb,%edi
call   1070 <malloc@plt>
movaps 0xcaf(%rip),%xmm0
movups %xmm0,(%rax)
movl   $0x7a7a7a7a,0x10(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x9,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xd13(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
xor    %edi,%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     13d0 <test_malloc+0x260>
mov    %r12,(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1050 <assert@plt>
jmp    13d8 <test_malloc+0x268>
mov    %rax,%rdi
call   1030 <free@plt>
mov    (%r15),%edi
lea    0xc66(%rip),%r14
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xcc2(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x18,%edi
call   1070 <malloc@plt>
movaps 0xbf6(%rip),%xmm0
movups %xmm0,(%rax)
movups %xmm0,0x10(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xc79(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x8,%edi
call   1070 <malloc@plt>
mov    %r12,(%rax)
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xc3c(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x400,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x400,%edx
mov    %rax,%rdi
mov    $0x7a,%esi
call   1040 <memset@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    (%r15),%edi
lea    0xbed(%rip),%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
call   1080 <fflush@plt>
mov    $0x40000,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x40000,%edx
mov    %rax,%rdi
mov    $0x7a,%esi
call   1040 <memset@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
call   1090 <ofc_getCount@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1050 <assert@plt>
mov    (%r15),%edi
mov    %r14,%rsi
call   1060 <fprintf@plt>
mov    (%r15),%edi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1080 <fflush@plt>

LLVM IR (-O0):
@stdout = global i32 0
@.str = [18 x i8] c"#### malloc ####\0A\00"
@.str.1 = [22 x i8] c"[TEST] malloc_01 ...\0A\00"
@.str.2 = [8 x i8] c"passed\0A\00"
@.str.3 = [22 x i8] c"[TEST] malloc_02 ...\0A\00"
@.str.4 = [22 x i8] c"[TEST] malloc_03 ...\0A\00"
@.str.5 = [22 x i8] c"[TEST] malloc_04 ...\0A\00"
@.str.6 = [22 x i8] c"[TEST] malloc_05 ...\0A\00"
@.str.7 = [22 x i8] c"[TEST] malloc_06 ...\0A\00"
@.str.8 = [22 x i8] c"[TEST] malloc_07 ...\0A\00"
@.str.9 = [22 x i8] c"[TEST] malloc_08 ...\0A\00"
@.str.10 = [22 x i8] c"[TEST] malloc_09 ...\0A\00"
@.str.11 = [22 x i8] c"[TEST] malloc_10 ...\0A\00"
define void @test_malloc() {
%1 = alloca i8*
%2 = alloca i32
br label %3
3: ; preds = %0
%4 = load i32, i32* @stdout
%5 = call i32 @fprintf(i32 %4, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
%6 = load i32, i32* @stdout
%7 = call i32 @fflush(i32 %6)
br label %8
8: ; preds = %3
br label %9
9: ; preds = %8
%10 = load i32, i32* @stdout
%11 = call i32 @fprintf(i32 %10, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0))
%12 = load i32, i32* @stdout
%13 = call i32 @fflush(i32 %12)
br label %14
14: ; preds = %9
%15 = call i64 @malloc(i32 8)
%16 = inttoptr i64 %15 to i8*
store i8* %16, i8** %1
store i32 0, i32* %2
br label %17
17: ; preds = %25, %14
%18 = load i32, i32* %2
%19 = icmp slt i32 %18, 16
br i1 %19, label %20, label %28
20: ; preds = %17
%21 = load i8*, i8** %1
%22 = load i32, i32* %2
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
store i8 122, i8* %24
br label %25
25: ; preds = %20
%26 = load i32, i32* %2
%27 = add nsw i32 %26, 1
store i32 %27, i32* %2
br label %17
28: ; preds = %17
%29 = load i8*, i8** %1
%30 = call i32 @free(i8* %29)
%31 = call i32 (...) @ofc_getCount()
%32 = icmp eq i32 %31, 8
%33 = zext i1 %32 to i32
%34 = call i32 @assert(i32 %33)
br label %35
35: ; preds = %28
%36 = load i32, i32* @stdout
%37 = call i32 @fprintf(i32 %36, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%38 = load i32, i32* @stdout
%39 = call i32 @fflush(i32 %38)
br label %40
40: ; preds = %35
br label %41
41: ; preds = %40
%42 = load i32, i32* @stdout
%43 = call i32 @fprintf(i32 %42, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0))
%44 = load i32, i32* @stdout
%45 = call i32 @fflush(i32 %44)
br label %46
46: ; preds = %41
%47 = call i64 @malloc(i32 1024)
%48 = inttoptr i64 %47 to i8*
store i8* %48, i8** %1
store i32 0, i32* %2
br label %49
49: ; preds = %57, %46
%50 = load i32, i32* %2
%51 = icmp slt i32 %50, 1032
br i1 %51, label %52, label %60
52: ; preds = %49
%53 = load i8*, i8** %1
%54 = load i32, i32* %2
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
store i8 122, i8* %56
br label %57
57: ; preds = %52
%58 = load i32, i32* %2
%59 = add nsw i32 %58, 1
store i32 %59, i32* %2
br label %49
60: ; preds = %49
%61 = load i8*, i8** %1
%62 = call i32 @free(i8* %61)
%63 = call i32 (...) @ofc_getCount()
%64 = icmp eq i32 %63, 8
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
br label %67
67: ; preds = %60
%68 = load i32, i32* @stdout
%69 = call i32 @fprintf(i32 %68, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%70 = load i32, i32* @stdout
%71 = call i32 @fflush(i32 %70)
br label %72
72: ; preds = %67
br label %73
73: ; preds = %72
%74 = load i32, i32* @stdout
%75 = call i32 @fprintf(i32 %74, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0))
%76 = load i32, i32* @stdout
%77 = call i32 @fflush(i32 %76)
br label %78
78: ; preds = %73
%79 = call i64 @malloc(i32 262144)
%80 = inttoptr i64 %79 to i8*
store i8* %80, i8** %1
store i32 0, i32* %2
br label %81
81: ; preds = %89, %78
%82 = load i32, i32* %2
%83 = icmp slt i32 %82, 262152
br i1 %83, label %84, label %92
84: ; preds = %81
%85 = load i8*, i8** %1
%86 = load i32, i32* %2
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %85, i64 %87
store i8 122, i8* %88
br label %89
89: ; preds = %84
%90 = load i32, i32* %2
%91 = add nsw i32 %90, 1
store i32 %91, i32* %2
br label %81
92: ; preds = %81
%93 = load i8*, i8** %1
%94 = call i32 @free(i8* %93)
%95 = call i32 (...) @ofc_getCount()
%96 = icmp eq i32 %95, 8
%97 = zext i1 %96 to i32
%98 = call i32 @assert(i32 %97)
br label %99
99: ; preds = %92
%100 = load i32, i32* @stdout
%101 = call i32 @fprintf(i32 %100, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%102 = load i32, i32* @stdout
%103 = call i32 @fflush(i32 %102)
br label %104
104: ; preds = %99
br label %105
105: ; preds = %104
%106 = load i32, i32* @stdout
%107 = call i32 @fprintf(i32 %106, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0))
%108 = load i32, i32* @stdout
%109 = call i32 @fflush(i32 %108)
br label %110
110: ; preds = %105
%111 = call i64 @malloc(i32 11)
%112 = inttoptr i64 %111 to i8*
store i8* %112, i8** %1
store i32 0, i32* %2
br label %113
113: ; preds = %121, %110
%114 = load i32, i32* %2
%115 = icmp slt i32 %114, 16
br i1 %115, label %116, label %124
116: ; preds = %113
%117 = load i8*, i8** %1
%118 = load i32, i32* %2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %117, i64 %119
store i8 122, i8* %120
br label %121
121: ; preds = %116
%122 = load i32, i32* %2
%123 = add nsw i32 %122, 1
store i32 %123, i32* %2
br label %113
124: ; preds = %113
%125 = load i8*, i8** %1
%126 = call i32 @free(i8* %125)
%127 = call i32 (...) @ofc_getCount()
%128 = icmp eq i32 %127, 5
%129 = zext i1 %128 to i32
%130 = call i32 @assert(i32 %129)
br label %131
131: ; preds = %124
%132 = load i32, i32* @stdout
%133 = call i32 @fprintf(i32 %132, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%134 = load i32, i32* @stdout
%135 = call i32 @fflush(i32 %134)
br label %136
136: ; preds = %131
br label %137
137: ; preds = %136
%138 = load i32, i32* @stdout
%139 = call i32 @fprintf(i32 %138, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.6, i64 0, i64 0))
%140 = load i32, i32* @stdout
%141 = call i32 @fflush(i32 %140)
br label %142
142: ; preds = %137
%143 = call i64 @malloc(i32 11)
%144 = inttoptr i64 %143 to i8*
store i8* %144, i8** %1
store i32 0, i32* %2
br label %145
145: ; preds = %153, %142
%146 = load i32, i32* %2
%147 = icmp slt i32 %146, 20
br i1 %147, label %148, label %156
148: ; preds = %145
%149 = load i8*, i8** %1
%150 = load i32, i32* %2
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %149, i64 %151
store i8 122, i8* %152
br label %153
153: ; preds = %148
%154 = load i32, i32* %2
%155 = add nsw i32 %154, 1
store i32 %155, i32* %2
br label %145
156: ; preds = %145
%157 = load i8*, i8** %1
%158 = call i32 @free(i8* %157)
%159 = call i32 (...) @ofc_getCount()
%160 = icmp eq i32 %159, 9
%161 = zext i1 %160 to i32
%162 = call i32 @assert(i32 %161)
br label %163
163: ; preds = %156
%164 = load i32, i32* @stdout
%165 = call i32 @fprintf(i32 %164, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%166 = load i32, i32* @stdout
%167 = call i32 @fflush(i32 %166)
br label %168
168: ; preds = %163
br label %169
169: ; preds = %168
%170 = load i32, i32* @stdout
%171 = call i32 @fprintf(i32 %170, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0))
%172 = load i32, i32* @stdout
%173 = call i32 @fflush(i32 %172)
br label %174
174: ; preds = %169
%175 = call i64 @malloc(i32 0)
%176 = inttoptr i64 %175 to i8*
store i8* %176, i8** %1
%177 = load i8*, i8** %1
%178 = icmp ne i8* %177, null
br i1 %178, label %179, label %192
179: ; preds = %174
store i32 0, i32* %2
br label %180
180: ; preds = %188, %179
%181 = load i32, i32* %2
%182 = icmp slt i32 %181, 8
br i1 %182, label %183, label %191
183: ; preds = %180
%184 = load i8*, i8** %1
%185 = load i32, i32* %2
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %184, i64 %186
store i8 122, i8* %187
br label %188
188: ; preds = %183
%189 = load i32, i32* %2
%190 = add nsw i32 %189, 1
store i32 %190, i32* %2
br label %180
191: ; preds = %180
br label %192
192: ; preds = %191, %174
%193 = load i8*, i8** %1
%194 = call i32 @free(i8* %193)
%195 = load i8*, i8** %1
%196 = icmp ne i8* %195, null
br i1 %196, label %197, label %202
197: ; preds = %192
%198 = call i32 (...) @ofc_getCount()
%199 = icmp eq i32 %198, 8
%200 = zext i1 %199 to i32
%201 = call i32 @assert(i32 %200)
br label %202
202: ; preds = %197, %192
br label %203
203: ; preds = %202
%204 = load i32, i32* @stdout
%205 = call i32 @fprintf(i32 %204, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%206 = load i32, i32* @stdout
%207 = call i32 @fflush(i32 %206)
br label %208
208: ; preds = %203
br label %209
209: ; preds = %208
%210 = load i32, i32* @stdout
%211 = call i32 @fprintf(i32 %210, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0))
%212 = load i32, i32* @stdout
%213 = call i32 @fflush(i32 %212)
br label %214
214: ; preds = %209
%215 = call i64 @malloc(i32 24)
%216 = inttoptr i64 %215 to i8*
store i8* %216, i8** %1
store i32 0, i32* %2
br label %217
217: ; preds = %225, %214
%218 = load i32, i32* %2
%219 = icmp slt i32 %218, 32
br i1 %219, label %220, label %228
220: ; preds = %217
%221 = load i8*, i8** %1
%222 = load i32, i32* %2
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %221, i64 %223
store i8 97, i8* %224
br label %225
225: ; preds = %220
%226 = load i32, i32* %2
%227 = add nsw i32 %226, 1
store i32 %227, i32* %2
br label %217
228: ; preds = %217
%229 = load i8*, i8** %1
%230 = call i32 @free(i8* %229)
%231 = call i32 (...) @ofc_getCount()
%232 = icmp eq i32 %231, 8
%233 = zext i1 %232 to i32
%234 = call i32 @assert(i32 %233)
br label %235
235: ; preds = %228
%236 = load i32, i32* @stdout
%237 = call i32 @fprintf(i32 %236, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%238 = load i32, i32* @stdout
%239 = call i32 @fflush(i32 %238)
br label %240
240: ; preds = %235
br label %241
241: ; preds = %240
%242 = load i32, i32* @stdout
%243 = call i32 @fprintf(i32 %242, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0))
%244 = load i32, i32* @stdout
%245 = call i32 @fflush(i32 %244)
br label %246
246: ; preds = %241
%247 = call i64 @malloc(i32 8)
%248 = inttoptr i64 %247 to i8*
store i8* %248, i8** %1
store i32 0, i32* %2
br label %249
249: ; preds = %257, %246
%250 = load i32, i32* %2
%251 = icmp slt i32 %250, 8
br i1 %251, label %252, label %260
252: ; preds = %249
%253 = load i8*, i8** %1
%254 = load i32, i32* %2
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i8, i8* %253, i64 %255
store i8 122, i8* %256
br label %257
257: ; preds = %252
%258 = load i32, i32* %2
%259 = add nsw i32 %258, 1
store i32 %259, i32* %2
br label %249
260: ; preds = %249
%261 = load i8*, i8** %1
%262 = call i32 @free(i8* %261)
%263 = call i32 (...) @ofc_getCount()
%264 = icmp eq i32 %263, 0
%265 = zext i1 %264 to i32
%266 = call i32 @assert(i32 %265)
br label %267
267: ; preds = %260
%268 = load i32, i32* @stdout
%269 = call i32 @fprintf(i32 %268, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%270 = load i32, i32* @stdout
%271 = call i32 @fflush(i32 %270)
br label %272
272: ; preds = %267
br label %273
273: ; preds = %272
%274 = load i32, i32* @stdout
%275 = call i32 @fprintf(i32 %274, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
%276 = load i32, i32* @stdout
%277 = call i32 @fflush(i32 %276)
br label %278
278: ; preds = %273
%279 = call i64 @malloc(i32 1024)
%280 = inttoptr i64 %279 to i8*
store i8* %280, i8** %1
store i32 0, i32* %2
br label %281
281: ; preds = %289, %278
%282 = load i32, i32* %2
%283 = icmp slt i32 %282, 1024
br i1 %283, label %284, label %292
284: ; preds = %281
%285 = load i8*, i8** %1
%286 = load i32, i32* %2
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i8, i8* %285, i64 %287
store i8 122, i8* %288
br label %289
289: ; preds = %284
%290 = load i32, i32* %2
%291 = add nsw i32 %290, 1
store i32 %291, i32* %2
br label %281
292: ; preds = %281
%293 = load i8*, i8** %1
%294 = call i32 @free(i8* %293)
%295 = call i32 (...) @ofc_getCount()
%296 = icmp eq i32 %295, 0
%297 = zext i1 %296 to i32
%298 = call i32 @assert(i32 %297)
br label %299
299: ; preds = %292
%300 = load i32, i32* @stdout
%301 = call i32 @fprintf(i32 %300, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%302 = load i32, i32* @stdout
%303 = call i32 @fflush(i32 %302)
br label %304
304: ; preds = %299
br label %305
305: ; preds = %304
%306 = load i32, i32* @stdout
%307 = call i32 @fprintf(i32 %306, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.11, i64 0, i64 0))
%308 = load i32, i32* @stdout
%309 = call i32 @fflush(i32 %308)
br label %310
310: ; preds = %305
%311 = call i64 @malloc(i32 262144)
%312 = inttoptr i64 %311 to i8*
store i8* %312, i8** %1
store i32 0, i32* %2
br label %313
313: ; preds = %321, %310
%314 = load i32, i32* %2
%315 = icmp slt i32 %314, 262144
br i1 %315, label %316, label %324
316: ; preds = %313
%317 = load i8*, i8** %1
%318 = load i32, i32* %2
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i8, i8* %317, i64 %319
store i8 122, i8* %320
br label %321
321: ; preds = %316
%322 = load i32, i32* %2
%323 = add nsw i32 %322, 1
store i32 %323, i32* %2
br label %313
324: ; preds = %313
%325 = load i8*, i8** %1
%326 = call i32 @free(i8* %325)
%327 = call i32 (...) @ofc_getCount()
%328 = icmp eq i32 %327, 0
%329 = zext i1 %328 to i32
%330 = call i32 @assert(i32 %329)
br label %331
331: ; preds = %324
%332 = load i32, i32* @stdout
%333 = call i32 @fprintf(i32 %332, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%334 = load i32, i32* @stdout
%335 = call i32 @fflush(i32 %334)
br label %336
336: ; preds = %331
ret void
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [18 x i8] c"#### malloc ####\0A\00"
@.str.1 = [22 x i8] c"[TEST] malloc_01 ...\0A\00"
@.str.2 = [8 x i8] c"passed\0A\00"
@.str.3 = [22 x i8] c"[TEST] malloc_02 ...\0A\00"
@.str.4 = [22 x i8] c"[TEST] malloc_03 ...\0A\00"
@.str.5 = [22 x i8] c"[TEST] malloc_04 ...\0A\00"
@.str.6 = [22 x i8] c"[TEST] malloc_05 ...\0A\00"
@.str.7 = [22 x i8] c"[TEST] malloc_06 ...\0A\00"
@.str.8 = [22 x i8] c"[TEST] malloc_07 ...\0A\00"
@.str.9 = [22 x i8] c"[TEST] malloc_08 ...\0A\00"
@.str.10 = [22 x i8] c"[TEST] malloc_09 ...\0A\00"
@.str.11 = [22 x i8] c"[TEST] malloc_10 ...\0A\00"
define void @test_malloc() {
%1 = load i32, i32* @stdout
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stdout
%4 = tail call i32 @fflush(i32 %3)
%5 = load i32, i32* @stdout
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0))
%7 = load i32, i32* @stdout
%8 = tail call i32 @fflush(i32 %7)
%9 = tail call i64 @malloc(i32 8)
%10 = inttoptr i64 %9 to i8*
%11 = tail call i32 @free(i8* %10)
%12 = tail call i32 (...) @ofc_getCount()
%13 = icmp eq i32 %12, 8
%14 = zext i1 %13 to i32
%15 = tail call i32 @assert(i32 %14)
%16 = load i32, i32* @stdout
%17 = tail call i32 @fprintf(i32 %16, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%18 = load i32, i32* @stdout
%19 = tail call i32 @fflush(i32 %18)
%20 = load i32, i32* @stdout
%21 = tail call i32 @fprintf(i32 %20, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0))
%22 = load i32, i32* @stdout
%23 = tail call i32 @fflush(i32 %22)
%24 = tail call i64 @malloc(i32 1024)
%25 = inttoptr i64 %24 to i8*
%26 = tail call i32 @free(i8* %25)
%27 = tail call i32 (...) @ofc_getCount()
%28 = icmp eq i32 %27, 8
%29 = zext i1 %28 to i32
%30 = tail call i32 @assert(i32 %29)
%31 = load i32, i32* @stdout
%32 = tail call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%33 = load i32, i32* @stdout
%34 = tail call i32 @fflush(i32 %33)
%35 = load i32, i32* @stdout
%36 = tail call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0))
%37 = load i32, i32* @stdout
%38 = tail call i32 @fflush(i32 %37)
%39 = tail call i64 @malloc(i32 262144)
%40 = inttoptr i64 %39 to i8*
%41 = tail call i32 @free(i8* %40)
%42 = tail call i32 (...) @ofc_getCount()
%43 = icmp eq i32 %42, 8
%44 = zext i1 %43 to i32
%45 = tail call i32 @assert(i32 %44)
%46 = load i32, i32* @stdout
%47 = tail call i32 @fprintf(i32 %46, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%48 = load i32, i32* @stdout
%49 = tail call i32 @fflush(i32 %48)
%50 = load i32, i32* @stdout
%51 = tail call i32 @fprintf(i32 %50, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0))
%52 = load i32, i32* @stdout
%53 = tail call i32 @fflush(i32 %52)
%54 = tail call i64 @malloc(i32 11)
%55 = inttoptr i64 %54 to i8*
%56 = tail call i32 @free(i8* %55)
%57 = tail call i32 (...) @ofc_getCount()
%58 = icmp eq i32 %57, 5
%59 = zext i1 %58 to i32
%60 = tail call i32 @assert(i32 %59)
%61 = load i32, i32* @stdout
%62 = tail call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%63 = load i32, i32* @stdout
%64 = tail call i32 @fflush(i32 %63)
%65 = load i32, i32* @stdout
%66 = tail call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.6, i64 0, i64 0))
%67 = load i32, i32* @stdout
%68 = tail call i32 @fflush(i32 %67)
%69 = tail call i64 @malloc(i32 11)
%70 = inttoptr i64 %69 to i8*
%71 = tail call i32 @free(i8* %70)
%72 = tail call i32 (...) @ofc_getCount()
%73 = icmp eq i32 %72, 9
%74 = zext i1 %73 to i32
%75 = tail call i32 @assert(i32 %74)
%76 = load i32, i32* @stdout
%77 = tail call i32 @fprintf(i32 %76, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%78 = load i32, i32* @stdout
%79 = tail call i32 @fflush(i32 %78)
%80 = load i32, i32* @stdout
%81 = tail call i32 @fprintf(i32 %80, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0))
%82 = load i32, i32* @stdout
%83 = tail call i32 @fflush(i32 %82)
%84 = tail call i64 @malloc(i32 0)
%85 = inttoptr i64 %84 to i8*
%86 = icmp eq i64 %84, 0
br i1 %86, label %94, label %87
87: ; preds = %0
%88 = inttoptr i64 %84 to i64*
store i64 8825501086245354106, i64* %88
%89 = tail call i32 @free(i8* %85)
%90 = tail call i32 (...) @ofc_getCount()
%91 = icmp eq i32 %90, 8
%92 = zext i1 %91 to i32
%93 = tail call i32 @assert(i32 %92)
br label %96
94: ; preds = %0
%95 = tail call i32 @free(i8* %85)
br label %96
96: ; preds = %94, %87
%97 = load i32, i32* @stdout
%98 = tail call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%99 = load i32, i32* @stdout
%100 = tail call i32 @fflush(i32 %99)
%101 = load i32, i32* @stdout
%102 = tail call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0))
%103 = load i32, i32* @stdout
%104 = tail call i32 @fflush(i32 %103)
%105 = tail call i64 @malloc(i32 24)
%106 = inttoptr i64 %105 to i8*
%107 = tail call i32 @free(i8* %106)
%108 = tail call i32 (...) @ofc_getCount()
%109 = icmp eq i32 %108, 8
%110 = zext i1 %109 to i32
%111 = tail call i32 @assert(i32 %110)
%112 = load i32, i32* @stdout
%113 = tail call i32 @fprintf(i32 %112, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%114 = load i32, i32* @stdout
%115 = tail call i32 @fflush(i32 %114)
%116 = load i32, i32* @stdout
%117 = tail call i32 @fprintf(i32 %116, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0))
%118 = load i32, i32* @stdout
%119 = tail call i32 @fflush(i32 %118)
%120 = tail call i64 @malloc(i32 8)
%121 = inttoptr i64 %120 to i8*
%122 = inttoptr i64 %120 to i64*
store i64 8825501086245354106, i64* %122
%123 = tail call i32 @free(i8* %121)
%124 = tail call i32 (...) @ofc_getCount()
%125 = icmp eq i32 %124, 0
%126 = zext i1 %125 to i32
%127 = tail call i32 @assert(i32 %126)
%128 = load i32, i32* @stdout
%129 = tail call i32 @fprintf(i32 %128, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%130 = load i32, i32* @stdout
%131 = tail call i32 @fflush(i32 %130)
%132 = load i32, i32* @stdout
%133 = tail call i32 @fprintf(i32 %132, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
%134 = load i32, i32* @stdout
%135 = tail call i32 @fflush(i32 %134)
%136 = tail call i64 @malloc(i32 1024)
%137 = inttoptr i64 %136 to i8*
%138 = tail call i32 @free(i8* %137)
%139 = tail call i32 (...) @ofc_getCount()
%140 = icmp eq i32 %139, 0
%141 = zext i1 %140 to i32
%142 = tail call i32 @assert(i32 %141)
%143 = load i32, i32* @stdout
%144 = tail call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%145 = load i32, i32* @stdout
%146 = tail call i32 @fflush(i32 %145)
%147 = load i32, i32* @stdout
%148 = tail call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.11, i64 0, i64 0))
%149 = load i32, i32* @stdout
%150 = tail call i32 @fflush(i32 %149)
%151 = tail call i64 @malloc(i32 262144)
%152 = inttoptr i64 %151 to i8*
%153 = tail call i32 @free(i8* %152)
%154 = tail call i32 (...) @ofc_getCount()
%155 = icmp eq i32 %154, 0
%156 = zext i1 %155 to i32
%157 = tail call i32 @assert(i32 %156)
%158 = load i32, i32* @stdout
%159 = tail call i32 @fprintf(i32 %158, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%160 = load i32, i32* @stdout
%161 = tail call i32 @fflush(i32 %160)
ret void
}