LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x34b0
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4a9b
movq -0x10(%rbp), %rdi
callq 0x4be0
movq %rax, -0x8(%rbp)
jmp 0x4bcb
callq 0x35c0
cltq
movq %rax, -0x18(%rbp)
cmpq $0x20, -0x10(%rbp)
ja 0x4aba
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x40, -0x10(%rbp)
ja 0x4ad1
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x80, -0x10(%rbp)
ja 0x4aec
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
ja 0x4b07
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x200, -0x10(%rbp)     # imm = 0x200
ja 0x4b22
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
ja 0x4b3d
movq -0x18(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
ja 0x4b55
movq -0x18(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
cmpq $0x1000, -0x10(%rbp)    # imm = 0x1000
ja 0x4b6d
movq -0x18(%rbp), %rax
shlq $0x7, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq $0x0, %rdx
je 0x4ba8
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4bcb
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, %rcx
movq -0x28(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_page_no_bonus
static size_t	get_page_no_bonus(const size_t size)
{
	size_t	i;

	i = getpagesize();
	if (size <= TINY && TINY == Z4)
		i *= 1;
	else if (size <= TINY)
		i *= TINY / 32;
	else if (size <= SMALL && SMALL == Z4)
		i *= 1;
	else if (size <= SMALL)
		i *= SMALL / 32;
	else if (size % i)
		i *= (size / i) + 1;
	else
		i *= (size / i);
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x35c0
cltq
movq %rax, -0x10(%rbp)
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
ja 0x4c1a
xorl %eax, %eax
testb $0x1, %al
jne 0x4c09
jmp 0x4c1a
movq -0x10(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x10(%rbp)
jmp 0x4cb7
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
ja 0x4c35
movq -0x10(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x4cb5
cmpq $0x400, -0x8(%rbp)      # imm = 0x400
ja 0x4c55
xorl %eax, %eax
testb $0x1, %al
jne 0x4c47
jmp 0x4c55
movq -0x10(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x10(%rbp)
jmp 0x4cb3
cmpq $0x400, -0x8(%rbp)      # imm = 0x400
ja 0x4c6d
movq -0x10(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x10(%rbp)
jmp 0x4cb1
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
cmpq $0x0, %rdx
je 0x4c9a
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
addq $0x1, %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4caf
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4cb1
jmp 0x4cb3
jmp 0x4cb5
jmp 0x4cb7
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xa6cd(%rip)      # 0xf3a8
jne 0x4d74
leaq 0x7600(%rip), %rdi      # 0xc2e8
callq 0x3030
cmpq $0x0, %rax
je 0x4d02
movl 0xa6af(%rip), %eax      # 0xf3a8
orl $0x2, %eax
movl %eax, 0xa6a6(%rip)      # 0xf3a8
leaq 0x75ec(%rip), %rdi      # 0xc2f5
callq 0x3030
cmpq $0x0, %rax
je 0x4d23
movl 0xa68e(%rip), %eax      # 0xf3a8
orl $0x4, %eax
movl %eax, 0xa685(%rip)      # 0xf3a8
leaq 0x75d7(%rip), %rdi      # 0xc301
callq 0x3030
cmpq $0x0, %rax
je 0x4d44
movl 0xa66d(%rip), %eax      # 0xf3a8
orl $0x10, %eax
movl %eax, 0xa664(%rip)      # 0xf3a8
leaq 0x75ca(%rip), %rdi      # 0xc315
callq 0x3030
cmpq $0x0, %rax
je 0x4d65
movl 0xa64c(%rip), %eax      # 0xf3a8
orl $0x20, %eax
movl %eax, 0xa643(%rip)      # 0xf3a8
movl 0xa63d(%rip), %eax      # 0xf3a8
orl $0x1, %eax
movl %eax, 0xa634(%rip)      # 0xf3a8
movl 0xa62e(%rip), %eax      # 0xf3a8
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x34b0
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4d9b
movl $0xffffffff, 0xa5cd(%rip) # imm = 0xFFFFFFFF
cmpl $-0x2, 0xa5c6(%rip)     # 0xf368
jne 0x4dbd
leaq 0x7578(%rip), %rdi      # 0xc323
movl $0x242, %esi            # imm = 0x242
movb $0x0, %al
callq 0x3510
movl %eax, 0xa5ab(%rip)      # 0xf368
movl 0xa5a5(%rip), %eax      # 0xf368
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x4df7
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4e25
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x4e15
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
shll $0x8, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x4e25
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
shll $0x7, %eax
cltq
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x9, %edi
leaq -0x30(%rbp), %rsi
callq 0x35f0
cmpl $0x0, %eax
je 0x4e6d
xorl %eax, %eax
movl %eax, %edi
movl $0x3, %esi
callq 0x31c0
movq $0x0, -0x8(%rbp)
jmp 0x4f0b
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x4e8f
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x31c0
movq $0x0, -0x8(%rbp)
jmp 0x4f0b
cmpl $0x0, -0x14(%rbp)
jne 0x4ebc
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x3190
movq %rax, -0x20(%rbp)
jmp 0x4ede
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
xorl %edx, %edx
movl $0x4022, %ecx           # imm = 0x4022
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x3190
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x4f03
xorl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x31c0
movq $0x0, -0x8(%rbp)
jmp 0x4f0b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x4f4f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5051
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x4f8c
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x4f8c
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movzbl 0x38(%rax,%rcx), %eax
andl $0xf0, %eax
sarl $0x4, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0x504f
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x4fb6
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movzbl 0x38(%rax,%rcx), %eax
andl $0xf, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0x504d
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x100, %eax            # imm = 0x100
jg 0x4fd7
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x38(%rax,%rcx), %eax
movq %rax, -0x18(%rbp)
jmp 0x504b
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x501b
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x38(%rax,%rcx), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
shrq %rdx
movzbl 0xb8(%rcx,%rdx), %ecx
andl $0xf0, %ecx
sarl $0x4, %ecx
addl %ecx, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0x5049
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x38(%rax,%rcx), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
shrq %rdx
movzbl 0xb8(%rcx,%rdx), %ecx
andl $0xf, %ecx
addl %ecx, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0x504b
jmp 0x504d
jmp 0x504f
jmp 0x5051
movq -0x18(%rbp), %rax
addq $0x1, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x507e
movq $0x20, -0x18(%rbp)
jmp 0x5086
movq $0x10, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x50f6
movq $0x0, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x50e8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl 0x18(%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x50da
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50fe
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x50a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x508e
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x5160
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x514f
movq -0x10(%rbp), %rax
movw $0x0, 0x4(%rax)
jmp 0x515b
movl $0x1, -0x4(%rbp)
jmp 0x5230
jmp 0x51f6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
movzbl 0x18(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
andq $0x7, %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x51eb
movq -0x20(%rbp), %rax
andq $0x7, %rax
movl %eax, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
movzbl 0x18(%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, 0x18(%rax,%rcx)
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %ecx
subl $0x1, %ecx
movw %cx, 0x4(%rax)
jmp 0x51f4
movl $0x1, -0x4(%rbp)
jmp 0x5230
jmp 0x51f6
callq 0x34b0
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5229
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3470
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movl $0xaa, %esi
callq 0x3260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5370
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0xf, -0x38(%rbp)
jae 0x535f
movq -0x20(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movzwl 0x30(%rax,%rcx,2), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x52ca
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x52ca
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5378
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movzwl 0x30(%rax,%rcx,2), %eax
cmpl $0x1001, %eax           # imm = 0x1001
je 0x534e
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movzwl 0x30(%rax,%rcx,2), %eax
cmpl $0x0, %eax
je 0x534e
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x534e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3360
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movq -0x40(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x534e
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzwl (%rcx), %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x534e
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5378
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5277
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5258
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x54b9
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
je 0x53d4
movq -0x8(%rbp), %rdi
callq 0x54d0
cmpl $0x1, %eax
jne 0x54b9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x5423
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0x34c0
movl %eax, -0x24(%rbp)
jmp 0x544c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edi
callq 0x31d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x34c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movw $0x0, 0x30(%rax,%rcx,2)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $0xffff, %edx           # imm = 0xFFFF
movq -0x10(%rbp), %rax
movzwl 0x4e(%rax), %ecx
andl %edx, %ecx
movw %cx, 0x4e(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
cmpl $-0x1, -0x24(%rbp)
jne 0x54a6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
callq 0x3480
jmp 0x54b7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3350
jmp 0x54b9
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_islast
static int			metabody_islast(t_metabody *body)
{
	t_metahead	*iter;
	size_t		i;
	size_t		j;

	j = 0;
	if (body->id == ZLARGE)
		return (0);
	iter = (t_metahead *)&(body->head);
	while (iter)
	{
		i = 0;
		while (i < AVAILABLE)
		{
			if ((iter->id)[i] == body->id)
				++j;
			if (j > 1)
				return (1);
			++i;
		}
		iter = iter->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x54f7
movl $0x0, -0x4(%rbp)
jmp 0x5570
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5569
movq $0x0, -0x20(%rbp)
cmpq $0xf, -0x20(%rbp)
jae 0x555b
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x30(%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x553d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jbe 0x554d
movl $0x1, -0x4(%rbp)
jmp 0x5570
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5512
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5503
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x9a4d(%rip), %rax      # 0xefe8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movzwl %ax, %esi
callq 0x3200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x55f4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x30(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x566d
movq 0x99ed(%rip), %rax      # 0xefe8
movq (%rax), %rdi
xorl %esi, %esi
leaq -0x30(%rbp), %rdx
callq 0x3200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5658
movq 0x99ce(%rip), %rdi      # 0xefe8
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5633
movq $0x0, -0x8(%rbp)
jmp 0x566d
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq -0x30(%rbp), %rdx
callq 0x3200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5656
movq $0x0, -0x8(%rbp)
jmp 0x566d
jmp 0x5658
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5680
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_set
static t_metabody	*metabody_set(t_metahead *head,
								const size_t size,
								const size_t index)
{
	t_metabody	*body;
	t_metadata	*data;
	size_t		requested;
	void		*elem;

	requested = get_page(size);
	if ((elem = mmap_malloc(requested, 0)) == NULL)
		return (NULL);
	data = (t_metadata *)(head->container);
	body = (t_metabody *)&((data->body)[index]);
	head->available_heap -= 1;
	body->head = head;
	body->index = index;
	body->address = elem;
	body->id = get_flag(size);
	(head->id)[index] = body->id;
	body->block_count = 0;
	log_metabody_set(body, head);
	return (body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x3560
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x56c3
movq $0x0, -0x8(%rbp)
jmp 0x5765
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x20(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x30d0
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movw (%rax), %dx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movw %dx, 0x30(%rax,%rcx,2)
movq -0x28(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3310
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5795
movzwl -0x12(%rbp), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x57a2
movq $0x0, -0x8(%rbp)
jmp 0x583e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5836
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5825
movq $0x0, -0x30(%rbp)
cmpq $0xf, -0x30(%rbp)
jae 0x5823
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movzwl 0x30(%rax,%rcx,2), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5815
movq -0x28(%rbp), %rax
movzwl 0x4e(%rax), %eax
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x5815
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x583e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x57c8
jmp 0x5825
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x57aa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0xf, 0x28(%rax)
jne 0x5948
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x5948
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x58c9
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x58e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
callq 0x34b0
andl $0x20, %eax
cmpl $0x0, %eax
je 0x58fc
movq -0x10(%rbp), %rdi
callq 0x5960
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x35c0
movq -0x40(%rbp), %rdi
movslq %eax, %rsi
callq 0x34c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x592e
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x3480
jmp 0x593f
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3650
movl $0x1, -0x4(%rbp)
jmp 0x594e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: guard_free
static void			guard_free(t_metahead *head)
{
	if (head->r_protect != NULL
	&& (munmap(head->r_protect, getpagesize())) == -1)
		log_free_failed(head->r_protect, ERR_FREE_MUNMAP);
	if (head->l_protect != NULL
	&& (munmap(head->l_protect, getpagesize())) == -1)
		log_free_failed(head->l_protect, ERR_FREE_MUNMAP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x59ab
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x35c0
movq -0x10(%rbp), %rdi
movslq %eax, %rsi
callq 0x34c0
cmpl $-0x1, %eax
jne 0x59ab
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x3480
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x59ea
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x35c0
movq -0x18(%rbp), %rdi
movslq %eax, %rsi
callq 0x34c0
cmpl $-0x1, %eax
jne 0x59ea
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x2, %esi
callq 0x3480
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x5aa0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5a15
movq $0x0, -0x8(%rbp)
jmp 0x5a87
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5a37
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a87
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5a64
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5a56
jmp 0x5a64
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5a42
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: metadata_set
static t_metadata	*metadata_set(void)
{
	t_metadata		*elem;
	t_metahead		*head;
	void			*temp;

	temp = NULL;
	if ((get_env() & ENV_GUARD) != 0)
		temp = mmap_malloc(getpagesize(), 1);
	if ((elem = (t_metadata *)mmap_malloc(getpagesize(), 0)) == NULL)
		return (NULL);
	head = &((elem->head).data);
	head->container = elem;
	head->available_heap = AVAILABLE;
	if ((get_env() & ENV_GUARD) != 0)
	{
		head->l_protect = temp;
		head->r_protect = mmap_malloc(getpagesize(), 1);
		log_metadata_set(elem, head->l_protect, head->r_protect);
	}
	else
		log_metadata_set(elem, 0, 0);
	return (elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x20(%rbp)
callq 0x34b0
andl $0x20, %eax
cmpl $0x0, %eax
je 0x5ad3
callq 0x35c0
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3560
movq %rax, -0x20(%rbp)
callq 0x35c0
movslq %eax, %rdi
xorl %esi, %esi
callq 0x3560
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x5af9
movq $0x0, -0x8(%rbp)
jmp 0x5b82
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0xf, 0x28(%rax)
callq 0x34b0
andl $0x20, %eax
cmpl $0x0, %eax
je 0x5b6a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x35c0
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3560
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x31b0
jmp 0x5b7a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x31b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x5bc1
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5bcb
movq $0x0, -0x8(%rbp)
jmp 0x5bfa
movq -0x28(%rbp), %rdi
callq 0x32c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5bf2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x3260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x93b1(%rip), %rdi      # 0xefd8
callq 0x3670
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3240
movq %rax, -0x18(%rbp)
movq 0x9394(%rip), %rdi      # 0xefd8
callq 0x33e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memalloc.c
// Function: ft_memalloc
void	*ft_memalloc(size_t size)
{
	void	*p;

	if (!(p = (void *)malloc(size)))
		return (NULL);
	ft_bzero(p, size);
	return (p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3690
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5cb9
movq $0x0, -0x8(%rbp)
jmp 0x5cce
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3130
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x8, -0x28(%rbp)
jb 0x5d64
movq -0x10(%rbp), %rax
andq $0x7, %rax
movq -0x18(%rbp), %rcx
andq $0x7, %rcx
cmpq %rcx, %rax
jne 0x5d64
movl -0x1c(%rbp), %eax
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rcx
movzbl %al, %edx
callq 0x5dd0
cmpl $0x0, %eax
je 0x5d4d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5dc4
movl -0x1c(%rbp), %eax
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rcx
movzbl %al, %edx
callq 0x5e60
jmp 0x5d66
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5dbc
movq -0x38(%rbp), %rax
movb (%rax), %al
movq -0x30(%rbp), %rcx
movb %al, (%rcx)
movzbl %al, %eax
movl -0x1c(%rbp), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5da2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5dc4
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5d66
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memccpy.c
// Function: align_address
static inline int	align_address(unsigned char **cs1,
						unsigned char **cs2,
						const unsigned char c, size_t *n)
{
	while ((uintptr_t)*cs1 & 0x7)
	{
		if ((**cs1 = **cs2) == c)
			return (1);
		++(*cs1);
		++(*cs2);
		--(*n);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x5e48
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb %al, (%rcx)
movzbl %al, %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e1c
movl $0x1, -0x4(%rbp)
jmp 0x5e4f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x5de5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memccpy.c
// Function: loopword
static inline void	loopword(unsigned char **cs1, unsigned char **cs2,
						const unsigned char c, size_t *n)
{
	uint64_t	*lls1;
	uint64_t	*lls2;
	uint64_t	one_each_byte;
	uint64_t	c_each_byte;
	uint64_t	zero_mask;

	lls1 = (uint64_t *)*cs1;
	lls2 = (uint64_t *)*cs2;
	one_each_byte = 0x0101010101010101L;
	c_each_byte = c | (c << 8);
	c_each_byte |= c_each_byte << 16;
	c_each_byte |= c_each_byte << 32;
	while (*n >= 8)
	{
		zero_mask = *lls2 ^ c_each_byte;
		if (((zero_mask - one_each_byte) & ~zero_mask) & (one_each_byte << 7))
			break ;
		*lls1++ = *lls2++;
		*n -= 8;
	}
	*cs1 = (unsigned char *)lls1;
	*cs2 = (unsigned char *)lls2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
movq %rax, -0x38(%rbp)
movzbl -0x11(%rbp), %eax
movzbl -0x11(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x10, %rax
orq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x20, %rax
orq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x8, (%rax)
jb 0x5f3f
movq -0x30(%rbp), %rax
movq (%rax), %rax
xorq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
subq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x7, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x5f0b
jmp 0x5f3f
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x28(%rbp)
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq $0x8, %rcx
movq %rcx, (%rax)
jmp 0x5ecc
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memcpy.c
// Function: ft_memcpy
void				*ft_memcpy(void *s1, const void *s2,
						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)))
		loopword(&cs1, &cs2, &n);
	while (n--)
		*cs1++ = *cs2++;
	return (s1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x8, -0x18(%rbp)
jb 0x5fb1
movq -0x8(%rbp), %rax
andq $0x7, %rax
movq -0x10(%rbp), %rcx
andq $0x7, %rcx
cmpq %rcx, %rax
jne 0x5fb1
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x6000
jmp 0x5fb3
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5fec
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x5fb3
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memcpy.c
// Function: loopword
static inline void	loopword(unsigned char **cs1,
						unsigned char **cs2,
						size_t *n)
{
	uint64_t	*lls1;
	uint64_t	*lls2;

	while ((uintptr_t)*cs1 & 0x7)
	{
		*((*cs1)++) = *((*cs2)++);
		--(*n);
	}
	lls1 = (uint64_t *)*cs1;
	lls2 = (uint64_t *)*cs2;
	while (*n >= 8)
	{
		*lls1++ = *lls2++;
		*n -= 8;
	}
	*cs1 = (unsigned char *)lls1;
	*cs2 = (unsigned char *)lls2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x6057
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x6010
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x8, (%rax)
jb 0x60ab
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq $0x8, %rcx
movq %rcx, (%rax)
jmp 0x606d
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memmove.c
// Function: ft_memmove
void				*ft_memmove(void *s1, const void *s2, size_t n)
{
	unsigned char		*cs1;
	const unsigned char	*cs2;

	if (s1 < s2)
		return (ft_memcpy(s1, s2, n));
	else if (!n || (s1 == s2))
		return (s1);
	cs1 = (unsigned char *)s1 + n - 1;
	cs2 = (const unsigned char *)s2 + n - 1;
	if ((n >= 15) && (((uintptr_t)s1 & 0x7) == ((uintptr_t)s2 & 0x7)))
		longword(&cs1, &cs2, &n);
	while (n--)
		*cs1-- = *cs2--;
	return (s1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6108
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3440
movq %rax, -0x8(%rbp)
jmp 0x61b8
cmpq $0x0, -0x20(%rbp)
je 0x6119
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x6126
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x61b8
jmp 0x6128
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0xf, -0x20(%rbp)
jb 0x6175
movq -0x10(%rbp), %rax
andq $0x7, %rax
movq -0x18(%rbp), %rcx
andq $0x7, %rcx
cmpq %rcx, %rax
jne 0x6175
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x61d0
jmp 0x6177
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x61b0
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x6177
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memmove.c
// Function: longword
static inline void	longword(unsigned char **cs1, const unsigned char **cs2,
						size_t *n)
{
	uint64_t		*lls1;
	const uint64_t	*lls2;

	while (((uintptr_t)*cs1 & 0x7))
	{
		*((*cs1)--) = *((*cs2)--);
		--(*n);
	}
	**cs1 = **cs2;
	lls1 = (uint64_t *)*cs1 - 1;
	lls2 = (const uint64_t *)*cs2 - 1;
	while (*n >= 8)
	{
		*lls1-- = *lls2--;
		*n -= 8;
	}
	if (*n)
	{
		*cs1 = (unsigned char *)lls1 - 1;
		*cs2 = (const unsigned char *)lls2 - 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x6227
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x61e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x8, (%rax)
jb 0x6295
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq $0x8, %rcx
movq %rcx, (%rax)
jmp 0x6257
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x62bd
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memset.c
// Function: ft_memset
void					*ft_memset(void *s, int c, size_t n)
{
	uint64_t		c_each_byte;
	uint64_t		*pll;
	unsigned char	*pc;

	pc = (unsigned char *)s;
	if (n >= 8)
	{
		while (((uintptr_t)pc & 0x7))
		{
			*pc++ = (unsigned char)c;
			--n;
		}
		c_each_byte = set_byte((unsigned char)c);
		pll = (uint64_t *)pc;
		while (n >= 8)
		{
			*pll++ = c_each_byte;
			n -= 8;
		}
		pc = (unsigned char *)pll;
	}
	while (n--)
		*pc++ = (unsigned char)c;
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x8, -0x18(%rbp)
jb 0x6360
jmp 0x62e4
movq -0x30(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x6316
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x62e4
movl -0xc(%rbp), %eax
movzbl %al, %edi
callq 0x63a0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x8, -0x18(%rbp)
jb 0x6358
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x28(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x632d
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6362
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x638f
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x6362
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)