LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_get_rand32
uint32_t
cf_get_rand32(void)
{
	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < sizeof(uint64_t) ) {
		if (cf_rand_reload() == -1) {
			pthread_mutex_unlock(&rand_buf_lock);
			return 0;
		}
	}

	rand_buf_off -= sizeof(uint64_t);

	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);

	pthread_mutex_unlock(&rand_buf_lock);

	return (uint32_t)r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb051(%rip), %rdi      # 0x31800
callq 0x8c60
movl 0xb06e(%rip), %eax      # 0x31828
cmpq $0x8, %rax
jae 0x267e1
callq 0x265a0
cmpl $-0x1, %eax
jne 0x267df
leaq 0xb02f(%rip), %rdi      # 0x31800
callq 0x8740
movl $0x0, -0x4(%rbp)
jmp 0x2681b
jmp 0x267e1
movl 0xb041(%rip), %eax      # 0x31828
subq $0x8, %rax
movl %eax, 0xb037(%rip)      # 0x31828
movl 0xb031(%rip), %eax      # 0x31828
movl %eax, %ecx
leaq 0xb030(%rip), %rax      # 0x31830
movq (%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
leaq 0xaff1(%rip), %rdi      # 0x31800
callq 0x8740
movq -0x10(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: str2int
char str2int(char c)
{
        switch (c)
        {
                case 'A':
                        return 0;
                case 'C':
                        return 1;
                case 'G':
                        return 2;
                case 'T':
                        return 3;
        }
        return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0x1318
movq -0x10(%rbp), %rax
leaq 0x11d0d(%rip), %rcx     # 0x13004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x131c
movb $0x1, -0x1(%rbp)
jmp 0x131c
movb $0x2, -0x1(%rbp)
jmp 0x131c
movb $0x3, -0x1(%rbp)
jmp 0x131c
movb $0x4, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: generate
void generate(char *seq,char out[],int pos,int length)
{
	int i;
	for(i=0;i<length;i++)
	{
		out[i]=seq[pos+i];
	}
	out[i]='\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xe5c7
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe599
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: gc
float gc(char seq[],int length)
{
	int i,number;
	float gc;

	number=0;
	for(i=0;i<length;i++)
	{
		if(seq[i]=='C')
		{
			number++;
			continue;
		}
	
		if(seq[i]=='G')
		{
			number++;
		}
	}

	gc=1.0*number/length*100;
	return gc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xe644
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0xe61d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe639
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x47, %eax
jne 0xe637
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe639
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe5f9
cvtsi2sdl -0x14(%rbp), %xmm1
movsd 0x4abf(%rip), %xmm0     # 0x13110
mulsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x4a92(%rip), %xmm1     # 0x130f8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: translate
int translate(char a)
{
	if(a=='A')
		return 0;
	if(a=='T')
		return 1;
	if(a=='C')
		return 2;
	return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jne 0xe69c
movl $0x0, -0x4(%rbp)
jmp 0xe6c7
movsbl -0x5(%rbp), %eax
cmpl $0x54, %eax
jne 0xe6ae
movl $0x1, -0x4(%rbp)
jmp 0xe6c7
movsbl -0x5(%rbp), %eax
cmpl $0x43, %eax
jne 0xe6c0
movl $0x2, -0x4(%rbp)
jmp 0xe6c7
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: words
int words(char *seq,int position,int length)
{
	int i;
	
	for(i=0;i<length;i++)
	{
		if(seq[position+i]=='N')
		{
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xe9a9
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4e, %eax
jne 0xe99c
movl $0x0, -0x4(%rbp)
jmp 0xe9b0
jmp 0xe99e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe975
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: check_long_ploy
int check_long_ploy(char primer[],int length)
{
	int i,same;
	char ref;

	same=1;
	ref=primer[0];
	for(i=1;i<length;i++)
	{
		if(primer[i]==ref)
			same++;
		else
		{
			if(same>=6)
				return 0;
			same=1;
			ref=primer[i];
		}
	}
	if(same>=6)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1d(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xeafa
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
jne 0xeac9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xeaed
cmpl $0x6, -0x1c(%rbp)
jl 0xead8
movl $0x0, -0x4(%rbp)
jmp 0xeb10
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
jmp 0xeaef
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeaa2
cmpl $0x6, -0x1c(%rbp)
jl 0xeb09
movl $0x0, -0x4(%rbp)
jmp 0xeb10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/single.c
// Function: GContent
float GContent(char primer[],int length)
{
	int i,G;
	G=0;
	for(i=0;i<length;i++)
	{
		if(primer[i]=='G')
			G++;
	}
	return 1.0*G/length*100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xeb68
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x47, %eax
jne 0xeb5b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xeb5d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xeb39
cvtsi2sdl -0x14(%rbp), %xmm1
movsd 0x459b(%rip), %xmm0     # 0x13110
mulsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x456e(%rip), %xmm1     # 0x130f8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xec0d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x47, %eax
jne 0xebe4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xec00
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0xebfe
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xec00
jmp 0xec02
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xebc0
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0xec1e
movl $0x1, -0x4(%rbp)
jmp 0xec25
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x1eeb(%rip), %rdi      # 0x133e6
movb $0x0, %al
callq 0x10c0
leaq 0x1ee5(%rip), %rdi      # 0x133ee
movb $0x0, %al
callq 0x10c0
leaq 0x1f17(%rip), %rdi      # 0x1342e
movb $0x0, %al
callq 0x10c0
leaq 0x1f15(%rip), %rdi      # 0x1343a
movb $0x0, %al
callq 0x10c0
leaq 0x1f1b(%rip), %rdi      # 0x1344e
movb $0x0, %al
callq 0x10c0
leaq 0x1f32(%rip), %rdi      # 0x13473
movb $0x0, %al
callq 0x10c0
leaq 0x1f3b(%rip), %rdi      # 0x1348a
movb $0x0, %al
callq 0x10c0
leaq 0x1f61(%rip), %rdi      # 0x134be
movb $0x0, %al
callq 0x10c0
leaq 0x1f67(%rip), %rdi      # 0x134d2
movb $0x0, %al
callq 0x10c0
leaq 0x1f7c(%rip), %rdi      # 0x134f5
movb $0x0, %al
callq 0x10c0
leaq 0x1f8e(%rip), %rdi      # 0x13515
movb $0x0, %al
callq 0x10c0
leaq 0x1f8a(%rip), %rdi      # 0x1351f
movb $0x0, %al
callq 0x10c0
leaq 0x1fa5(%rip), %rdi      # 0x13548
movb $0x0, %al
callq 0x10c0
leaq 0x1fc2(%rip), %rdi      # 0x13573
movb $0x0, %al
callq 0x10c0
leaq 0x1fc0(%rip), %rdi      # 0x1357f
movb $0x0, %al
callq 0x10c0
leaq 0x1fec(%rip), %rdi      # 0x135b9
movb $0x0, %al
callq 0x10c0
leaq 0x2006(%rip), %rdi      # 0x135e1
movb $0x0, %al
callq 0x10c0
leaq 0x2010(%rip), %rdi      # 0x135f9
movb $0x0, %al
callq 0x10c0
leaq 0x205a(%rip), %rdi      # 0x13651
movb $0x0, %al
callq 0x10c0
leaq 0x2065(%rip), %rdi      # 0x1366a
movb $0x0, %al
callq 0x10c0
leaq 0x2064(%rip), %rdi      # 0x13677
movb $0x0, %al
callq 0x10c0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x37ad
movq $0x0, -0x8(%rbp)
jmp 0x3825
movq -0x10(%rbp), %rdi
callq 0x32a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x37cb
movq $0x0, -0x8(%rbp)
jmp 0x3825
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3830
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x37ed
movq $0x0, -0x8(%rbp)
jmp 0x3825
callq 0x34b0
andl $0x10, %eax
cmpl $0x0, %eax
je 0x380c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xaa, %esi
callq 0x3260
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x35e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: malloc_ptr
static void	*malloc_ptr(t_metabody *body, const size_t size)
{
	ssize_t		i;

	if (body->id == ZLARGE)
	{
		malloc_set_size(body, size, 0);
		malloc_set_head(body);
		return (body->address);
	}
	if ((i = metablock_get_available_index(body)) == -1)
		return (NULL);
	if (((body->free)[i / 8] & (1 << (i % 8))) == 0)
		(body->free)[i / 8] |= (1 << (i % 8));
	malloc_set_size(body, size, i);
	malloc_set_head(body);
	return (((uint8_t *)(body->address)) + i * body->id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x3879
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x39b0
movq -0x10(%rbp), %rdi
callq 0x3b90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3958
movq -0x10(%rbp), %rdi
callq 0x36a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0x3899
movq $0x0, -0x8(%rbp)
jmp 0x3958
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movzbl 0x18(%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl -0x24(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x3920
movq -0x20(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl %edx, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movzbl 0x18(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0x18(%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x39b0
movq -0x10(%rbp), %rdi
callq 0x3b90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzwl (%rdx), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xb655(%rip), %rdi      # 0xefd8
callq 0x3670
movq -0x8(%rbp), %rdi
callq 0x32c0
movq %rax, -0x10(%rbp)
movq 0xb63c(%rip), %rdi      # 0xefd8
callq 0x33e0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x3a2e
movq -0x18(%rbp), %rax
andq $0x1, %rax
shlq $0x2, %rax
movl %eax, %ecx
movl $0xf0, %esi
sarl %cl, %esi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
movzbl 0x38(%rax,%rcx), %edx
andl %esi, %edx
movb %dl, 0x38(%rax,%rcx)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
movq -0x18(%rbp), %rcx
andq $0x1, %rcx
shlq $0x2, %rcx
shlq %cl, %rsi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
movzbl 0x38(%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, 0x38(%rax,%rcx)
jmp 0x3b7b
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x100, %eax            # imm = 0x100
jg 0x3a57
movq -0x10(%rbp), %rax
subq $0x1, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, 0x38(%rax,%rcx)
jmp 0x3b79
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jg 0x3af1
movq -0x10(%rbp), %rax
subq $0x1, %rax
shrq $0x4, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, 0x38(%rax,%rcx)
movq -0x18(%rbp), %rax
andq $0x1, %rax
shlq $0x2, %rax
movl %eax, %ecx
movl $0xf0, %esi
sarl %cl, %esi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
movzbl 0xb8(%rax,%rcx), %edx
andl %esi, %edx
movb %dl, 0xb8(%rax,%rcx)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
andq $0xf, %rsi
movq -0x18(%rbp), %rcx
andq $0x1, %rcx
shlq $0x2, %rcx
shlq %cl, %rsi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
movzbl 0xb8(%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, 0xb8(%rax,%rcx)
jmp 0x3b77
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x35c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
callq 0x35c0
movq -0x28(%rbp), %rcx
cltq
imulq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x35c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x3b75
callq 0x35c0
movslq %eax, %rcx
movq -0x8(%rbp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
jmp 0x3b77
jmp 0x3b79
jmp 0x3b7b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: malloc_set_head
static void	malloc_set_head(t_metabody *body)
{
	t_metahead	*head;

	body->block_count += 1;
	head = (t_metahead *)(body->head);
	if ((body->id == Z4 && body->block_count == 256)
		|| (body->id != Z4 && body->block_count == 128))
		head->full |= (1 << body->index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x3bce
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x100, %eax            # imm = 0x100
je 0x3be9
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
je 0x3c06
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x80, %eax
jne 0x3c06
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x10(%rbp), %rax
movzwl 0x4e(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x4e(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c30
movq 0xb3be(%rip), %rax      # 0xefe8
cmpq $0x0, (%rax)
jne 0x3c40
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3480
jmp 0x3cc8
movq -0x8(%rbp), %rdi
movq 0xb39d(%rip), %rax      # 0xefe8
movq (%rax), %rsi
callq 0x3660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c6b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3480
jmp 0x3cc8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3380
cmpl $0x1, %eax
jne 0x3c8d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3480
jmp 0x3cc8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, %esi
callq 0x32b0
movq -0x10(%rbp), %rdi
callq 0x33a0
movq -0x18(%rbp), %rdi
movq 0xb328(%rip), %rax      # 0xefe8
movq (%rax), %rsi
callq 0x34e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xb2b1(%rip), %rdi      # 0xefd8
callq 0x3670
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3d60
movq %rax, -0x18(%rbp)
movq 0xb294(%rip), %rdi      # 0xefd8
callq 0x33e0
movq -0x18(%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/realloc.c
// Function: mono_realloc
static void		*mono_realloc(void *ptr, size_t size)
{
	t_metabody	*body;
	void		*ret;

	if (!ptr)
		return (mono_malloc(size));
	if (!size)
	{
		mono_free(ptr);
		return (NULL);
	}
	body = metabody_find(ptr, g_metadata);
	if (body == NULL)
		return (NULL);
	else if (body->id == ZLARGE)
		return (realloc_large(body, size));
	else if (size > body->id || size <= body->id / 2)
	{
		ret = mono_malloc(size);
		ret = ft_memcpy(ret, ptr, (body->size)[body->index]);
		mono_free(ptr);
		return (ptr);
	}
	(body->size)[body->index] = size;
	return (ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d89
movq -0x18(%rbp), %rdi
callq 0x32c0
movq %rax, -0x8(%rbp)
jmp 0x3e90
cmpq $0x0, -0x18(%rbp)
jne 0x3da6
movq -0x10(%rbp), %rdi
callq 0x3340
movq $0x0, -0x8(%rbp)
jmp 0x3e90
movq -0x10(%rbp), %rdi
movq 0xb237(%rip), %rax      # 0xefe8
movq (%rax), %rsi
callq 0x3660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3dd1
movq $0x0, -0x8(%rbp)
jmp 0x3e90
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x3df5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ea0
movq %rax, -0x8(%rbp)
jmp 0x3e90
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
ja 0x3e2a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
ja 0x3e6e
movq -0x18(%rbp), %rdi
callq 0x32c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movzbl 0x38(%rax,%rcx), %eax
movl %eax, %edx
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3340
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e90
jmp 0x3e70
jmp 0x3e72
movq -0x18(%rbp), %rax
movb %al, %dl
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movb %dl, 0x38(%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/realloc.c
// Function: realloc_large
static void		*realloc_large(t_metabody *body, size_t size)
{
	size_t	stored;
	void	*ret;

	stored = *((size_t *)&(body->store));
	if (size <= stored && size >= stored - getpagesize())
	{
		body->block_count = size;
		return (body->address);
	}
	ret = mono_malloc(size);
	if (size < stored)
		ret = ft_memcpy(ret, body->address, size);
	else
		ret = ft_memcpy(ret, body->address, stored);
	mono_free(body->address);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x3f10
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x35c0
movq -0x38(%rbp), %rcx
movl %eax, %edx
movq -0x30(%rbp), %rax
movslq %edx, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jb 0x3f10
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f70
movq -0x18(%rbp), %rdi
callq 0x32c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3f42
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3440
movq %rax, -0x28(%rbp)
jmp 0x3f5b
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3340
movq -0x28(%rbp), %rax
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/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0xb026(%rip), %rax      # 0xefe8
cmpq $0x0, (%rax)
jne 0x3fca
jmp 0x401b
movq $0x0, -0x18(%rbp)
movq 0xb00f(%rip), %rax      # 0xefe8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4009
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x3220
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3fe0
movq -0x18(%rbp), %rsi
leaq 0x7fec(%rip), %rdi      # 0xc000
movb $0x0, %al
callq 0x3550
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x407e
cmpq $0x0, -0x8(%rbp)
jne 0x4083
jmp 0x410f
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x40f3
movq -0x18(%rbp), %rax
addq $0x1, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x40cb
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x7f50(%rip), %rdi      # 0xc012
movb $0x0, %al
callq 0x3550
jmp 0x40e5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x7f3a(%rip), %rdi      # 0xc018
movb $0x0, %al
callq 0x3550
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4093
movq -0x10(%rbp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x410f
leaq 0x81c2(%rip), %rdi      # 0xc2ca
movb $0x0, %al
callq 0x3550
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x7ebc(%rip), %rdi      # 0xc01e
movb $0x0, %al
callq 0x3550
cmpl $0x0, -0xc(%rbp)
je 0x417c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32d0
movq -0x18(%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/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4267
movq -0x8(%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 0x4256
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3470
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movzwl (%rdx), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq -0x30(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x7dee(%rip), %rdi      # 0xc01e
movb $0x0, %al
callq 0x3550
cmpl $0x0, -0x14(%rbp)
je 0x424a
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x32d0
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x41b3
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edi
callq 0x30d0
movw %ax, -0xa(%rbp)
callq 0x34b0
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x430b
movzwl -0xa(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jg 0x42ce
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7d70(%rip), %rdi      # 0xc035
movb $0x0, %al
callq 0x3550
jmp 0x4309
movzwl -0xa(%rbp), %eax
cmpl $0x400, %eax            # imm = 0x400
jg 0x42f1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7d59(%rip), %rdi      # 0xc041
movb $0x0, %al
callq 0x3550
jmp 0x4307
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7d4e(%rip), %rdi      # 0xc04e
movb $0x0, %al
callq 0x3550
jmp 0x4309
jmp 0x434d
movzwl -0xa(%rbp), %eax
cmpl $0x1001, %eax           # imm = 0x1001
je 0x4335
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x7d2f(%rip), %rdi      # 0xc05b
movb $0x0, %al
callq 0x3550
jmp 0x434b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7d0a(%rip), %rdi      # 0xc04e
movb $0x0, %al
callq 0x3550
jmp 0x434d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0xf, -0x28(%rbp)
jae 0x4435
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x28(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x4424
movq -0x18(%rbp), %rdi
callq 0x3250
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x43e0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3610
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4422
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x4407
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x100, %esi            # imm = 0x100
callq 0x33d0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4420
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x80, %esi
callq 0x33d0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4422
jmp 0x4424
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x437f
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log1.c
// Function: log_attempt
int			log_attempt(size_t i)
{
	int fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	ft_dprintf(fd, "Malloc attempt: %zu |", i);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x35d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x4463
movl $0x1, -0x4(%rbp)
jmp 0x447f
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7bfd(%rip), %rsi      # 0xc06e
movb $0x0, %al
callq 0x3410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x35d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x44bb
movl $0x1, -0x4(%rbp)
jmp 0x44e8
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %r9d
leaq 0x7baa(%rip), %rsi      # 0xc084
movb $0x0, %al
callq 0x3410
movl $0x0, -0x4(%rbp)
movl -0x4(%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/log1.c
// Function: log_free
int			log_free(void *ptr, size_t count)
{
	int fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	ft_dprintf(fd, "Free:        %p (N-%zu)\n", ptr, count);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x35d0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x4527
movl $0x1, -0x4(%rbp)
jmp 0x4547
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x7b69(%rip), %rsi      # 0xc0a2
movb $0x0, %al
callq 0x3410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log1.c
// Function: log_free_failed
int			log_free_failed(void *ptr, t_error error)
{
	int	fd;

	fd = get_fd();
	if (fd == -1)
		return (1);
	if (error == ERR_FREE_INVALID)
		ft_dprintf(fd, "! - Cannot free %p: invalid pointer\n", ptr);
	else if (error == ERR_FREE_DOUBLE)
		ft_dprintf(fd, "! - Cannot free %p: double-free\n", ptr);
	else if (error == ERR_FREE_MUNMAP)
		ft_dprintf(fd, "!!! - Invalid munmap on %p\n", ptr);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x35d0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x4576
movl $0x1, -0x4(%rbp)
jmp 0x45d6
cmpl $0x0, -0x14(%rbp)
jne 0x4593
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7b31(%rip), %rsi      # 0xc0bb
movb $0x0, %al
callq 0x3410
jmp 0x45cf
cmpl $0x1, -0x14(%rbp)
jne 0x45b0
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7b39(%rip), %rsi      # 0xc0e0
movb $0x0, %al
callq 0x3410
jmp 0x45cd
cmpl $0x2, -0x14(%rbp)
jne 0x45cb
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7b3d(%rip), %rsi      # 0xc101
movb $0x0, %al
callq 0x3410
jmp 0x45cd
jmp 0x45cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x35d0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x4606
movl $0x1, -0x4(%rbp)
jmp 0x465e
cmpl $0x3, -0x14(%rbp)
jne 0x461f
movl -0x18(%rbp), %edi
leaq 0x7b07(%rip), %rsi      # 0xc11d
movb $0x0, %al
callq 0x3410
jmp 0x4657
cmpl $0x4, -0x14(%rbp)
jne 0x4638
movl -0x18(%rbp), %edi
leaq 0x7b18(%rip), %rsi      # 0xc147
movb $0x0, %al
callq 0x3410
jmp 0x4655
cmpl $0x5, -0x14(%rbp)
jne 0x4653
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7b23(%rip), %rsi      # 0xc16f
movb $0x0, %al
callq 0x3410
jmp 0x4655
jmp 0x4657
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x35d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x469e
movl $0x1, -0x4(%rbp)
jmp 0x472f
cmpq $0x0, -0x18(%rbp)
je 0x46cb
cmpq $0x0, -0x20(%rbp)
je 0x46cb
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x7ad4(%rip), %rsi      # 0xc196
movb $0x0, %al
callq 0x3410
jmp 0x4728
cmpq $0x0, -0x18(%rbp)
je 0x46ed
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x7ad6(%rip), %rsi      # 0xc1ba
movb $0x0, %al
callq 0x3410
jmp 0x4726
cmpq $0x0, -0x20(%rbp)
je 0x470f
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x7ad3(%rip), %rsi      # 0xc1d9
movb $0x0, %al
callq 0x3410
jmp 0x4724
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x7adb(%rip), %rsi      # 0xc1f8
movb $0x0, %al
callq 0x3410
jmp 0x4726
jmp 0x4728
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x35d0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x4767
movl $0x1, -0x4(%rbp)
jmp 0x479b
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x18(%rbp), %rax
movq 0x28(%rax), %r9
leaq 0x7a85(%rip), %rsi      # 0xc212
movb $0x0, %al
callq 0x3410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x35d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x47db
movl $0x1, -0x4(%rbp)
jmp 0x480b
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
movq 0x28(%rax), %r9
leaq 0x7a3d(%rip), %rsi      # 0xc23a
movb $0x0, %al
callq 0x3410
movl $0x0, -0x4(%rbp)
movl -0x4(%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/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x35d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x484e
movl $0x1, -0x4(%rbp)
jmp 0x48df
cmpq $0x0, -0x18(%rbp)
je 0x487b
cmpq $0x0, -0x20(%rbp)
je 0x487b
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x79f2(%rip), %rsi      # 0xc264
movb $0x0, %al
callq 0x3410
jmp 0x48d8
cmpq $0x0, -0x18(%rbp)
je 0x489d
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x79f6(%rip), %rsi      # 0xc28a
movb $0x0, %al
callq 0x3410
jmp 0x48d6
cmpq $0x0, -0x20(%rbp)
je 0x48bf
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x79f5(%rip), %rsi      # 0xc2ab
movb $0x0, %al
callq 0x3410
jmp 0x48d4
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x79ff(%rip), %rsi      # 0xc2cc
movb $0x0, %al
callq 0x3410
jmp 0x48d6
jmp 0x48d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_block
uint16_t		get_block(const size_t size)
{
	if (size == 0)
		return (0);
	if (size <= Z4)
		return (256);
	if (size <= Z11)
		return (128);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4907
movw $0x0, -0x2(%rbp)
jmp 0x492e
cmpq $0x10, -0x10(%rbp)
ja 0x4916
movw $0x100, -0x2(%rbp)      # imm = 0x100
jmp 0x492e
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
ja 0x4928
movw $0x80, -0x2(%rbp)
jmp 0x492e
movw $0x1, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x495e
movw $0x0, -0x2(%rbp)
jmp 0x4a22
callq 0x34b0
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x497d
movq -0x10(%rbp), %rdi
callq 0x4a30
movw %ax, -0x2(%rbp)
jmp 0x4a22
cmpq $0x10, -0x10(%rbp)
ja 0x498f
movw $0x10, -0x2(%rbp)
jmp 0x4a22
cmpq $0x20, -0x10(%rbp)
ja 0x49a1
movw $0x20, -0x2(%rbp)
jmp 0x4a22
cmpq $0x40, -0x10(%rbp)
ja 0x49b0
movw $0x40, -0x2(%rbp)
jmp 0x4a22
cmpq $0x80, -0x10(%rbp)
ja 0x49c2
movw $0x80, -0x2(%rbp)
jmp 0x4a22
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
ja 0x49d4
movw $0x100, -0x2(%rbp)      # imm = 0x100
jmp 0x4a22
cmpq $0x200, -0x10(%rbp)     # imm = 0x200
ja 0x49e6
movw $0x200, -0x2(%rbp)      # imm = 0x200
jmp 0x4a22
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
ja 0x49f8
movw $0x400, -0x2(%rbp)      # imm = 0x400
jmp 0x4a22
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
ja 0x4a0a
movw $0x800, -0x2(%rbp)      # imm = 0x800
jmp 0x4a22
cmpq $0x1000, -0x10(%rbp)    # imm = 0x1000
ja 0x4a1c
movw $0x1000, -0x2(%rbp)     # imm = 0x1000
jmp 0x4a22
movw $0x1001, -0x2(%rbp)     # imm = 0x1001
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_flag_no_bonus
static uint16_t	get_flag_no_bonus(const size_t size)
{
	if (size <= TINY)
		return (TINY);
	if (size <= SMALL)
		return (SMALL);
	return (ZLARGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
ja 0x4a4a
movw $0x100, -0x2(%rbp)      # imm = 0x100
jmp 0x4a62
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
ja 0x4a5c
movw $0x400, -0x2(%rbp)      # imm = 0x400
jmp 0x4a62
movw $0x1001, -0x2(%rbp)     # imm = 0x1001
movw -0x2(%rbp), %ax
popq %rbp
retq
nopl (%rax,%rax)