LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
je 0x89c0
movzbl (%rdi,%rax), %r8d
cmpl $0x47, %r8d
je 0x89b9
cmpl $0x43, %r8d
jne 0x89bb
incl %edx
incq %rax
jmp 0x89a3
pushq %rbp
movq %rsp, %rbp
cvtsi2sd %edx, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x26b8(%rip), %xmm0     # 0xb090
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x41, %edi
je 0x89ff
cmpl $0x43, %edi
je 0x89f8
cmpl $0x54, %edi
jne 0x8a03
movl $0x1, %eax
jmp 0x8a08
movl $0x2, %eax
jmp 0x8a08
xorl %eax, %eax
jmp 0x8a08
movl $0x3, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jiqingxiaoxi[P]RPA/single.c
// Function: tm
float tm(char seq[],float deltah[],float deltas[],int length)
{
	int i,pos;
	float total_deltah,total_deltas,result;

	total_deltah=0;
	total_deltas=0;
	for(i=0;i<length-1;i++)
	{
		pos=translate(seq[i]);
		pos=pos*4+translate(seq[i+1]);
		total_deltah+=deltah[pos];
		total_deltas+=deltas[pos];
	}

	total_deltah=(-1.0)*total_deltah;
	total_deltas=(-1.0)*total_deltas;
	if((seq[0]=='A')||(seq[0]=='T'))
	{
		total_deltah+=2.3;
		total_deltas+=4.1;
	}
	else
	{
		total_deltah+=0.1;
		total_deltas-=2.8;
	}
        if((seq[length-1]=='A')||(seq[length-1]=='T'))
        {
                total_deltah+=2.3;
                total_deltas+=4.1;
        }
        else
        {
                total_deltah+=0.1;
                total_deltas-=2.8;
        }
	result=1000.0*total_deltah/(total_deltas-0.6656578*(length-1)-36.1585064)-273.15;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %ecx, %rax
decq %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
xorps %xmm0, %xmm0
movabsq $0x2, %r9
movabsq $0x1, %r10
movabsq $0x3, %r11
movabsq $0x8, %rbx
movabsq $0x4, %r14
movabsq $0xc, %r15
xorps %xmm1, %xmm1
cmpq %rcx, %r8
je 0x8add
movzbl (%rdi,%rcx), %r12d
cmpl $0x41, %r12d
je 0x8a93
cmpl $0x43, %r12d
je 0x8a8e
cmpl $0x54, %r12d
jne 0x8a98
movq %r14, %r12
jmp 0x8a9b
movq %rbx, %r12
jmp 0x8a9b
xorl %r12d, %r12d
jmp 0x8a9b
movq %r15, %r12
movzbl 0x1(%rdi,%rcx), %r13d
cmpl $0x41, %r13d
je 0x8abd
cmpl $0x43, %r13d
je 0x8ab8
cmpl $0x54, %r13d
jne 0x8ac2
movq %r10, %r13
jmp 0x8ac5
movq %r9, %r13
jmp 0x8ac5
xorl %r13d, %r13d
jmp 0x8ac5
movq %r11, %r13
orl %r12d, %r13d
shll $0x2, %r13d
addss (%rsi,%r13), %xmm0
addss (%rdx,%r13), %xmm1
incq %rcx
jmp 0x8a6d
movzbl (%rdi), %ecx
movsd 0x25c0(%rip), %xmm2     # 0xb0a8
movsd 0x25c0(%rip), %xmm3     # 0xb0b0
movapd %xmm3, %xmm5
movapd %xmm2, %xmm4
cmpl $0x41, %ecx
je 0x8b1a
movapd %xmm3, %xmm5
movapd %xmm2, %xmm4
cmpl $0x54, %ecx
je 0x8b1a
movsd 0x25a6(%rip), %xmm4     # 0xb0b8
movsd 0x25a6(%rip), %xmm5     # 0xb0c0
movzbl (%rdi,%rax), %ecx
cmpl $0x41, %ecx
je 0x8b38
cmpl $0x54, %ecx
je 0x8b38
movsd 0x2588(%rip), %xmm2     # 0xb0b8
movsd 0x2588(%rip), %xmm3     # 0xb0c0
cvtss2sd %xmm0, %xmm0
subsd %xmm0, %xmm5
cvtsd2ss %xmm5, %xmm0
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm4
cvtsd2ss %xmm4, %xmm1
cvtss2sd %xmm0, %xmm0
addsd %xmm3, %xmm0
cvtss2sd %xmm1, %xmm1
addsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x2554(%rip), %xmm0     # 0xb0c8
cvtsi2sd %eax, %xmm2
mulsd 0x2550(%rip), %xmm2     # 0xb0d0
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm2
addsd 0x2548(%rip), %xmm2     # 0xb0d8
divsd %xmm2, %xmm0
addsd 0x24c4(%rip), %xmm0     # 0xb060
cvtsd2ss %xmm0, %xmm0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %esi, %rcx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
addq %rdi, %rcx
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x8bd2
cmpb $0x4e, (%rcx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x8bc1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movb (%rdi), %r8b
movslq %esi, %rax
movl $0x1, %ecx
movabsq $0x1, %rdx
movl %ecx, %esi
cmpq %rax, %rdx
jge 0x8c65
movb (%rdi,%rdx), %r9b
cmpb %r8b, %r9b
jne 0x8c56
incl %esi
movl %r8d, %r9d
jmp 0x8c5d
cmpl $0x5, %esi
movl %ecx, %esi
jg 0x8c6f
incq %rdx
movl %r9d, %r8d
jmp 0x8c41
xorl %eax, %eax
cmpl $0x6, %esi
setl %al
jmp 0x8c71
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
je 0x8c99
xorl %r8d, %r8d
cmpb $0x47, (%rdi,%rax)
sete %r8b
addl %r8d, %edx
incq %rax
jmp 0x8c81
pushq %rbp
movq %rsp, %rbp
cvtsi2sd %edx, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x23df(%rip), %xmm0     # 0xb090
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rsi
je 0x8ce7
movzbl (%rdi,%rax), %r8d
cmpl $0x43, %r8d
je 0x8ce0
cmpl $0x47, %r8d
jne 0x8ce2
incl %ecx
jmp 0x8ce2
incl %edx
incq %rax
jmp 0x8cc6
xorl %eax, %eax
cmpl %ecx, %edx
setg %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a12(%rip), %rdi      # 0xb53c
callq 0x1080
leaq 0x1a0d(%rip), %rdi      # 0xb543
callq 0x1080
leaq 0x1a40(%rip), %rdi      # 0xb582
callq 0x1080
leaq 0x1a3f(%rip), %rdi      # 0xb58d
callq 0x1080
leaq 0x1a46(%rip), %rdi      # 0xb5a0
callq 0x1080
leaq 0x1a5e(%rip), %rdi      # 0xb5c4
callq 0x1080
leaq 0x1a68(%rip), %rdi      # 0xb5da
callq 0x1080
leaq 0x1a8f(%rip), %rdi      # 0xb60d
callq 0x1080
leaq 0x1a96(%rip), %rdi      # 0xb620
callq 0x1080
leaq 0x1aac(%rip), %rdi      # 0xb642
callq 0x1080
leaq 0x1abf(%rip), %rdi      # 0xb661
callq 0x1080
leaq 0x1abc(%rip), %rdi      # 0xb66a
callq 0x1080
leaq 0x1ad8(%rip), %rdi      # 0xb692
callq 0x1080
leaq 0x1af6(%rip), %rdi      # 0xb6bc
callq 0x1080
leaq 0x1af5(%rip), %rdi      # 0xb6c7
callq 0x1080
leaq 0x1b22(%rip), %rdi      # 0xb700
callq 0x1080
leaq 0x1b3d(%rip), %rdi      # 0xb727
callq 0x1080
leaq 0x1b48(%rip), %rdi      # 0xb73e
callq 0x1080
leaq 0x1b93(%rip), %rdi      # 0xb795
callq 0x1080
leaq 0x1b9f(%rip), %rdi      # 0xb7ad
callq 0x1080
leaq 0x1b9f(%rip), %rdi      # 0xb7b9
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: mono_malloc
void		*mono_malloc(size_t size)
{
	void		*ret;
	t_metabody	*body;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3859
movq %rdi, %rbx
callq 0x32a0
testq %rax, %rax
je 0x3859
movq %rax, %r14
cmpw $0x1001, (%rax)         # imm = 0x1001
jne 0x37d5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x389e
movq %r14, %rdi
callq 0x3959
movq 0x8(%r14), %r15
jmp 0x382b
movq %r14, %rdi
callq 0x36a0
cmpq $-0x1, %rax
je 0x3859
movq %rax, %r15
pushq $0x8
popq %rcx
cqto
idivq %rcx
movq %rdx, %rcx
movzbl 0x18(%r14,%rax), %edx
pushq $0x1
popq %rsi
shll %cl, %esi
btl %ecx, %edx
jb 0x3809
orb %dl, %sil
movb %sil, 0x18(%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x389e
movq %r14, %rdi
callq 0x3959
movzwl (%r14), %eax
imulq %rax, %r15
addq 0x8(%r14), %r15
testq %r15, %r15
je 0x3859
callq 0x34b0
testb $0x10, %al
je 0x3849
movq %r15, %rdi
movl $0xaa, %esi
movq %rbx, %rdx
callq 0x3260
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x35e0
jmp 0x385c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/malloc.c
// Function: malloc
void		*malloc(size_t size)
{
	void	*ret;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rdi), %ecx
cmpw $0x10, %cx
jne 0x38d4
leal (,%rdx,4), %ecx
andb $0x4, %cl
movb $-0x10, %al
shrb %cl, %al
shrq %rdx
decl %r14d
shlq %cl, %r14
andb 0x38(%rbx,%rdx), %al
orb %al, %r14b
jmp 0x38de
cmpw $0x100, %cx             # imm = 0x100
ja 0x38e8
decb %r14b
movb %r14b, 0x38(%rbx,%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1(%r14), %rax
cmpw $0x1000, %cx            # imm = 0x1000
ja 0x392a
movl %eax, %esi
leal (,%rdx,4), %ecx
andb $0x4, %cl
movb $-0x10, %dil
shrb %cl, %dil
shrl $0x4, %esi
movb %sil, 0x38(%rbx,%rdx)
shrq %rdx
andl $0xf, %eax
shlq %cl, %rax
andb 0xb8(%rbx,%rdx), %dil
orb %dil, %al
movb %al, 0xb8(%rbx,%rdx)
jmp 0x38e3
movq %rax, 0x38(%rbx)
callq 0x35c0
movslq %eax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0xb8(%rbx)
testq %rdx, %rdx
je 0x38e3
addq %rcx, %r14
movq %r14, 0xb8(%rbx)
jmp 0x38e3
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x4(%rdi), %eax
incl %eax
movw %ax, 0x4(%rdi)
xorl %ecx, %ecx
cmpw $0x10, (%rdi)
sete %cl
shll $0x7, %ecx
subl $-0x80, %ecx
cmpw %cx, %ax
jne 0x398d
pushq %rbp
movq %rsp, %rbp
movb 0x2(%rdi), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x10(%rdi), %rcx
orw %ax, 0x4e(%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/free.c
// Function: mono_free
void		mono_free(void *ptr)
{
	t_metabody	*body;
	t_metahead	*head;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
movq 0x763d(%rip), %r12      # 0xafe8
movq (%r12), %rsi
testq %rsi, %rsi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
je 0x39e4
movq %rbx, %rdi
callq 0x3660
testq %rax, %rax
je 0x39e4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3380
cmpl $0x1, %eax
jne 0x39f6
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x39e9
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3480
movq 0x10(%r14), %r15
movzwl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x32b0
movq %r14, %rdi
callq 0x33a0
movq (%r12), %rsi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34e0
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/realloc.c
// Function: realloc
void			*realloc(void *ptr, size_t size)
{
	void	*ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x7571(%rip), %rdi      # 0xafd8
callq 0x3670
testq %rbx, %rbx
je 0x3ae4
testq %r14, %r14
je 0x3af1
movq 0x756b(%rip), %rax      # 0xafe8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3660
testq %rax, %rax
je 0x3af9
movq %rax, %r15
movzwl (%rax), %eax
cmpq $0x1001, %rax           # imm = 0x1001
jne 0x3afd
movq 0xb8(%r15), %rbx
cmpq %r14, %rbx
jb 0x3abd
callq 0x35c0
cltq
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r14, %rcx
jbe 0x3b55
movq %r14, %rdi
callq 0x32c0
movq 0x8(%r15), %rsi
cmpq %r14, %rbx
cmovbq %rbx, %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x3440
movq %rax, %rbx
movq 0x8(%r15), %rdi
jmp 0x3b36
movq %r14, %rdi
callq 0x32c0
movq %rax, %rbx
jmp 0x3b3b
movq %rbx, %rdi
callq 0x3340
xorl %ebx, %ebx
jmp 0x3b3b
cmpq %r14, %rax
jb 0x3b15
shrl %eax
cmpq %r14, %rax
jae 0x3b15
movzwl 0x2(%r15), %eax
movb %r14b, 0x38(%r15,%rax)
jmp 0x3b3b
movq %r14, %rdi
callq 0x32c0
movzwl 0x2(%r15), %ecx
movzbl 0x38(%r15,%rcx), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3440
movq %rbx, %rdi
callq 0x3340
movq 0x7496(%rip), %rdi      # 0xafd8
callq 0x33e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movw %r14w, 0x4(%r15)
movq 0x8(%r15), %rbx
jmp 0x3b3b
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/show_alloc_mem.c
// Function: mono_show_alloc_mem
static void	mono_show_alloc_mem(int option)
{
	t_metahead	*iter;
	size_t		total;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x744c(%rip), %rax      # 0xafe8
movq (%rax), %r15
testq %r15, %r15
je 0x3bdc
movl %edi, %ebx
xorl %r14d, %r14d
testq %r15, %r15
je 0x3bc1
movq %r15, %rdi
movl %ebx, %esi
callq 0x3220
addq %rax, %r14
movq 0x8(%r15), %r15
jmp 0x3ba9
leaq 0x4438(%rip), %rdi      # 0x8000
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3550
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_dump
void		print_dump(void *address, size_t size)
{
	size_t	i;
	uint8_t	*ptr;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, -0x38(%rbp)
je 0x3d77
movq %r13, %rax
shrq $0x3, %rax
movzbl 0x18(%r15,%rax), %eax
movl %r13d, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x3d72
movq %r15, %rdi
movq %r13, %rsi
callq 0x3470
movq %rax, %rbx
movzwl (%r15), %r14d
imulq %r13, %r14
addq 0x8(%r15), %r14
leaq (%r14,%rax), %rdx
leaq 0x42cd(%rip), %rdi      # 0x801e
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x3550
cmpl $0x0, -0x2c(%rbp)
je 0x3d6f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
addq %rbx, %r12
incq %r13
jmp 0x3d0e
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_zone
void		print_zone(t_metabody *body)
{
	uint16_t	flag;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl (%rdi), %edi
callq 0x30d0
movl %eax, %r14d
callq 0x34b0
testb $0x2, %al
jne 0x3dbc
cmpw $0x100, %r14w           # imm = 0x100
ja 0x3dca
movq 0x8(%rbx), %rsi
leaq 0x427b(%rip), %rdi      # 0x8035
jmp 0x3de6
cmpw $0x1001, %r14w          # imm = 0x1001
jne 0x3df1
movq 0x8(%rbx), %rsi
jmp 0x3ddf
movq 0x8(%rbx), %rsi
cmpw $0x400, %r14w           # imm = 0x400
ja 0x3ddf
leaq 0x4264(%rip), %rdi      # 0x8041
jmp 0x3de6
leaq 0x4268(%rip), %rdi      # 0x804e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3550
movzwl (%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x425c(%rip), %rdi      # 0x805b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3550
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/print.c
// Function: print_metadata
size_t		print_metadata(t_metahead *head, int option)
{
	t_metabody	*body;
	size_t		total;
	size_t		i;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %r13d           # imm = 0x100
xorl %r15d, %r15d
cmpq $0x1000, %r13           # imm = 0x1000
je 0x3e85
movq 0x10(%r14), %r12
cmpw $0x0, (%r12,%r13)
je 0x3e7c
addq %r13, %r12
movq %r12, %rdi
callq 0x3250
movzwl (%r12), %eax
cmpl $0x10, %eax
je 0x3e63
cmpl $0x1001, %eax           # imm = 0x1001
jne 0x3e6a
movq %r12, %rdi
movl %ebx, %esi
callq 0x3610
jmp 0x3e79
movl $0x100, %esi            # imm = 0x100
jmp 0x3e6f
movl $0x80, %esi
movq %r12, %rdi
movl %ebx, %edx
callq 0x33d0
addq %rax, %r15
addq $0x100, %r13            # imm = 0x100
jmp 0x3e26
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log1.c
// Function: log_malloc
int			log_malloc(t_metabody *body, void *ptr, size_t size)
{
	int fd;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
callq 0x35d0
cmpl $-0x1, %eax
je 0x3ff7
cmpl $0x5, %r15d
je 0x4010
cmpl $0x4, %r15d
je 0x3ffc
xorl %ebx, %ebx
cmpl $0x3, %r15d
jne 0x4025
leaq 0x4128(%rip), %rsi      # 0x811d
jmp 0x4003
pushq $0x1
popq %rbx
jmp 0x4025
leaq 0x4144(%rip), %rsi      # 0x8147
xorl %ebx, %ebx
movl %eax, %edi
xorl %eax, %eax
callq 0x3410
jmp 0x4025
leaq 0x4158(%rip), %rsi      # 0x816f
xorl %ebx, %ebx
movl %eax, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3410
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metadata_set
int			log_metadata_set(t_metadata *data, void *l, void *r)
{
	int	fd;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x35d0
cmpl $-0x1, %eax
je 0x4080
testq %r12, %r12
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
jne 0x4086
leaq 0x413b(%rip), %rsi      # 0x81a4
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3410
jmp 0x40bd
pushq $0x1
popq %r14
jmp 0x40bd
testq %r12, %r12
je 0x409f
leaq 0x4136(%rip), %rsi      # 0x81c8
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
jmp 0x40b6
testq %r15, %r15
je 0x40c9
leaq 0x413c(%rip), %rsi      # 0x81e7
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3410
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4136(%rip), %rsi      # 0x8206
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3410
jmp 0x40bd
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/log2_meta.c
// Function: log_metabody_set
int			log_metabody_set(t_metabody *body, t_metahead *head)
{
	int	fd;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x35d0
cmpl $-0x1, %eax
je 0x41c6
testq %r12, %r12
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
jne 0x41cc
leaq 0x40c3(%rip), %rsi      # 0x8272
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3410
jmp 0x4203
pushq $0x1
popq %r14
jmp 0x4203
testq %r12, %r12
je 0x41e5
leaq 0x40c0(%rip), %rsi      # 0x8298
xorl %r14d, %r14d
movl %eax, %edi
movq %r12, %rdx
movq %rbx, %rcx
jmp 0x41fc
testq %r15, %r15
je 0x420f
leaq 0x40c8(%rip), %rsi      # 0x82b9
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3410
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40c4(%rip), %rsi      # 0x82da
xorl %r14d, %r14d
movl %eax, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3410
jmp 0x4203
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get1.c
// Function: get_flag
uint16_t		get_flag(const size_t size)
{
	if (size == 0)
		return (0);
	if ((get_env() & ENV_ZONE) == 0)
		return (get_flag_no_bonus(size));
	if (size <= Z4)
		return (Z4);
	if (size <= Z5)
		return (Z5);
	if (size <= Z6)
		return (Z6);
	if (size <= Z7)
		return (Z7);
	if (size <= Z8)
		return (Z8);
	if (size <= Z9)
		return (Z9);
	if (size <= Z10)
		return (Z10);
	if (size <= Z11)
		return (Z11);
	if (size <= Z12)
		return (Z12);
	return (ZLARGE);
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x34b0
movl %eax, %r14d
callq 0x35c0
movslq %eax, %rcx
testb $0x2, %r14b
jne 0x4338
cmpq $0x100, %rbx            # imm = 0x100
ja 0x4349
shlq $0x3, %rcx
jmp 0x4365
cmpq $0x21, %rbx
jb 0x4365
cmpq $0x40, %rbx
ja 0x4358
addq %rcx, %rcx
jmp 0x4365
cmpq $0x400, %rbx            # imm = 0x400
ja 0x4370
shlq $0x5, %rcx
jmp 0x4365
cmpq $0x80, %rbx
ja 0x4391
shlq $0x2, %rcx
movq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x4368
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
incq %rbx
imulq %rcx, %rbx
jmp 0x4368
cmpq $0x100, %rbx            # imm = 0x100
jbe 0x4332
cmpq $0x200, %rbx            # imm = 0x200
ja 0x43a9
shlq $0x4, %rcx
jmp 0x4365
cmpq $0x400, %rbx            # imm = 0x400
jbe 0x4352
cmpq $0x800, %rbx            # imm = 0x800
ja 0x43c1
shlq $0x6, %rcx
jmp 0x4365
cmpq $0x1000, %rbx           # imm = 0x1000
ja 0x43d0
shlq $0x7, %rcx
jmp 0x4365
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x4368
incq %rax
imulq %rcx, %rax
movq %rax, %rbx
jmp 0x4368
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get2_static.c
// Function: get_env
int	get_env(void)
{
	static int	flag = 0;

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

// Assembly:
movl 0x6fb6(%rip), %eax      # 0xb3a8
testl %eax, %eax
je 0x43f7
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x3ef2(%rip), %rdi      # 0x82f6
callq 0x3030
testq %rax, %rax
je 0x441d
movl $0x2, 0x6f90(%rip)      # 0xb3a8
pushq $0x2
popq %rbx
jmp 0x441f
xorl %ebx, %ebx
leaq 0x3edd(%rip), %rdi      # 0x8303
callq 0x3030
testq %rax, %rax
je 0x4439
orl $0x4, %ebx
movl %ebx, 0x6f6f(%rip)      # 0xb3a8
leaq 0x3ecf(%rip), %rdi      # 0x830f
callq 0x3030
testq %rax, %rax
je 0x4453
orl $0x10, %ebx
movl %ebx, 0x6f55(%rip)      # 0xb3a8
leaq 0x3ec9(%rip), %rdi      # 0x8323
callq 0x3030
movq %rax, %rcx
leal 0x20(%rbx), %eax
testq %rcx, %rcx
cmovel %ebx, %eax
orl $0x1, %eax
movl %eax, 0x6f34(%rip)      # 0xb3a8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
testb $0x4, %al
jne 0x448d
pushq $-0x1
popq %rax
jmp 0x44ab
movl 0x6ed5(%rip), %eax      # 0xb368
cmpl $-0x2, %eax
jne 0x44b1
leaq 0x3e92(%rip), %rdi      # 0x8331
movl $0x242, %esi            # imm = 0x242
xorl %eax, %eax
callq 0x3510
movl %eax, 0x6eb7(%rip)      # 0xb368
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/get3_size.c
// Function: get_body_size
size_t	get_body_size(t_metabody *body)
{
	if (body->id == ZLARGE)
		return (*((size_t *)(body->store)));
	else if (body->id == Z4)
		return (body->id * 256);
	else
		return (body->id * 128);
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x9
popq %rdi
leaq -0x20(%rbp), %rsi
callq 0x35f0
testl %eax, %eax
je 0x450b
xorl %ebx, %ebx
pushq $0x3
popq %rsi
xorl %edi, %edi
callq 0x31c0
jmp 0x4557
cmpq %rbx, -0x20(%rbp)
jae 0x4520
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x31c0
xorl %ebx, %ebx
jmp 0x4557
testl %r14d, %r14d
je 0x4537
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x4022, %ecx           # imm = 0x4022
jmp 0x4546
pushq $0x3
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x3190
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x4563
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
pushq $0x4
jmp 0x4501
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metablock.c
// Function: metablock_get_size
size_t	metablock_get_size(t_metabody *body, const size_t i)
{
	size_t	size;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
cmpw $0x10, (%rdi)
sete %cl
shll $0x4, %ecx
addq $0x10, %rcx
xorl %edx, %edx
movabsq $-0x1, %rax
xorl %esi, %esi
cmpq %rcx, %rsi
je 0x462c
movzbl 0x18(%rdi,%rsi), %r9d
xorl %r8d, %r8d
cmpq $0x8, %r8
je 0x461d
btl %r8d, %r9d
jae 0x4626
incq %r8
jmp 0x460c
incq %rsi
addq $-0x8, %rdx
jmp 0x45fe
subq %rdx, %r8
movq %r8, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metablock.c
// Function: metablock_free
int		metablock_free(t_metabody *body, void *ptr)
{
	size_t	index;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
cmpw $0x0, 0x4(%rdi)
jne 0x4861
movq %rdi, %rbx
movzwl (%rdi), %edi
cmpq $0x1001, %rdi           # imm = 0x1001
jne 0x47bc
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %r15
movzwl 0x2(%rbx), %r13d
movq 0x10(%rbx), %r12
movq 0xb8(%rbx), %rsi
movq %r15, %rdi
jmp 0x4815
leaq 0x10(%rbx), %rax
xorl %r14d, %r14d
xorl %ecx, %ecx
testq %rax, %rax
je 0x4861
xorl %edx, %edx
cmpq $0xf, %rdx
je 0x47ef
xorl %esi, %esi
cmpw %di, 0x30(%rax,%rdx,2)
sete %sil
addq %rsi, %rcx
incq %rdx
cmpq $0x1, %rcx
jbe 0x47d0
jmp 0x47f5
movq 0x8(%rax), %rax
jmp 0x47c5
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %r15
movzwl 0x2(%rbx), %r13d
movq 0x10(%rbx), %r12
callq 0x31d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x34c0
movl %eax, %r14d
movzwl %r13w, %ecx
andw $0x0, 0x30(%r12,%rcx,2)
pushq $-0x2
popq %rax
roll %cl, %eax
andw %ax, 0x4e(%r12)
incq 0x28(%r12)
cmpl $-0x1, %r14d
je 0x484e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3350
jmp 0x4861
movq -0x30(%rbp), %rax
movq (%rax), %rdi
pushq $0x2
popq %rsi
callq 0x3480
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metabody.c
// Function: metabody_get
t_metabody			*metabody_get(const size_t size)
{
	t_metadata	*data;
	t_metahead	*head;
	t_metabody	*body;
	size_t		index;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq -0x28(%rbp), %r14
andq $0x0, (%r14)
movq %rdi, %rbx
movq 0x6754(%rip), %r12      # 0xafe8
movq (%r12), %r15
callq 0x30d0
movzwl %ax, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3200
testq %rax, %rax
je 0x48cc
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x8, %rcx
leaq (%rax,%rcx), %r14
addq $0x100, %r14            # imm = 0x100
jmp 0x4978
movq (%r12), %rdi
leaq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x3200
testq %rax, %rax
je 0x494d
movq %rax, %r15
movq -0x28(%rbp), %r12
movq %rbx, %rdi
callq 0x31d0
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3560
testq %rax, %rax
je 0x4978
movq 0x10(%r15), %rcx
movq %r12, %rdx
shlq $0x8, %rdx
decq 0x28(%r15)
leaq (%rcx,%rdx), %r14
addq $0x100, %r14            # imm = 0x100
movq %r15, 0x10(%r14)
movw %r12w, 0x2(%r14)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x30d0
movw %ax, (%r14)
movw %ax, 0x30(%r15,%r12,2)
andw $0x0, 0x4(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3310
jmp 0x4978
movq 0x6694(%rip), %rdi      # 0xafe8
callq 0x3150
xorl %r14d, %r14d
testq %rax, %rax
je 0x4978
leaq -0x28(%rbp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3200
testq %rax, %rax
jne 0x48e0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/srcs/metadata.c
// Function: metadata_find
t_metahead			*metadata_find(const t_metadata *start,
									const uint16_t flag,
									size_t *index)
{
	t_metahead	*iter;
	size_t		i;

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

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
sete %cl
cmpl $0x1001, %esi           # imm = 0x1001
sete %dil
orb %cl, %dil
je 0x49a3
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
testq %rax, %rax
je 0x49db
cmpq $0x0, 0x28(%rax)
je 0x49d0
xorl %ecx, %ecx
cmpq $0xf, %rcx
je 0x49d0
cmpw %si, 0x30(%rax,%rcx,2)
jne 0x49cb
movzwl 0x4e(%rax), %edi
btl %ecx, %edi
jae 0x49d6
incq %rcx
jmp 0x49b5
movq 0x8(%rax), %rax
jmp 0x49a7
movq %rcx, (%rdx)
popq %rbp
retq
xorl %eax, %eax
jmp 0x49d9