LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: check_G_C_Count
int check_G_C_Count(char primer[],int length)
{
	int i,G,C;
	G=0;
	C=0;

	for(i=0;i<length;i++)
	{
		if(primer[i]=='G')
			G++;
		else if(primer[i]=='C')
			C++;
	}
	if(C>G)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x990a
movl %esi, %eax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movzbl (%rdi,%rsi), %r8d
cmpl $0x43, %r8d
je 0x98fe
cmpl $0x47, %r8d
jne 0x9900
incl %ecx
jmp 0x9900
incl %edx
incq %rsi
cmpq %rsi, %rax
jne 0x98e9
jmp 0x990e
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpl %ecx, %edx
setg %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: usage
void usage()
{
	printf("USAGE:\n");
	printf("  Single  -in <ref_genome>  -out <single_primers>  [options]*\n\n");
	printf("ARGUMENTS:\n");
	printf("  -in <ref_genome>\n");
	printf("    reference genome, fasta formate\n");
	printf("  -out <primer_probe>\n");
	printf("    output the candidate single primers and probes\n");
	printf("  -dir <directory>\n");
	printf("    the directory for output file\n");
	printf("    default: current directory\n");
        printf("  -NoExo\n");
	printf("    don't identifiy candidate exo probe\n");
	printf("    default:identifiy candidate exo probe\n");
	printf("  -NoCheck\n");
	printf("    don't check secondary structure of primers or probes\n");
	printf("    default: check secondary structure\n");
	printf("  -par <par_directory>\n");
	printf("    parameter files under the directory are used to check primers' secondary structure\n");
	printf("    default: GLAPD/Par/\n");
	printf("  -h[-help]\n");
	printf("    print usage\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1b42(%rip), %rdi      # 0xc518
callq 0x1080
leaq 0x1b3d(%rip), %rdi      # 0xc51f
callq 0x1080
leaq 0x1b70(%rip), %rdi      # 0xc55e
callq 0x1080
leaq 0x1b6f(%rip), %rdi      # 0xc569
callq 0x1080
leaq 0x1b76(%rip), %rdi      # 0xc57c
callq 0x1080
leaq 0x1b8e(%rip), %rdi      # 0xc5a0
callq 0x1080
leaq 0x1b98(%rip), %rdi      # 0xc5b6
callq 0x1080
leaq 0x1bbf(%rip), %rdi      # 0xc5e9
callq 0x1080
leaq 0x1bc6(%rip), %rdi      # 0xc5fc
callq 0x1080
leaq 0x1bdc(%rip), %rdi      # 0xc61e
callq 0x1080
leaq 0x1bef(%rip), %rdi      # 0xc63d
callq 0x1080
leaq 0x1bec(%rip), %rdi      # 0xc646
callq 0x1080
leaq 0x1c08(%rip), %rdi      # 0xc66e
callq 0x1080
leaq 0x1c26(%rip), %rdi      # 0xc698
callq 0x1080
leaq 0x1c25(%rip), %rdi      # 0xc6a3
callq 0x1080
leaq 0x1c52(%rip), %rdi      # 0xc6dc
callq 0x1080
leaq 0x1c6d(%rip), %rdi      # 0xc703
callq 0x1080
leaq 0x1c78(%rip), %rdi      # 0xc71a
callq 0x1080
leaq 0x1cc3(%rip), %rdi      # 0xc771
callq 0x1080
leaq 0x1ccf(%rip), %rdi      # 0xc789
callq 0x1080
leaq 0x1ccf(%rip), %rdi      # 0xc795
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: mono_malloc
void		*mono_malloc(size_t size)
{
	void		*ret;
	t_metabody	*body;

	if (size == 0)
		return (NULL);
	body = metabody_get(size);
	if (body == NULL)
		return (NULL);
	ret = malloc_ptr(body, size);
	if (ret == NULL)
		return (NULL);
	if ((get_env() & ENV_PRESCRIBBLE) != 0)
		(void)ft_memset(ret, 0xaa, size);
	log_malloc(body, ret, size);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x38d7
movq %rdi, %rbx
callq 0x32c0
testq %rax, %rax
je 0x38d7
movq %rax, %r14
cmpw $0x1001, (%rax)         # imm = 0x1001
jne 0x3813
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x391c
movl 0x4(%r14), %eax
incl %eax
movw %ax, 0x4(%r14)
xorl %ecx, %ecx
cmpw $0x10, (%r14)
sete %cl
shll $0x7, %ecx
subl $-0x80, %ecx
cmpw %cx, %ax
jne 0x380a
movb 0x2(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x10(%r14), %rcx
orw %ax, 0x4e(%rcx)
movq 0x8(%r14), %r15
jmp 0x38a9
movq %r14, %rdi
callq 0x36b0
cmpq $-0x1, %rax
je 0x38d7
movq %rax, %r15
addq $0x7, %rax
testq %r15, %r15
cmovnsq %r15, %rax
sarq $0x3, %rax
movzbl 0x18(%r14,%rax), %edx
leal (,%rax,8), %esi
movl %r15d, %ecx
subl %esi, %ecx
movl $0x1, %esi
shll %cl, %esi
btl %ecx, %edx
jb 0x385d
orb %dl, %sil
movb %sil, 0x18(%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x391c
movl 0x4(%r14), %ecx
incl %ecx
movw %cx, 0x4(%r14)
movzwl (%r14), %eax
xorl %edx, %edx
cmpq $0x10, %rax
sete %dl
shll $0x7, %edx
subl $-0x80, %edx
cmpw %dx, %cx
jne 0x38a1
movb 0x2(%r14), %cl
movl $0x1, %edx
shll %cl, %edx
movq 0x10(%r14), %rcx
orw %dx, 0x4e(%rcx)
imulq %rax, %r15
addq 0x8(%r14), %r15
testq %r15, %r15
je 0x38d7
callq 0x34c0
testb $0x10, %al
je 0x38c7
movq %r15, %rdi
movl $0xaa, %esi
movq %rbx, %rdx
callq 0x3280
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x35f0
jmp 0x38da
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: malloc
void		*malloc(size_t size)
{
	void	*ret;

	pthread_mutex_lock(&g_thread_mutex);
	ret = mono_malloc(size);
	pthread_mutex_unlock(&g_thread_mutex);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x76df(%rip), %r14      # 0xafd8
movq %r14, %rdi
callq 0x3680
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x33f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: malloc_set_size
static void	malloc_set_size(t_metabody *body, const size_t size, const size_t i)
{
	if (body->id == Z4)
	{
		(body->size)[i / 2] &= 0xf0 >> (4 * (i % 2));
		(body->size)[i / 2] |= (size - 1) << (4 * (i % 2));
	}
	else if (body->id <= Z8)
		(body->size)[i] = size - 1;
	else if (body->id <= ZMAX)
	{
		body->size[i] = (size - 1) >> 4;
		(body->store)[i / 2] &= 0xf0 >> (4 * (i % 2));
		(body->store)[i / 2] |= ((size - 1) & 0xf) << (4 * (i % 2));
	}
	else
	{
		*((size_t *)(body->size)) = size - 1;
		*((size_t *)(body->store)) = (size / getpagesize()) * getpagesize();
		if (size % getpagesize())
			*((size_t *)(body->store)) += getpagesize();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rdi), %eax
cmpw $0x10, %ax
jne 0x3952
leal (,%rdx,4), %ecx
andb $0x4, %cl
movb $-0x10, %al
shrb %cl, %al
shrq %rdx
decl %r14d
shlq %cl, %r14
andb 0x38(%rbx,%rdx), %al
orb %al, %r14b
jmp 0x3960
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
ja 0x396a
decb %r14b
movb %r14b, 0x38(%rbx,%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1(%r14), %rax
cmpl $0x1000, %ecx           # imm = 0x1000
ja 0x39ad
movl %eax, %esi
leal (,%rdx,4), %ecx
andb $0x4, %cl
movb $-0x10, %dil
shrb %cl, %dil
shrl $0x4, %esi
movb %sil, 0x38(%rbx,%rdx)
shrq %rdx
andl $0xf, %eax
shlq %cl, %rax
andb 0xb8(%rbx,%rdx), %dil
orb %dil, %al
movb %al, 0xb8(%rbx,%rdx)
jmp 0x3965
movq %rax, 0x38(%rbx)
callq 0x35d0
movslq %eax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0xb8(%rbx)
testq %rdx, %rdx
je 0x3965
addq %rcx, %r14
movq %r14, 0xb8(%rbx)
jmp 0x3965
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/free.c
// Function: mono_free
void		mono_free(void *ptr)
{
	t_metabody	*body;
	t_metahead	*head;

	if (ptr == NULL || g_metadata == NULL)
	{
		log_free_failed(ptr, ERR_FREE_INVALID);
		return ;
	}
	body = metabody_find(ptr, g_metadata);
	if (body == NULL)
	{
		log_free_failed(ptr, ERR_FREE_INVALID);
		return ;
	}
	if (metablock_free(body, ptr) == 1)
	{
		log_free_failed(ptr, ERR_FREE_DOUBLE);
		return ;
	}
	head = body->head;
	log_free(ptr, body->block_count);
	metabody_free(body);
	metadata_free(head, g_metadata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
movq 0x75f1(%rip), %r12      # 0xafe8
movq (%r12), %rsi
testq %rsi, %rsi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
je 0x3a32
movq %rbx, %rdi
callq 0x3670
testq %rax, %rax
je 0x3a32
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3390
cmpl $0x1, %eax
jne 0x3a44
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x3a37
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3490
movq 0x10(%r14), %r15
movzwl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x32d0
movq %r14, %rdi
callq 0x33b0
movq (%r12), %rsi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34f0
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/realloc.c
// Function: realloc
void			*realloc(void *ptr, size_t size)
{
	void	*ret;

	pthread_mutex_lock(&g_thread_mutex);
	ret = mono_realloc(ptr, size);
	pthread_mutex_unlock(&g_thread_mutex);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x7521(%rip), %rdi      # 0xafd8
callq 0x3680
testq %rbx, %rbx
je 0x3b34
testq %r14, %r14
je 0x3b41
movq 0x751b(%rip), %rax      # 0xafe8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3670
testq %rax, %rax
je 0x3b49
movq %rax, %r15
movzwl (%rax), %eax
cmpq $0x1001, %rax           # imm = 0x1001
jne 0x3b4d
movq 0xb8(%r15), %rbx
cmpq %r14, %rbx
jb 0x3b0d
callq 0x35d0
cltq
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r14, %rcx
jbe 0x3ba5
movq %r14, %rdi
callq 0x32e0
movq 0x8(%r15), %rsi
cmpq %r14, %rbx
cmovbq %rbx, %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x3450
movq %rax, %rbx
movq 0x8(%r15), %rdi
jmp 0x3b86
movq %r14, %rdi
callq 0x32e0
movq %rax, %rbx
jmp 0x3b8b
movq %rbx, %rdi
callq 0x3350
xorl %ebx, %ebx
jmp 0x3b8b
cmpq %r14, %rax
jb 0x3b65
shrl %eax
cmpq %r14, %rax
jae 0x3b65
movzwl 0x2(%r15), %eax
movb %r14b, 0x38(%r15,%rax)
jmp 0x3b8b
movq %r14, %rdi
callq 0x32e0
movzwl 0x2(%r15), %ecx
movzbl 0x38(%r15,%rcx), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3450
movq %rbx, %rdi
callq 0x3350
movq 0x7446(%rip), %rdi      # 0xafd8
callq 0x33f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movw %r14w, 0x4(%r15)
movq 0x8(%r15), %rbx
jmp 0x3b8b
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/show_alloc_mem.c
// Function: mono_show_alloc_mem
static void	mono_show_alloc_mem(int option)
{
	t_metahead	*iter;
	size_t		total;

	if (g_metadata == NULL)
		return ;
	total = 0;
	iter = (t_metahead *)&(g_metadata->head);
	while (iter)
	{
		total += print_metadata(iter, option);
		iter = iter->next;
	}
	ft_printf("Total: %zu bytes\n", total);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x73fa(%rip), %rax      # 0xafe8
movq (%rax), %r15
testq %r15, %r15
je 0x3c2c
movl %edi, %ebx
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebx, %esi
callq 0x3230
addq %rax, %r14
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x3bfb
leaq 0x43e8(%rip), %rdi      # 0x8000
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3560
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_dump
void		print_dump(void *address, size_t size)
{
	size_t	i;
	uint8_t	*ptr;

	if (size == 0 || address == NULL)
		return ;
	ptr = (uint8_t *)address;
	i = 0;
	while (i < size)
	{
		if (((i + 1) % 16) != 0)
			ft_printf("%02p ", ptr[i]);
		else
			ft_printf("%02p\n", ptr[i]);
		i++;
	}
	if (size % 16 != 0)
		ft_printf("\n");
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x3cee
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
movq %rsi, %r15
negq %r15
movl $0x1, %r12d
leaq 0x437c(%rip), %r13      # 0x8018
leaq 0x436f(%rip), %rbx      # 0x8012
testb $0xf, %r12b
movzbl -0x1(%r14,%r12), %esi
movq %rbx, %rdi
cmoveq %r13, %rdi
xorl %eax, %eax
callq 0x3560
leaq (%r15,%r12), %rax
incq %rax
incq %r12
cmpq $0x1, %rax
jne 0x3ca3
testb $0xf, -0x30(%rbp)
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
je 0x3cee
leaq 0x45f1(%rip), %rdi      # 0x82d8
xorl %eax, %eax
jmp 0x3560
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_large
size_t		print_large(t_metabody *body, int option)
{
	size_t		offset;
	uintptr_t	address;

	offset = *((size_t *)(body->size)) + 1;
	address = (uintptr_t)(body->address);
	ft_printf("%#p - %#p : %zu bytes\n", address, address + offset, offset);
	if (option != 0)
		print_dump((void *)address, offset);
	return (offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq 0x8(%rdi), %r14
movq 0x38(%rdi), %rbx
leaq (%rbx,%r14), %rdx
incq %rdx
incq %rbx
leaq 0x4309(%rip), %rdi      # 0x801e
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3560
testl %r15d, %r15d
je 0x3d32
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_allocation
size_t		print_allocation(t_metabody *body, size_t max, int option)
{
	size_t		i;
	size_t		ret;
	size_t		offset;
	uintptr_t	address;

	i = 0;
	ret = 0;
	while (i < max)
	{
		if (((body->free)[i / 8] & (1 << (i % 8))) != 0)
		{
			offset = metablock_get_size(body, i);
			address = (uintptr_t)(body->address) + i * body->id;
			ft_printf("%#p - %#p : %zu bytes\n", (void *)address, address + offset,
				offset);
			if (option != 0)
				print_dump((void *)address, offset);
			ret += offset;
		}
		i++;
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
testq %rsi, %rsi
je 0x3dcf
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r13, %rax
shrq $0x3, %rax
movzbl 0x18(%r15,%rax), %eax
movl %r13d, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x3dc4
movq %r15, %rdi
movq %r13, %rsi
callq 0x3480
movq %rax, %rbx
movzwl (%r15), %r14d
imulq %r13, %r14
addq 0x8(%r15), %r14
leaq (%r14,%rax), %rdx
leaq 0x427b(%rip), %rdi      # 0x801e
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x3560
cmpl $0x0, -0x2c(%rbp)
je 0x3dc1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32f0
addq %rbx, %r12
incq %r13
cmpq %r13, -0x38(%rbp)
jne 0x3d66
jmp 0x3dd2
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_zone
void		print_zone(t_metabody *body)
{
	uint16_t	flag;

	flag = get_flag(body->id);
	if ((get_env() & ENV_ZONE) == 0)
	{
		if (flag <= TINY)
			ft_printf("TINY : %#p\n", (uintptr_t)(body->address));
		else if (flag <= SMALL)
			ft_printf("SMALL : %#p\n", (uintptr_t)(body->address));
		else
			ft_printf("LARGE : %#p\n", (uintptr_t)(body->address));
	}
	else
	{
		if (flag != ZLARGE)
			ft_printf("Zone [ %d ] : %#p\n", body->id,
				(uintptr_t)(body->address));
		else
			ft_printf("LARGE : %#p\n", (uintptr_t)(body->address));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl (%rdi), %edi
callq 0x30e0
movl %eax, %r14d
callq 0x34c0
testb $0x2, %al
jne 0x3e1a
movzwl %r14w, %eax
cmpl $0x100, %eax            # imm = 0x100
ja 0x3e2b
movq 0x8(%rbx), %rsi
leaq 0x421d(%rip), %rdi      # 0x8035
jmp 0x3e46
movzwl %r14w, %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x3e51
movq 0x8(%rbx), %rsi
jmp 0x3e3f
movq 0x8(%rbx), %rsi
cmpl $0x400, %eax            # imm = 0x400
ja 0x3e3f
leaq 0x4204(%rip), %rdi      # 0x8041
jmp 0x3e46
leaq 0x4208(%rip), %rdi      # 0x804e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3560
movzwl (%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x41fc(%rip), %rdi      # 0x805b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3560
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_metadata
size_t		print_metadata(t_metahead *head, int option)
{
	t_metabody	*body;
	size_t		total;
	size_t		i;

	i = 0;
	total = 0;
	while (i < AVAILABLE)
	{
		body = (t_metabody *)&((((t_metadata *)(head->container))->body)[i]);
		if (body->id != 0)
		{
			print_zone(body);
			if (body->id == ZLARGE)
				total += print_large(body, option);
			else if (body->id == Z4)
				total += print_allocation(body, 256, option);
			else
				total += print_allocation(body, 128, option);

		}
		i++;
	}
	return (total);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %r13d           # imm = 0x100
xorl %r15d, %r15d
movq 0x10(%r14), %r12
cmpw $0x0, (%r12,%r13)
je 0x3ed3
addq %r13, %r12
movq %r12, %rdi
callq 0x3270
movzwl (%r12), %eax
cmpl $0x10, %eax
je 0x3eba
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x3ec1
movq %r12, %rdi
movl %ebx, %esi
callq 0x3620
jmp 0x3ed0
movl $0x100, %esi            # imm = 0x100
jmp 0x3ec6
movl $0x80, %esi
movq %r12, %rdi
movl %ebx, %edx
callq 0x33e0
addq %rax, %r15
addq $0x100, %r13            # imm = 0x100
cmpq $0x1000, %r13           # imm = 0x1000
jne 0x3e86
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log1.c
// Function: log_malloc
int			log_malloc(t_metabody *body, void *ptr, size_t size)
{
	int fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	ft_dprintf(fd, "[%p] Malloc %4zu: %p (N-%zu)\n", (void *)body,
				size, ptr, body->block_count);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x35e0
cmpl $-0x1, %eax
je 0x3f74
movzwl 0x4(%r12), %r9d
leaq 0x4127(%rip), %rsi      # 0x8084
xorl %r15d, %r15d
movl %eax, %edi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3420
jmp 0x3f7a
movl $0x1, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log1.c
// Function: log_mmap_failed
int			log_mmap_failed(size_t size, t_error error)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	if (error == ERR_RLIMIT)
		ft_dprintf(fd, "!!! - Cannot allocate: issue with rlimit\n");
	else if (error == ERR_MMAP)
		ft_dprintf(fd, "!!! - Cannot allocate: issue with mmap\n");
	else if (error == ERR_TOO_LARGE)
		ft_dprintf(fd, "! - Cannot allocate: %zu is too large\n", size);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
callq 0x35e0
cmpl $-0x1, %eax
je 0x405f
cmpl $0x5, %r15d
je 0x407a
cmpl $0x4, %r15d
je 0x4066
xorl %ebx, %ebx
cmpl $0x3, %r15d
jne 0x408f
leaq 0x40c0(%rip), %rsi      # 0x811d
jmp 0x406d
movl $0x1, %ebx
jmp 0x408f
leaq 0x40da(%rip), %rsi      # 0x8147
xorl %ebx, %ebx
movl %eax, %edi
xorl %eax, %eax
callq 0x3420
jmp 0x408f
leaq 0x40ee(%rip), %rsi      # 0x816f
xorl %ebx, %ebx
movl %eax, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3420
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metadata_set
int			log_metadata_set(t_metadata *data, void *l, void *r)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	if (l != NULL && r != NULL)
		ft_dprintf(fd, "\n>>> New metadata: (%p| [%p] |%p)\n\n",
			l, (void *)data, r);
	else if (l != NULL)
		ft_dprintf(fd, "\n>>> New metadata: (%p| [%p]\n\n", l, (void *)data);
	else if (r != NULL)
		ft_dprintf(fd, "\n>>> New metadata: [%p] |%p)\n\n", (void *)data, r);
	else
		ft_dprintf(fd, "\n>>> New metadata: [%p]\n\n", (void *)data);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x35e0
cmpl $-0x1, %eax
je 0x40e8
testq %r12, %r12
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
jne 0x40f0
leaq 0x40d3(%rip), %rsi      # 0x81a4
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3420
jmp 0x4127
movl $0x1, %r14d
jmp 0x4127
testq %r12, %r12
je 0x4109
leaq 0x40cc(%rip), %rsi      # 0x81c8
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
jmp 0x4120
testq %r15, %r15
je 0x4133
leaq 0x40d2(%rip), %rsi      # 0x81e7
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3420
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40cc(%rip), %rsi      # 0x8206
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3420
jmp 0x4127
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metabody_set
int			log_metabody_set(t_metabody *body, t_metahead *head)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	ft_dprintf(fd, "[%p] New metabody: %p -> %p (%zu left)\n", head->container,
		(void *)body, (void *)body->address, head->available_heap);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x35e0
cmpl $-0x1, %eax
je 0x4186
movq 0x8(%rbx), %r8
movq 0x10(%r14), %rdx
movq 0x28(%r14), %r9
leaq 0x40ab(%rip), %rsi      # 0x8220
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3420
jmp 0x418c
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metabody_free
int			log_metabody_free(t_metabody *body, void *ptr, t_metahead *head)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	ft_dprintf(fd, "[%p] Freed metabody: %p -> %p (%zu left)\n",
		head->container, (void *)body, ptr, head->available_heap);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x35e0
cmpl $-0x1, %eax
je 0x41d4
movq 0x10(%r15), %rdx
movq 0x28(%r15), %r9
leaq 0x4088(%rip), %rsi      # 0x8248
xorl %r15d, %r15d
movl %eax, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3420
jmp 0x41da
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metadata_free
int			log_metadata_free(t_metadata *data, void *l, void *r)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	if (l != NULL && r != NULL)
		ft_dprintf(fd, "\n>>> Freed metadata: (%p| [%p] |%p)\n\n",
			l, (void *)data, r);
	else if (l != NULL)
		ft_dprintf(fd, "\n>>> Freed metadata: (%p| [%p]\n\n", l, (void *)data);
	else if (r != NULL)
		ft_dprintf(fd, "\n>>> Freed metadata: [%p] |%p)\n\n", (void *)data, r);
	else
		ft_dprintf(fd, "\n>>> Freed metadata: [%p]\n\n", (void *)data);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x35e0
cmpl $-0x1, %eax
je 0x4234
testq %r12, %r12
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
jne 0x423c
leaq 0x4055(%rip), %rsi      # 0x8272
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3420
jmp 0x4273
movl $0x1, %r14d
jmp 0x4273
testq %r12, %r12
je 0x4255
leaq 0x4050(%rip), %rsi      # 0x8298
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
jmp 0x426c
testq %r15, %r15
je 0x427f
leaq 0x4058(%rip), %rsi      # 0x82b9
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3420
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4054(%rip), %rsi      # 0x82da
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3420
jmp 0x4273
nop
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_flag
uint16_t		get_flag(const size_t size)
{
	if (size == 0)
		return (0);
	if ((get_env() & ENV_ZONE) == 0)
		return (get_flag_no_bonus(size));
	if (size <= Z4)
		return (Z4);
	if (size <= Z5)
		return (Z5);
	if (size <= Z6)
		return (Z6);
	if (size <= Z7)
		return (Z7);
	if (size <= Z8)
		return (Z8);
	if (size <= Z9)
		return (Z9);
	if (size <= Z10)
		return (Z10);
	if (size <= Z11)
		return (Z11);
	if (size <= Z12)
		return (Z12);
	return (ZLARGE);
}

// Assembly:
testq %rdi, %rdi
je 0x4301
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x34c0
testb $0x2, %al
jne 0x4304
cmpq $0x401, %rbx            # imm = 0x401
movl $0x400, %eax            # imm = 0x400
movl $0x1001, %ecx           # imm = 0x1001
cmovbl %eax, %ecx
cmpq $0x101, %rbx            # imm = 0x101
movl $0x100, %eax            # imm = 0x100
cmovael %ecx, %eax
jmp 0x4372
xorl %eax, %eax
retq
movw $0x10, %ax
cmpq $0x11, %rbx
jb 0x4372
movw $0x20, %ax
cmpq $0x21, %rbx
jb 0x4372
movw $0x40, %ax
cmpq $0x41, %rbx
jb 0x4372
movw $0x80, %ax
cmpq $0x81, %rbx
jb 0x4372
movw $0x100, %ax             # imm = 0x100
cmpq $0x101, %rbx            # imm = 0x101
jb 0x4372
movw $0x200, %ax             # imm = 0x200
cmpq $0x201, %rbx            # imm = 0x201
jb 0x4372
movw $0x400, %ax             # imm = 0x400
cmpq $0x401, %rbx            # imm = 0x401
jb 0x4372
movw $0x800, %ax             # imm = 0x800
cmpq $0x801, %rbx            # imm = 0x801
jb 0x4372
cmpq $0x1001, %rbx           # imm = 0x1001
movw $0x1001, %ax            # imm = 0x1001
sbbw $0x0, %ax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_page
size_t			get_page(const size_t size)
{
	size_t	i;

	if ((get_env() & ENV_ZONE) == 0)
		return (get_page_no_bonus(size));
	i = getpagesize();
	if (size <= Z5)
		return (i);
	else if (size <= Z6)
		return (i * 2);
	else if (size <= Z7)
		return (i * 4);
	else if (size <= Z8)
		return (i * 8);
	else if (size <= Z9)
		return (i * 16);
	else if (size <= Z10)
		return (i * 32);
	else if (size <= Z11)
		return (i * 64);
	else if (size <= Z12)
		return (i * 128);
	else if (size % i)
		return (i * ((size / i) + 1));
	else
		return (i * (size / i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x34c0
movl %eax, %r14d
callq 0x35d0
movslq %eax, %rcx
testb $0x2, %r14b
jne 0x43a8
cmpq $0x100, %rbx            # imm = 0x100
ja 0x43b9
shlq $0x3, %rcx
jmp 0x43d5
cmpq $0x21, %rbx
jb 0x43d5
cmpq $0x40, %rbx
ja 0x43c8
addq %rcx, %rcx
jmp 0x43d5
cmpq $0x400, %rbx            # imm = 0x400
ja 0x43e0
shlq $0x5, %rcx
jmp 0x43d5
cmpq $0x80, %rbx
ja 0x4401
shlq $0x2, %rcx
movq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x43d8
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
incq %rbx
imulq %rcx, %rbx
jmp 0x43d8
cmpq $0x100, %rbx            # imm = 0x100
jbe 0x43a2
cmpq $0x200, %rbx            # imm = 0x200
ja 0x4419
shlq $0x4, %rcx
jmp 0x43d5
cmpq $0x400, %rbx            # imm = 0x400
jbe 0x43c2
cmpq $0x800, %rbx            # imm = 0x800
ja 0x4431
shlq $0x6, %rcx
jmp 0x43d5
cmpq $0x1000, %rbx           # imm = 0x1000
ja 0x4440
shlq $0x7, %rcx
jmp 0x43d5
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x43d8
incq %rax
imulq %rcx, %rax
movq %rax, %rbx
jmp 0x43d8
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get2_static.c
// Function: get_env
int	get_env(void)
{
	static int	flag = 0;

	if (flag == 0)
	{
		if (getenv(ENV_ZONE_TXT))
			flag |= ENV_ZONE;
		if (getenv(ENV_LOG_TXT))
			flag |= ENV_LOG;
		if (getenv(ENV_PRESCRIBBLE_TXT))
			flag |= ENV_PRESCRIBBLE;
		if (getenv(ENV_GUARD_TXT))
			flag |= ENV_GUARD;
		flag |= 1;
	}
	return (flag);
}

// Assembly:
movl 0x6f4e(%rip), %eax      # 0xb3b0
testl %eax, %eax
je 0x4467
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x3e82(%rip), %rdi      # 0x82f6
callq 0x3030
testq %rax, %rax
je 0x448f
movl $0x2, 0x6f28(%rip)      # 0xb3b0
movl $0x2, %ebx
jmp 0x4491
xorl %ebx, %ebx
leaq 0x3e6b(%rip), %rdi      # 0x8303
callq 0x3030
testq %rax, %rax
je 0x44ab
orl $0x4, %ebx
movl %ebx, 0x6f05(%rip)      # 0xb3b0
leaq 0x3e5d(%rip), %rdi      # 0x830f
callq 0x3030
testq %rax, %rax
je 0x44c5
orl $0x10, %ebx
movl %ebx, 0x6eeb(%rip)      # 0xb3b0
leaq 0x3e57(%rip), %rdi      # 0x8323
callq 0x3030
movq %rax, %rcx
leal 0x20(%rbx), %eax
testq %rcx, %rcx
cmovel %ebx, %eax
orl $0x1, %eax
movl %eax, 0x6eca(%rip)      # 0xb3b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get2_static.c
// Function: get_fd
int	get_fd(void)
{
	static int	fd = -2;

	if ((get_env() & ENV_LOG) == 0)
		fd = -1;
	if (fd == -2)
		fd = open("log_malloc.txt", O_CREAT | O_RDWR | O_TRUNC);
	return (fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x34c0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x4, %cl
je 0x4520
movl 0x6e68(%rip), %eax      # 0xb370
cmpl $-0x2, %eax
jne 0x4526
leaq 0x3e1d(%rip), %rdi      # 0x8331
movl $0x242, %esi            # imm = 0x242
xorl %eax, %eax
callq 0x3520
movl %eax, 0x6e4a(%rip)      # 0xb370
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get3_size.c
// Function: get_body_size
size_t	get_body_size(t_metabody *body)
{
	if (body->id == ZLARGE)
		return (*((size_t *)(body->store)));
	else if (body->id == Z4)
		return (body->id * 256);
	else
		return (body->id * 128);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl (%rdi), %eax
cmpl $0x10, %eax
je 0x4544
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x454b
movq 0xb8(%rdi), %rax
jmp 0x454e
movl $0x1000, %eax           # imm = 0x1000
jmp 0x454e
shll $0x7, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/mmap.c
// Function: mmap_malloc
void		*mmap_malloc(const size_t requested, int bonus)
{
	void			*ret;
	struct rlimit	limit;

	if (getrlimit(RLIMIT_AS, &limit) != 0)
	{
		log_mmap_failed(0, ERR_RLIMIT);
		return (NULL);
	}
	if (requested > limit.rlim_cur)
	{
		log_mmap_failed(requested, ERR_TOO_LARGE);
		return (NULL);
	}
	if (bonus == 0)
		ret = mmap(NULL, requested, PROT_READ | PROT_WRITE,
				MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	else
		ret = mmap(NULL, requested, PROT_NONE,
				MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
	if (ret == MAP_FAILED)
	{
		log_mmap_failed(0, ERR_MMAP);
		return (NULL);
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x20(%rbp), %rsi
movl $0x9, %edi
callq 0x3600
testl %eax, %eax
je 0x4583
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x3, %esi
callq 0x31d0
jmp 0x45ce
cmpq %rbx, -0x20(%rbp)
jae 0x459a
movq %rbx, %rdi
movl $0x5, %esi
callq 0x31d0
xorl %ebx, %ebx
jmp 0x45ce
xorl %edi, %edi
movq %rbx, %rsi
testl %r14d, %r14d
je 0x45ad
xorl %edx, %edx
movl $0x4022, %ecx           # imm = 0x4022
jmp 0x45b7
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x31a0
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x45da
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x4, %esi
jmp 0x457c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metablock.c
// Function: metablock_get_size
size_t	metablock_get_size(t_metabody *body, const size_t i)
{
	size_t	size;

	if (body->id == ZLARGE)
		size = *((size_t *)(body->size)) + 1;
	else if (body->id == Z4 && i % 2)
		size = ((body->size)[i / 2] & 0xf0) >> 4;
	else if (body->id == Z4)
		size = (body->size)[i / 2] & 0xf;
	else if (body->id <= Z8)
		size = (body->size)[i];
	else if (i % 2)
		size = ((body->size)[i] << 4) + (((body->store)[i / 2] & 0xf0) >> 4);
	else
		size = ((body->size)[i] << 4) + ((body->store)[i / 2] & 0xf);
	return (size + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl (%rdi), %eax
cmpl $0x10, %eax
je 0x4604
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x461a
movq 0x38(%rdi), %rax
incq %rax
jmp 0x4657
movq %rsi, %rax
shrq %rax
movzbl 0x38(%rdi,%rax), %eax
testb $0x1, %sil
jne 0x462b
andl $0xf, %eax
jmp 0x4657
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
ja 0x4630
movzbl 0x38(%rdi,%rsi), %eax
jmp 0x4657
shrl $0x4, %eax
jmp 0x4657
movzbl 0x38(%rdi,%rsi), %eax
shll $0x4, %eax
movq %rsi, %rcx
shrq %rcx
movzbl 0xb8(%rdi,%rcx), %ecx
testb $0x1, %sil
jne 0x4651
andl $0xf, %ecx
jmp 0x4654
shrl $0x4, %ecx
orq %rcx, %rax
incq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metablock.c
// Function: metablock_get_available_index
ssize_t	metablock_get_available_index(t_metabody *body)
{
	size_t	max;
	size_t	i;
	size_t	j;

	if (body->id == Z4)
		max = MAX_Z4;
	else
		max = MAX_OTHER;
	i = 0;
	while (i < max)
	{
		j = 0;
		while (j < 8)
		{
			if (((body->free)[i] & (1 << j)) == 0)
				return (i * 8 + j);
			j++;
		}
		i++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
cmpw $0x10, (%rdi)
sete %cl
shll $0x4, %ecx
addq $0x10, %rcx
xorl %edx, %edx
xorl %esi, %esi
movzbl 0x18(%rdi,%rsi), %r8d
xorl %eax, %eax
btl %eax, %r8d
jae 0x46a0
incq %rax
cmpq $0x8, %rax
jne 0x467c
incq %rsi
addq $-0x8, %rdx
cmpq %rcx, %rsi
jne 0x4674
movq $-0x1, %rax
jmp 0x46a3
subq %rdx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metablock.c
// Function: metablock_free
int		metablock_free(t_metabody *body, void *ptr)
{
	size_t	index;

	index = 0;
	if (body->id == ZLARGE)
	{
		if (body->block_count != 0)
			body->block_count = 0;
		else
			return (1);
	}
	else
	{
		index = (uintptr_t)ptr - (uintptr_t)(body->address);
		index /= (uintptr_t)(body->id);
		if ((body->free)[index / 8] & (1 << (index % 8)))
		{
			(body->free)[index / 8] ^= (1 << (index % 8));
			body->block_count -= 1;
		}
		else
			return (1);
	}
	if ((get_env() & ENV_SCRIBBLE) != 0)
		(void)ft_memset(ptr, 0xaa, metablock_get_size(body, index));
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl (%rdi), %ecx
cmpq $0x1001, %rcx           # imm = 0x1001
jne 0x46d6
cmpw $0x0, 0x4(%r14)
je 0x4743
movw $0x0, 0x4(%r14)
xorl %r15d, %r15d
jmp 0x471a
movq %rbx, %rax
subq 0x8(%r14), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
shrq $0x3, %rax
movzbl 0x18(%r14,%rax), %edx
movl %r15d, %ecx
andb $0x7, %cl
movl $0x1, %esi
shll %cl, %esi
movl $0x1, %r12d
movl %r15d, %ecx
andl $0x7, %ecx
btl %ecx, %edx
jae 0x4749
xorb %dl, %sil
movb %sil, 0x18(%r14,%rax)
decw 0x4(%r14)
callq 0x34c0
xorl %r12d, %r12d
testb $0x8, %al
je 0x4749
movq %r14, %rdi
movq %r15, %rsi
callq 0x3480
movq %rbx, %rdi
movl $0xaa, %esi
movq %rax, %rdx
callq 0x3280
jmp 0x4749
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_find
t_metabody			*metabody_find(const void *ptr, t_metadata *start)
{
	t_metadata	*data;
	t_metahead	*head;
	t_metabody	*body;
	size_t		i;

	head = (t_metahead *)&(start->head);
	while (head)
	{
		i = 0;
		data = (t_metadata *)(head->container);
		while (i < AVAILABLE)
		{
			body = (t_metabody *)&((data->body)[i]);
			if ((head->id)[i] == ZLARGE && ptr == body->address)
				return (body);
			if ((head->id)[i] != ZLARGE && (head->id)[i] != 0
			&& ptr >= body->address
			&& (uintptr_t)ptr < (uintptr_t)(body->address) + get_body_size(body)
			&& ((uintptr_t)ptr % body->id) == 0)
				return (body);
			i++;
		}
		head = head->next;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x47dc
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rbx), %r15
movl $0x100, %eax            # imm = 0x100
addq %rax, %r15
xorl %r13d, %r13d
movzwl 0x30(%rbx,%r13,2), %eax
testl %eax, %eax
je 0x47c3
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x4799
cmpq %r14, 0x8(%r15)
jne 0x47c3
jmp 0x47df
movq 0x8(%r15), %r12
cmpq %r14, %r12
ja 0x47c3
movq %r15, %rdi
callq 0x3370
addq %r12, %rax
cmpq %r14, %rax
jbe 0x47c3
movzwl (%r15), %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x47df
incq %r13
addq $0x100, %r15            # imm = 0x100
cmpq $0xf, %r13
jne 0x4780
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x4771
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_free
int					metabody_free(t_metabody *body)
{
	t_metahead	*head;
	void		*mem;
	size_t		index;
	int			ret;

	ret = 0;
	if (body->block_count == 0
	&& (body->id == ZLARGE || metabody_islast(body) == 1))
	{
		head = body->head;
		index = body->index;
		mem = body->address;
		if (body->id == ZLARGE)
			ret = munmap(body->address, *((size_t *)(body->store)));
		else
			ret = munmap(body->address, get_page(body->id));
		(head->id)[index] = 0;
		(head->full) &= (MASK_AVAILABLE ^ (1 << index));
		head->available_heap += 1;
		if (ret == -1)
			log_free_failed(body->address, ERR_FREE_MUNMAP);
		else
			log_metabody_free(body, mem, head);
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
cmpw $0x0, 0x4(%rdi)
jne 0x48e5
movq %rdi, %rbx
movzwl (%rdi), %edi
cmpq $0x1001, %rdi           # imm = 0x1001
jne 0x483d
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %r14
movzwl 0x2(%rbx), %r13d
movq 0x10(%rbx), %r12
movq 0xb8(%rbx), %rsi
movq %r14, %rdi
jmp 0x4892
leaq 0x10(%rbx), %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %edx, %edx
movq %rcx, %rsi
xorl %ecx, %ecx
cmpw %di, 0x30(%rax,%rdx,2)
sete %cl
addq %rsi, %rcx
cmpq $0x1, %rcx
ja 0x4872
incq %rdx
cmpq $0xf, %rdx
jne 0x4848
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x4846
jmp 0x48e5
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %r14
movzwl 0x2(%rbx), %r13d
movq 0x10(%rbx), %r12
callq 0x31e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x34d0
movl %eax, %r15d
movzwl %r13w, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
movw $0x0, 0x30(%r12,%rcx,2)
andw %ax, 0x4e(%r12)
incq 0x28(%r12)
cmpl $-0x1, %r15d
je 0x48ce
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3360
jmp 0x48e5
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x3490
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_get
t_metabody			*metabody_get(const size_t size)
{
	t_metadata	*data;
	t_metahead	*head;
	t_metabody	*body;
	size_t		index;

	index = 0;
	if ((head = metadata_find(g_metadata, get_flag(size), &index)))
	{
		data = (t_metadata *)(head->container);
		body = (t_metabody *)&((data->body)[index]);
		return (body);
	}
	if (!(head = metadata_find(g_metadata, 0, &index)))
	{
		if (!(data = metadata_add(&g_metadata)))
			return (NULL);
		if (!(head = metadata_find(data, 0, &index)))
			return (NULL);
	}
	return (metabody_set(head, size, index));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq $0x0, (%r14)
movq 0x66cd(%rip), %r12      # 0xafe8
movq (%r12), %r15
callq 0x30e0
movzwl %ax, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3210
testq %rax, %rax
je 0x4953
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x8, %rcx
leaq (%rax,%rcx), %r14
addq $0x100, %r14            # imm = 0x100
jmp 0x4a00
movq (%r12), %rdi
leaq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x3210
testq %rax, %rax
je 0x49d5
movq %rax, %r15
movq -0x28(%rbp), %r12
movq %rbx, %rdi
callq 0x31e0
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3570
testq %rax, %rax
je 0x4a00
movq 0x10(%r15), %rcx
movq %r12, %rdx
shlq $0x8, %rdx
decq 0x28(%r15)
leaq (%rcx,%rdx), %r14
addq $0x100, %r14            # imm = 0x100
movq %r15, 0x10(%r14)
movw %r12w, 0x2(%r14)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x30e0
movw %ax, (%r14)
movw %ax, 0x30(%r15,%r12,2)
movw $0x0, 0x4(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3320
jmp 0x4a00
movq 0x660c(%rip), %rdi      # 0xafe8
callq 0x3160
xorl %r14d, %r14d
testq %rax, %rax
je 0x4a00
leaq -0x28(%rbp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3210
testq %rax, %rax
jne 0x4967
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: metadata_find
t_metahead			*metadata_find(const t_metadata *start,
									const uint16_t flag,
									size_t *index)
{
	t_metahead	*iter;
	size_t		i;

	if (start == NULL || flag == ZLARGE)
		return (NULL);
	iter = (t_metahead *)&(start->head);
	while (iter)
	{
		if (iter->available_heap)
		{
			i = 0;
			while (i < AVAILABLE)
			{
				if ((iter->id)[i] == flag && ((iter->full) & (1 << i)) == 0)
				{
					*index = i;
					return (iter);
				}
				++i;
			}
		}
		iter = iter->next;
	}
	return (NULL);
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
sete %cl
cmpl $0x1001, %esi           # imm = 0x1001
sete %dil
orb %cl, %dil
je 0x4a2b
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x28(%rax)
je 0x4a51
xorl %ecx, %ecx
cmpw %si, 0x30(%rax,%rcx,2)
jne 0x4a48
movzwl 0x4e(%rax), %edi
btl %ecx, %edi
jae 0x4a5e
incq %rcx
cmpq $0xf, %rcx
jne 0x4a38
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x4a2f
xorl %eax, %eax
jmp 0x4a61
movq %rcx, (%rdx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: metadata_free
int					metadata_free(t_metahead *head, t_metadata *start)
{
	void	*ptr;
	int		ret;
	void	*l;
	void	*r;

	ret = 0;
	if (head->available_heap == AVAILABLE && head->container != (void *)start)
	{
		ptr = head->container;
		l = head->l_protect;
		r = head->r_protect;
		if (head->next)
			head->next->prev = head->prev;
		if (head->prev)
			head->prev->next = head->next;
		if ((get_env() & ENV_GUARD) != 0)
			guard_free(head);
		ret = munmap(ptr, getpagesize());
		if (ret == -1)
			log_free_failed(ptr, ERR_FREE_MUNMAP);
		else
			log_metadata_free((t_metadata *)ptr, l, r);
		return (1);
	}
	return (ret);
}

// Assembly:
xorl %eax, %eax
cmpq $0xf, 0x28(%rdi)
jne 0x4b59
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq 0x10(%rdi), %rbx
cmpq %rsi, %rbx
je 0x4b4b
movq 0x20(%r12), %r14
movq 0x18(%r12), %r15
movq (%r12), %rax
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0x4aa9
movq %rax, (%rcx)
testq %rax, %rax
je 0x4ab2
movq %rcx, 0x8(%rax)
callq 0x34c0
testb $0x20, %al
je 0x4b17
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x4ae9
callq 0x35d0
movslq %eax, %rsi
movq %r13, %rdi
callq 0x34d0
cmpl $-0x1, %eax
jne 0x4ae9
movq 0x18(%r12), %rdi
movl $0x2, %esi
callq 0x3490
movq 0x20(%r12), %r13
testq %r13, %r13
je 0x4b17
callq 0x35d0
movslq %eax, %rsi
movq %r13, %rdi
callq 0x34d0
cmpl $-0x1, %eax
jne 0x4b17
movq 0x20(%r12), %rdi
movl $0x2, %esi
callq 0x3490
callq 0x35d0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x34d0
movq %rbx, %rdi
cmpl $-0x1, %eax
je 0x4b3c
movq %r14, %rsi
movq %r15, %rdx
callq 0x3660
jmp 0x4b46
movl $0x2, %esi
callq 0x3490
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: metadata_add
t_metadata			*metadata_add(t_metadata **start)
{
	t_metadata	*data;
	t_metahead	*head;

	if (!(data = metadata_set()))
		return (NULL);
	if (!*start)
	{
		*start = data;
		return (*start);
	}
	head = &(((*start)->head).data);
	while (head)
	{
		if (head->next == NULL)
			break ;
		head = head->next;
	}
	head->next = (t_metahead *)&(data->head);
	head->next->prev = head;
	return (data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x34c0
movl %eax, %r14d
callq 0x35d0
movslq %eax, %r15
testb $0x20, %r14b
jne 0x4b83
xorl %r12d, %r12d
jmp 0x4b93
movq %r15, %rdi
movl $0x1, %esi
callq 0x3570
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x3570
movq %rax, %r14
testq %rax, %rax
je 0x4c07
movq %r14, 0x10(%r14)
movq $0xf, 0x28(%r14)
callq 0x34c0
testb $0x20, %al
jne 0x4bc3
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x4be2
movq %r12, 0x20(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3570
movq %rax, 0x18(%r14)
movq 0x20(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x31c0
movq (%rbx), %rax
testq %rax, %rax
je 0x4c04
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x4bef
movq %r14, 0x8(%rcx)
movq %rcx, (%r14)
jmp 0x4c07
movq %r14, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/calloc.c
// Function: mono_calloc
void		*mono_calloc(size_t count, size_t size)
{
	void		*ret;
	size_t		res;

	res = count * size;
	if (res < count || res < size)
		return (NULL);
	ret = mono_malloc(res);
	if (ret)
		ret = ft_memset(ret, 0, res);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
imulq %rdi, %rbx
cmpq %rdi, %rbx
setb %al
cmpq %rsi, %rbx
setb %cl
orb %al, %cl
jne 0x4c51
movq %rbx, %rdi
callq 0x32e0
testq %rax, %rax
je 0x4c51
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3280
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/srcs/calloc.c
// Function: calloc
void		*calloc(size_t count, size_t size)
{
	void	*ret;

	pthread_mutex_lock(&g_thread_mutex);
	ret = mono_calloc(count, size);
	pthread_mutex_unlock(&g_thread_mutex);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x6367(%rip), %r15      # 0xafd8
movq %r15, %rdi
callq 0x3680
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3260
movq %rax, %rbx
movq %r15, %rdi
callq 0x33f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memccpy.c
// Function: ft_memccpy
void				*ft_memccpy(void *s1, const void *s2, int c, size_t n)
{
	unsigned char	*cs1;
	unsigned char	*cs2;

	cs1 = (unsigned char *)s1;
	cs2 = (unsigned char *)s2;
	if ((n >= 8) && (((uintptr_t)s1 & 0x7) == ((uintptr_t)s2 & 0x7)))
	{
		if (align_address(&cs1, &cs2, (unsigned char)c, &n))
			return (cs1 + 1);
		loopword(&cs1, &cs2, (const unsigned char)c, &n);
	}
	while (n--)
	{
		if ((*cs1 = *cs2) == (unsigned char)c)
			return (cs1 + 1);
		++cs1;
		++cs2;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
cmpq $0x8, %rcx
jb 0x4d85
movl %esi, %eax
xorl %edi, %eax
testb $0x7, %al
jne 0x4d8a
testb $0x7, %dil
je 0x4d36
leaq 0x1(%rdi), %r8
xorl %r9d, %r9d
xorl %eax, %eax
movb (%rsi,%r9), %r10b
movb %r10b, (%rdi,%r9)
cmpb %dl, %r10b
je 0x4db3
leal (%r8,%r9), %r10d
decq %rax
incq %r9
testb $0x7, %r10b
jne 0x4d06
addq %rax, %rcx
subq %rax, %rdi
subq %rax, %rsi
cmpq $0x8, %rcx
jb 0x4d85
movabsq $-0x7f7f7f7f7f7f7f80, %rax # imm = 0x8080808080808080
movabsq $0x101010101010100, %r8 # imm = 0x101010101010100
movzbl %dl, %r10d
leaq 0x1(%r8), %r9
imulq %r10, %r9
movq (%rsi), %r10
movq %r10, %r11
xorq %r9, %r11
movq %r8, %rbx
subq %r11, %rbx
orq %r11, %rbx
notq %rbx
testq %rbx, %rax
jne 0x4d8a
addq $0x8, %rsi
movq %r10, (%rdi)
addq $0x8, %rdi
addq $-0x8, %rcx
cmpq $0x7, %rcx
ja 0x4d56
testq %rcx, %rcx
je 0x4daf
xorl %eax, %eax
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
movb %r9b, (%rdi,%r8)
cmpb %dl, %r9b
je 0x4da6
incq %r8
cmpq %r8, %rcx
jne 0x4d8f
jmp 0x4dbc
leaq (%rdi,%r8), %rax
incq %rax
jmp 0x4dbc
xorl %eax, %eax
jmp 0x4dbc
subq %rax, %rdi
incq %rdi
movq %rdi, %rax
popq %rbx
popq %rbp
retq
nop