LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: copy_check_rooms
void	copy_check_rooms(t_info *info)
{
	int		i;

	i = 0;
	while (info->check_rooms[i] != EMPTY)
	{
		info->check_rooms[i] = EMPTY;
		i++;
	}
	i = 0;
	while (info->tmp_string[i] != EMPTY)
	{
		info->check_rooms[i] = info->tmp_string[i];
		i++;
	}
	i = 0;
	while (info->tmp_string[i] != EMPTY)
	{
		info->tmp_string[i] = EMPTY;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x34(%rdi)
je 0x34d2
leaq 0x38(%rdi), %rax
movl $0xffffffff, -0x4(%rax) # imm = 0xFFFFFFFF
cmpl $-0x1, (%rax)
leaq 0x4(%rax), %rax
jne 0x34c2
movl 0x107c(%rdi), %eax
cmpl $-0x1, %eax
je 0x3515
leaq 0x1080(%rdi), %rcx
movl %eax, -0x104c(%rcx)
movl (%rcx), %eax
addq $0x4, %rcx
cmpl $-0x1, %eax
jne 0x34e4
cmpl $-0x1, 0x107c(%rdi)
je 0x3515
addq $0x1080, %rdi           # imm = 0x1080
movl $0xffffffff, -0x4(%rdi) # imm = 0xFFFFFFFF
cmpl $-0x1, (%rdi)
leaq 0x4(%rdi), %rdi
jne 0x3505
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: add_to_next_round
void	add_to_next_round(t_info *info, int s, int i)
{
	int		t;

	t = 0;
	s += 0;
	if (i == info->end_index
	|| (info->rooms[s]->flow == 1 && info->rooms[i]->flow == 1))
		return ;
	while (info->tmp_string[t] != EMPTY)
		t++;
	info->tmp_string[t] = i;
}

// Assembly:
cmpl %edx, 0x103c(%rdi)
je 0x3558
movq 0x18a8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rcx
cmpl $0x1, 0x38(%rcx)
jne 0x3540
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
je 0x3558
pushq %rbp
movq %rsp, %rbp
addq $0x107c, %rdi           # imm = 0x107C
cmpl $-0x1, (%rdi)
leaq 0x4(%rdi), %rdi
jne 0x354b
movl %edx, -0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: start_over_or_continue
void	start_over_or_continue(t_info *info, int index)
{
	if (index != info->end_index && info->check_rooms[0] >= 0
	&& info->tmp_string[0] >= 0)
	{
		copy_check_rooms(info);
		info->level++;
		find_paths(info, -1, 0, 0);
	}
	else if (info->path_saved == 1)
	{
		info->path_saved = 0;
		get_links_for_start(info, 0, 0, 0);
		find_paths(info, -1, 0, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl %esi, 0x103c(%rdi)
je 0x3589
cmpl $0x0, 0x34(%rbx)
js 0x3589
cmpl $0x0, 0x107c(%rbx)
js 0x3589
movq %rbx, %rdi
callq 0x34b4
incl 0x1050(%rbx)
jmp 0x35aa
cmpl $0x1, 0x1068(%rbx)
jne 0x35c1
movl $0x0, 0x1068(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x410f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3fe6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: set_visited
void	set_visited(t_info *info, int s, int l)
{
	info->rooms[l]->visited = info->rooms[l]->start_or_end == 2 ? 0 : 1;
	info->rooms[l]->level = info->rooms[l]->start_or_end == 2
	? INT_MAX : info->level;
	add_to_path(info, s, l, -1);
	add_to_next_round(info, s, l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0x18a8(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
cmpl $0x2, 0x58(%rax)
movl %esi, %r15d
setne %cl
movl %ecx, 0x5c(%rax)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0x3602
movl 0x1050(%r14), %ecx
movl %ecx, 0x4c(%rax)
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x19f6
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3517
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: get_links
void	get_links(t_info *info)
{
	int		i;
	int		t;

	i = 0;
	t = 0;
	if (!(info->index_stack = (int**)malloc(sizeof(int*) * info->link_amnt)))
		exit_error(ERR_MALLOC, info);
	while (i < info->link_amnt)
	{
		if (!(info->index_stack[i] = (int*)malloc(sizeof(int) * 513)))
			exit_error(ERR_MALLOC, info);
		while (t < 513)
		{
			info->index_stack[i][t] = EMPTY;
			t++;
		}
		t = 0;
		i++;
	}
	get_links_for_start(info, 0, 0, 0);
	find_paths(info, -1, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x1058(%rdi), %r14
movq %r14, %rdi
shlq $0x3, %rdi
callq 0x1080
movq %rax, 0x1048(%rbx)
testq %rax, %rax
jne 0x3671
leaq 0x3f47(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x348b
movl 0x1058(%rbx), %r14d
testl %r14d, %r14d
jle 0x36ce
movq 0x1048(%rbx), %r12
xorl %r15d, %r15d
leaq 0x3f22(%rip), %r14      # 0x75a9
movl $0x804, %edi            # imm = 0x804
callq 0x1080
movq %rax, (%r12,%r15,8)
testq %rax, %rax
jne 0x36a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x348b
movq 0x1048(%rbx), %r12
movq (%r12,%r15,8), %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
incq %r15
movslq 0x1058(%rbx), %rax
cmpq %rax, %r15
jl 0x3687
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x410f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3fe6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: print_paths
void			print_paths(t_info *info)
{
	int			y;
	int			i;

	y = 0;
	while (info->valid_indexes[y][0] != EMPTY)
	{
		i = 0;
		ft_putchar('[');
		while (info->valid_indexes[y][i] != EMPTY)
		{
			path_color(info->rooms[info->valid_indexes[y][i]]->name, y);
			i++;
		}
		ft_putstr("]\n");
		y++;
	}
	ft_putchar('\n');
	if (info->path_n_2 > 0)
		print_other_paths(info, 0, 0);
	ft_putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1898(%rdi), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
je 0x3cae
xorl %r14d, %r14d
leaq 0x3c33(%rip), %r15      # 0x7872
movl $0x5b, %edi
callq 0x4574
movq 0x1898(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax), %eax
cmpl $-0x1, %eax
je 0x3c92
movl $0x4, %r12d
movq 0x18a8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdi
movl %r14d, %esi
callq 0x3d6b
movq 0x1898(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r12), %eax
addq $0x4, %r12
cmpl $-0x1, %eax
jne 0x3c61
movq %r15, %rdi
callq 0x4668
movq 0x1898(%rbx), %rax
movq 0x8(%rax,%r14,8), %rax
incq %r14
cmpl $-0x1, (%rax)
jne 0x3c3f
movl $0xa, %edi
callq 0x4574
cmpl $0x0, 0x1064(%rbx)
jle 0x3d59
leaq 0x3c40(%rip), %rdi      # 0x790c
callq 0x4668
movq 0x18a0(%rbx), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
je 0x3d59
xorl %r14d, %r14d
leaq 0x3b88(%rip), %r15      # 0x7872
movl $0x5b, %edi
callq 0x4574
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax), %eax
cmpl $-0x1, %eax
je 0x3d3d
movl $0x4, %r12d
movq 0x18a8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdi
movl %r14d, %esi
callq 0x3d6b
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r12), %eax
addq $0x4, %r12
cmpl $-0x1, %eax
jne 0x3d0c
movq %r15, %rdi
callq 0x4668
movq 0x18a0(%rbx), %rax
movq 0x8(%rax,%r14,8), %rax
incq %r14
cmpl $-0x1, (%rax)
jne 0x3cea
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4574
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: print_ant
void			print_ant(char *ant, t_info *info, int i, char *room)
{
	int			color;

	color = i % 10;
	if (info->flag_storage & VERBOSE)
		ant_color(ant, room, color);
	else
	{
		write(1, "L", 1);
		ft_putstr(ant);
		write(1, "-", 1);
		ft_putstr(room);
		write(1, " ", 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testb $0x40, 0x1040(%rsi)
jne 0x3e1e
leaq 0x3c82(%rip), %rsi      # 0x7a51
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
movq %r14, %rdi
callq 0x4668
leaq 0x3c52(%rip), %rsi      # 0x7a3f
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
movq %rbx, %rdi
callq 0x4668
leaq 0x3b88(%rip), %rsi      # 0x7993
movl $0x1, %edx
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $0x9, %eax
ja 0x3e62
movl %eax, %eax
leaq 0x3bae(%rip), %rcx      # 0x79f8
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4adc
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: reorder_check_rooms
void		reorder_check_rooms(t_info *info)
{
	int		i;
	int		t;

	i = 0;
	t = 0;
	if (info->round == 2)
	{
		while (info->check_rooms[i] != EMPTY)
		{
			info->tmp_string[i] = info->check_rooms[i];
			i++;
		}
		while (--i >= 0)
			info->check_rooms[i] = info->tmp_string[t++];
	}
	else if (info->round == 3)
		from_the_middle(info, 2);
	else
		from_the_middle(info, 1);
	i = -1;
	while (++i < 513)
		info->tmp_string[i] = EMPTY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1070(%rdi), %eax
cmpl $0x3, %eax
je 0x3ec1
cmpl $0x2, %eax
jne 0x3ec8
movl 0x34(%rbx), %eax
cmpl $-0x1, %eax
je 0x3ed5
xorl %ecx, %ecx
movl %eax, 0x107c(%rbx,%rcx,4)
movl 0x38(%rbx,%rcx,4), %eax
incq %rcx
cmpl $-0x1, %eax
jne 0x3e8b
movl %ecx, %eax
leaq (%rbx,%rax,4), %rcx
addq $0x30, %rcx
xorl %edx, %edx
movl 0x107c(%rbx,%rdx,4), %esi
incq %rdx
movl %esi, (%rcx)
addq $-0x4, %rcx
cmpq %rdx, %rax
jne 0x3eaa
jmp 0x3ed5
movl $0x2, %esi
jmp 0x3ecd
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3ef4
addq $0x107c, %rbx           # imm = 0x107C
movl $0x804, %edx            # imm = 0x804
movq %rbx, %rdi
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: from_the_middle
static void	from_the_middle(t_info *info, int direction)
{
	int		i;
	int		t;

	i = -1;
	t = -1;
	while (info->check_rooms[++i] != EMPTY)
	{
		info->tmp_string[i] = info->check_rooms[i];
		info->check_rooms[i] = EMPTY;
	}
	i = direction == 1 ? i / 2 : i / 2 + 1;
	while (direction == 2 && info->tmp_string[i] != EMPTY)
	{
		info->check_rooms[++t] = info->tmp_string[i];
		info->tmp_string[i] = EMPTY;
		i++;
		i = info->tmp_string[i] == EMPTY ? 0 : i;
	}
	if (direction == 1)
		to_left(info, i);
}

// Assembly:
leaq 0x34(%rdi), %rax
movl 0x34(%rdi), %ecx
cmpl $-0x1, %ecx
je 0x3f27
xorl %edx, %edx
movl %ecx, 0x1048(%rax,%rdx,4)
movl $0xffffffff, (%rax,%rdx,4) # imm = 0xFFFFFFFF
movl 0x4(%rax,%rdx,4), %ecx
incq %rdx
cmpl $-0x1, %ecx
jne 0x3f02
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
jmp 0x3f29
xorl %ecx, %ecx
cmpl $0x1, %esi
je 0x3f94
cmpl $0x2, %esi
jne 0x3fe5
movslq %ecx, %rsi
movl 0x1080(%rdi,%rsi,4), %ecx
cmpl $-0x1, %ecx
je 0x3fe5
pushq %rbp
movq %rsp, %rbp
leal 0x1(%rsi), %edx
leaq (%rdi,%rsi,4), %rsi
addq $0x1080, %rsi           # imm = 0x1080
addq $0x107c, %rdi           # imm = 0x107C
movl %ecx, (%rax)
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
movslq %edx, %rcx
xorl %r8d, %r8d
cmpl $-0x1, 0x4(%rdi,%rcx,4)
je 0x3f7d
incl %edx
movl %edx, %r8d
movslq %r8d, %rcx
leaq (%rdi,%rcx,4), %rsi
movl (%rsi), %ecx
addq $0x4, %rax
movl %r8d, %edx
cmpl $-0x1, %ecx
jne 0x3f63
popq %rbp
retq
testl %ecx, %ecx
js 0x3fe5
xorl %edx, %edx
movq $-0x1, %rax
movl %ecx, %esi
movl 0x107c(%rdi,%rsi,4), %r8d
movl %r8d, 0x38(%rdi,%rax,4)
movl $0xffffffff, 0x107c(%rdi,%rsi,4) # imm = 0xFFFFFFFF
subl $0x1, %ecx
jae 0x3fde
testl %edx, %edx
jne 0x3fe5
movl $0x61f, %ecx            # imm = 0x61F
cmpl $-0x1, (%rdi,%rcx,4)
leaq -0x1(%rcx), %rcx
je 0x3fc9
addl $0xfffffbe2, %ecx       # imm = 0xFFFFFBE2
movl $0x1, %edx
incq %rax
testl %ecx, %ecx
jns 0x3fa1
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: find_paths
void		find_paths(t_info *info, int i, int j, int s)
{
	int		l;

	while (info->check_rooms[++i] != EMPTY && info->path_saved == 0)
	{
		s = info->check_rooms[i];
		if (info->phase == 1 && info->rooms[s]->level > 1
		&& info->rooms[s]->path < 0)
			delete_dead_end(info, s);
		while (info->rooms[s]->links[j] != NULL
		&& info->path_saved == 0)
		{
			l = find_a_room(info,
			info->rooms[s]->links[j++]);
			if (info->rooms[l]->visited == 0)
				set_visited(info, s, l);
			if (l == info->end_index)
				break ;
		}
		info->rooms[s]->visited++;
		j = 0;
	}
	start_over_or_continue(info, l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r12
movl 0x38(%rdi,%r12,4), %r8d
incq %r12
movslq %edx, %r15
cmpl $0x0, 0x1068(%rbx)
jne 0x40f6
cmpl $0x1, 0x106c(%rbx)
movq 0x18a8(%rbx), %rax
movslq %r8d, %r13
jne 0x404f
movq (%rax,%r13,8), %rcx
cmpl $0x2, 0x4c(%rcx)
jl 0x404f
cmpl $0x0, 0x50(%rcx)
jns 0x404f
movq %rbx, %rdi
movl %r8d, %esi
movl %r8d, -0x2c(%rbp)
callq 0x33f7
movl -0x2c(%rbp), %r8d
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rcx
movq 0x8(%rcx), %rdx
movq (%rdx,%r15,8), %rsi
testq %rsi, %rsi
je 0x4071
movl %r8d, -0x2c(%rbp)
cmpl $0x0, 0x1068(%rbx)
je 0x408e
movq (%rax,%r13,8), %rcx
incl 0x5c(%rcx)
movl 0x38(%rbx,%r12,4), %r8d
incq %r12
movl $0x0, %r15d
cmpl $-0x1, %r8d
jne 0x4005
jmp 0x40f6
leaq 0x8(,%r15,8), %r15
movq %rbx, %rdi
callq 0x2d20
movl %eax, %r14d
movq 0x18a8(%rbx), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rcx
cmpl $0x0, 0x5c(%rcx)
jne 0x40ca
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
movl %r14d, %edx
callq 0x35c8
movq 0x18a8(%rbx), %rax
cmpl 0x103c(%rbx), %r14d
je 0x406d
movq (%rax,%r13,8), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx,%r15), %rsi
testq %rsi, %rsi
je 0x406d
addq $0x8, %r15
cmpl $0x0, 0x1068(%rbx)
je 0x4096
jmp 0x406d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3559
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: get_links_for_start
void		get_links_for_start(t_info *info, int i, int s, int t)
{
	while (s < 513)
	{
		info->check_rooms[s] = EMPTY;
		s++;
	}
	while (info->rooms[info->start_index]->links[i] != NULL)
	{
		s = find_a_room(info, info->rooms[info->start_index]->links[i]);
		if (info->rooms[s]->visited == 0)
		{
			info->rooms[s]->visited = 1;
			info->rooms[s]->level = info->level;
			info->index_stack[t][0] = s;
			info->check_rooms[t] = s;
			t++;
		}
		i++;
	}
	if (info->round > 1)
		reorder_check_rooms(info);
	info->rooms[info->start_index]->visited = 2;
	info->level++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x200, %edx            # imm = 0x200
jg 0x414e
movslq %edx, %rax
leaq (%rbx,%rax,4), %rdi
addq $0x34, %rdi
movl $0x200, %eax            # imm = 0x200
subl %edx, %eax
leaq 0x4(,%rax,4), %rdx
movl $0xff, %esi
callq 0x1060
movq 0x18a8(%rbx), %rcx
movslq 0x1078(%rbx), %rax
movq (%rcx,%rax,8), %rdx
movq 0x8(%rdx), %rsi
movslq %r15d, %rdx
movq (%rsi,%rdx,8), %rsi
testq %rsi, %rsi
je 0x41d8
leaq 0x8(,%rdx,8), %r15
movq %rbx, %rdi
callq 0x2d20
movq 0x18a8(%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, 0x5c(%rdx)
jne 0x41bc
movl $0x1, 0x5c(%rdx)
movl 0x1050(%rbx), %esi
movl %esi, 0x4c(%rdx)
movq 0x1048(%rbx), %rdx
movslq %r14d, %r14
movq (%rdx,%r14,8), %rdx
movl %eax, (%rdx)
movl %eax, 0x34(%rbx,%r14,4)
incl %r14d
movslq 0x1078(%rbx), %rax
movq (%rcx,%rax,8), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx,%r15), %rsi
addq $0x8, %r15
testq %rsi, %rsi
jne 0x4178
cmpl $0x2, 0x1070(%rbx)
jl 0x41f6
movq %rbx, %rdi
callq 0x3e68
movq 0x18a8(%rbx), %rcx
movl 0x1078(%rbx), %eax
cltq
movq (%rcx,%rax,8), %rax
movl $0x2, 0x5c(%rax)
incl 0x1050(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/sort_paths.c
// Function: swap_paths
void	swap_paths(t_info *info, int top, int stack)
{
	int		i;
	int		swap[513];

	i = -1;
	while (++i < 513)
		swap[i] = EMPTY;
	i = -1;
	while (stack == 1 && ++i < 513)
		swap[i] = info->valid_indexes[top][i];
	i = -1;
	while (stack == 1 && ++i < 513)
		info->valid_indexes[top][i] = info->valid_indexes[top + 1][i];
	i = -1;
	while (stack == 1 && ++i < 513)
		info->valid_indexes[top + 1][i] = swap[i];
	i = -1;
	while (stack == 2 && ++i < 513)
		swap[i] = info->valid_indexes_2[top][i];
	i = -1;
	while (stack == 2 && ++i < 513)
		info->valid_indexes_2[top][i] = info->valid_indexes_2[top + 1][i];
	i = -1;
	while (stack == 2 && ++i < 513)
		info->valid_indexes_2[top + 1][i] = swap[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x820(%rbp), %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
movslq %r15d, %rax
cmpl $0x1, %r14d
jne 0x42c4
movq 0x1898(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq $-0x2, %rdx
movl 0x8(%rcx,%rdx,4), %esi
movl %esi, -0x818(%rbp,%rdx,4)
incq %rdx
cmpq $0x1ff, %rdx            # imm = 0x1FF
jl 0x425e
cmpl $0x1, %r14d
jne 0x42c4
movq 0x1898(%rbx), %rcx
movq (%rcx,%rax,8), %rdx
movq 0x8(%rcx,%rax,8), %rcx
movq $-0x2, %rsi
movl 0x8(%rcx,%rsi,4), %edi
movl %edi, 0x8(%rdx,%rsi,4)
incq %rsi
cmpq $0x1ff, %rsi            # imm = 0x1FF
jl 0x4292
movq $-0x2, %rdx
movl -0x818(%rbp,%rdx,4), %esi
movl %esi, 0x8(%rcx,%rdx,4)
incq %rdx
cmpq $0x1ff, %rdx            # imm = 0x1FF
jl 0x42ad
cmpl $0x2, %r14d
jne 0x4342
movq 0x18a0(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq $-0x2, %rdx
movl 0x8(%rcx,%rdx,4), %esi
movl %esi, -0x818(%rbp,%rdx,4)
incq %rdx
cmpq $0x1ff, %rdx            # imm = 0x1FF
jl 0x42dc
cmpl $0x2, %r14d
jne 0x4342
movq 0x18a0(%rbx), %rdx
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rax
movq $-0x2, %rdx
movl 0x8(%rax,%rdx,4), %esi
movl %esi, 0x8(%rcx,%rdx,4)
incq %rdx
cmpq $0x1ff, %rdx            # imm = 0x1FF
jl 0x4310
movq $-0x2, %rcx
movl -0x818(%rbp,%rcx,4), %edx
movl %edx, 0x8(%rax,%rcx,4)
incq %rcx
cmpq $0x1ff, %rcx            # imm = 0x1FF
jl 0x432b
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/sort_paths.c
// Function: sort_paths
void	sort_paths(t_info *info)
{
	int		i;

	i = -1;
	while (info->path_n_1 > 1 && info->valid_indexes[++i + 1][0] != EMPTY)
	{
		if (info->rooms[info->valid_indexes[i + 1][0]]->length
		< info->rooms[info->valid_indexes[i][0]]->length)
		{
			swap_paths(info, i, 1);
			i = -1;
		}
	}
	i = -1;
	while (info->path_n_2 > 1 && info->valid_indexes_2[++i + 1][0] != EMPTY)
	{
		if (info->rooms[info->valid_indexes_2[i + 1][0]]->length_2
		< info->rooms[info->valid_indexes_2[i][0]]->length_2)
		{
			swap_paths(info, i, 2);
			i = -1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1060(%rdi), %eax
cmpl $0x2, %eax
jl 0x43c1
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x1898(%rbx), %rcx
movslq %esi, %rdx
movq 0x10(%rcx,%rdx,8), %rdx
movslq (%rdx), %rdx
cmpq $-0x1, %rdx
je 0x43c1
incl %esi
movq 0x18a8(%rbx), %rdi
movq (%rdi,%rdx,8), %rdx
movl 0x44(%rdx), %edx
movslq %esi, %r8
movq (%rcx,%r8,8), %rcx
movslq (%rcx), %rcx
movq (%rdi,%rcx,8), %rcx
cmpl 0x44(%rcx), %edx
jge 0x43bc
movq %rbx, %rdi
movl $0x1, %edx
callq 0x4214
movl 0x1060(%rbx), %eax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
jg 0x4369
movl 0x1064(%rbx), %eax
cmpl $0x2, %eax
jl 0x4429
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x18a0(%rbx), %rcx
movslq %esi, %rdx
movq 0x10(%rcx,%rdx,8), %rdx
movslq (%rdx), %rdx
cmpq $-0x1, %rdx
je 0x4429
incl %esi
movq 0x18a8(%rbx), %rdi
movq (%rdi,%rdx,8), %rdx
movl 0x48(%rdx), %edx
movslq %esi, %r8
movq (%rcx,%r8,8), %rcx
movslq (%rcx), %rcx
movq (%rdi,%rcx,8), %rcx
cmpl 0x48(%rcx), %edx
jge 0x4424
movq %rbx, %rdi
movl $0x2, %edx
callq 0x4214
movl 0x1064(%rbx), %eax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
jg 0x43d1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	int		res;
	int		sign;

	res = 0;
	sign = 1;
	while (*str && (*str == '\r' || *str == '\n' || *str == '\t' ||
					*str == '\f' || *str == '\v' || *str == ' '))
		str++;
	if (str[0] == '-')
		sign = -1;
	if (*str == '+' || *str == '-')
		str++;
	while (*str && *str >= '0' && *str <= '9')
	{
		res = res * 10 + (*str - 48);
		if (res > 999999)
			return (-1);
		str++;
	}
	if (*str && !ft_isdigit(*str))
		exit_error_no_info("ERROR: Coordinate not Int!");
	return (res * sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
incq %rdi
movb -0x1(%rdi), %bl
movzbl %bl, %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jb 0x4437
cmpl $0x20, %eax
je 0x4437
cmpl $0x2b, %eax
je 0x4457
cmpl $0x2d, %eax
jne 0x445b
movb (%rdi), %al
jmp 0x4460
decq %rdi
movl %ebx, %eax
leal -0x30(%rax), %ecx
xorl %r14d, %r14d
cmpb $0x9, %cl
ja 0x4494
incq %rdi
xorl %r14d, %r14d
leal (%r14,%r14,4), %ecx
addb $-0x30, %al
movzbl %al, %eax
leal (%rax,%rcx,2), %r14d
cmpl $0xf423f, %r14d         # imm = 0xF423F
jg 0x44be
movb (%rdi), %al
leal -0x30(%rax), %ecx
incq %rdi
cmpb $0x9, %cl
jbe 0x4471
testb %al, %al
je 0x44b0
movsbl %al, %edi
callq 0x44c8
testl %eax, %eax
jne 0x44b0
leaq 0x3575(%rip), %rdi      # 0x7a20
callq 0x346c
movl %r14d, %eax
negl %eax
cmpb $0x2d, %bl
cmovnel %r14d, %eax
jmp 0x44c3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_itoa.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	size_t		count;
	long		nbr;
	char		*str;

	nbr = (long)n;
	count = ft_nbrcount((intmax_t)n);
	if (!(str = ft_strnew(count)))
		return (NULL);
	count--;
	if (nbr == 0)
		str[0] = '0';
	if (nbr < 0)
	{
		str[0] = '-';
		nbr *= -1;
	}
	while (nbr > 0)
	{
		str[count] = nbr % 10 + '0';
		nbr /= 10;
		count--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq %edi, %r14
movq %r14, %rdi
callq 0x4a3c
movq %rax, %rbx
movq %rax, %rdi
callq 0x4840
movq %rax, %rcx
testq %rax, %rax
je 0x456c
movq %r14, %rsi
negq %rsi
cmovsq %r14, %rsi
testl %r14d, %r14d
jg 0x4532
sete %al
movzbl %al, %eax
leal 0x2d(%rax,%rax,2), %eax
movb %al, (%rcx)
je 0x456c
leaq (%rbx,%rcx), %rdi
decq %rdi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %esi, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rdi)
decq %rdi
cmpq $0x9, %rsi
movq %rdx, %rsi
ja 0x4543
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putendl.c
// Function: ft_putendl
void	ft_putendl(char const *s)
{
	int len;

	if (s)
	{
		len = ft_strlen(s);
		write(1, s, len);
		ft_putchar('\n');
	}
}

// Assembly:
testq %rdi, %rdi
je 0x45cb
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x481c
movslq %eax, %rdx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1040
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4574
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char const *s, int fd)
{
	int len;

	if (s)
	{
		len = ft_strlen(s);
		write(fd, s, len);
		ft_putchar_fd('\n', fd);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x45ff
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x481c
movslq %eax, %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1040
movl $0xa, %edi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4e7c
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putnbr.c
// Function: ft_putnbr
void	ft_putnbr(int n)
{
	long	k;

	k = n;
	if (n < 0)
	{
		ft_putchar('-');
		k = k * -1;
	}
	if (k / 10 > 0)
		ft_putnbr(k / 10);
	ft_putchar('0' + k % 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rbx
testl %ebx, %ebx
jns 0x461a
movl $0x2d, %edi
callq 0x4574
negq %rbx
cmpq $0xa, %rbx
jl 0x4634
movl %ebx, %eax
movl $0xcccccccd, %edi       # imm = 0xCCCCCCCD
imulq %rax, %rdi
shrq $0x23, %rdi
callq 0x4600
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x2, %edx
addl %eax, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %ebx
addb $0x30, %bl
movsbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4574
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	int i;

	i = 0;
	while (s[i])
	{
		if (s[i] == c)
			return ((char*)(s + i));
		i++;
	}
	if (s[i] == '\0' && c == '\0')
		return ((char*)(s + i));
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x46b0
movsbl %cl, %ecx
cmpl %esi, %ecx
je 0x46bd
movb 0x1(%rdi,%rax), %cl
incq %rax
jmp 0x469c
addq %rax, %rdi
xorl %eax, %eax
testl %esi, %esi
cmoveq %rdi, %rax
jmp 0x46c3
addq %rax, %rdi
movq %rdi, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int	i;

	i = 0;
	while (s1[i] && s2[i] && s1[i] == s2[i])
		++i;
	return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
xorl %ecx, %ecx
testb %al, %al
je 0x46eb
cmpb (%rsi,%rcx), %al
jne 0x46e6
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x46d4
xorl %eax, %eax
movzbl %al, %eax
jmp 0x46ed
xorl %eax, %eax
movzbl (%rsi,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	int		i;
	int		c;
	char	*dst;

	i = 0;
	c = 0;
	while (s1[i])
		i++;
	dst = (char*)ft_memalloc(sizeof(*dst) * (i + 1));
	if (!dst)
		return (NULL);
	while (c < i)
	{
		dst[c] = s1[c];
		c++;
	}
	dst[c] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x4729
movl %r14d, %edi
callq 0x4e44
testq %rax, %rax
je 0x4764
cmpq $0x1, %r14
jne 0x474c
xorl %r14d, %r14d
jmp 0x475f
decq %r14
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x4751
movb $0x0, (%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strequ.c
// Function: ft_strequ
int		ft_strequ(char const *s1, char const *s2)
{
	while (s1[0] != '\0' && !(*(s1) ^ *(s2)))
	{
		s1++;
		s2++;
	}
	return (!(*(s1) ^ *(s2)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %cl
testb %cl, %cl
je 0x4789
incq %rdi
cmpb (%rsi), %cl
jne 0x478b
incq %rsi
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x4779
xorl %ecx, %ecx
xorl %eax, %eax
cmpb (%rsi), %cl
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	int		a;
	int		b;
	int		x;
	char	*joint;

	if (!s1 || !s2)
		return (NULL);
	a = ft_strlen(s1);
	b = ft_strlen(s2);
	x = 0;
	if (!(joint = ft_strnew(a + b)))
		return (NULL);
	joint = ft_strcpy(joint, s1);
	while (x < b)
	{
		joint[a + x] = s2[x];
		x++;
	}
	return (joint);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x480c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x481c
movq %rax, %r12
movq %rbx, %rdi
callq 0x481c
movq %rax, %r14
addl %r12d, %eax
movslq %eax, %rdi
callq 0x4840
testq %rax, %rax
je 0x480f
movq %rax, %rdi
movq %r15, %rsi
callq 0x4ea0
testl %r14d, %r14d
jle 0x4811
movslq %r12d, %rdx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rax, %rcx
addq %rdx, %rcx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x47fa
jmp 0x4811
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsplit.c
// Function: ft_strsplit
char		**ft_strsplit(char const *s, char c)
{
	unsigned int	i;
	size_t			start;
	char			**str;
	int				y;

	y = 0;
	i = 0;
	start = 0;
	if (!s)
		return (NULL);
	if (!(str = (char**)ft_memalloc(sizeof(char*) * (ft_count(s, (int)c) + 1))))
		return (NULL);
	while (y < ft_count(s, (int)c))
	{
		while (s[i] == (int)c)
			i++;
		start = i;
		while (s[i] && s[i] != (int)c)
			i++;
		if (!(str[y] = ft_strsub(s, start, (i - start))))
			return (NULL);
		i++;
		y++;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4941
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %dl
testb %dl, %dl
je 0x48a6
leaq 0x1(%r14), %rcx
xorl %eax, %eax
cmpb %bl, %dl
je 0x4891
movb (%rcx), %dl
cmpb %bl, %dl
sete %sil
testb %dl, %dl
sete %dl
orb %sil, %dl
movzbl %dl, %edx
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x4878
cltq
leaq 0x8(,%rax,8), %rdi
jmp 0x48ab
movl $0x8, %edi
callq 0x4e44
testq %rax, %rax
je 0x4941
movq %rax, %r15
leaq 0x1(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movb (%r14), %dl
testb %dl, %dl
je 0x48fd
xorl %eax, %eax
movq -0x30(%rbp), %rcx
cmpb %bl, %dl
je 0x48f0
movb (%rcx), %dl
cmpb %bl, %dl
sete %sil
testb %dl, %dl
sete %dl
orb %sil, %dl
movzbl %dl, %edx
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x48d7
cltq
jmp 0x48ff
xorl %eax, %eax
cmpq %rax, %r13
jge 0x4944
movl %r12d, %eax
incl %r12d
cmpb %bl, (%r14,%rax)
je 0x4904
movl %r12d, %esi
decl %esi
movl %esi, %r12d
movl %r12d, %edx
movb (%r14,%rdx), %cl
incl %r12d
testb %cl, %cl
je 0x492a
cmpb %bl, %cl
jne 0x4918
subq %rax, %rdx
movq %r14, %rdi
callq 0x49ac
movq %rax, (%r15,%r13,8)
incq %r13
testq %rax, %rax
jne 0x48ca
xorl %r15d, %r15d
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_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strstr.c
// Function: ft_strstr
char	*ft_strstr(const char *haystack, const char *needle)
{
	int	i;
	int	t;

	i = 0;
	t = 0;
	if (needle[t] == '\0')
		return ((char*)haystack);
	while (haystack[i])
	{
		t = 0;
		while (haystack[i + t] == needle[t])
		{
			t++;
			if (needle[t] == '\0')
				return ((char*)haystack + (i));
		}
		i++;
	}
	return (NULL);
}

// Assembly:
movb (%rsi), %cl
testb %cl, %cl
je 0x49a3
cmpb $0x0, (%rdi)
je 0x49a7
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rdi, %rdx
xorl %r8d, %r8d
movl %ecx, %r10d
xorl %r9d, %r9d
cmpb %r10b, (%rdx,%r9)
jne 0x498a
movb 0x1(%rsi,%r9), %r10b
incq %r9
testb %r10b, %r10b
jne 0x4975
jmp 0x499b
incq %rdx
cmpb $0x0, 0x1(%rdi,%r8)
leaq 0x1(%r8), %r8
jne 0x496f
jmp 0x49a1
addq %r8, %rdi
movq %rdi, %rax
popq %rbp
retq
movq %rdi, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsub.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char			*sub;
	size_t			i;
	unsigned int	index;

	if (!s)
		return (NULL);
	sub = (char*)malloc(sizeof(char) * (len + 1));
	i = 0;
	index = 0;
	if (!sub || start > ft_strlen(s))
		return (NULL);
	while (s[start] != '\0' && i < len)
	{
		sub[index] = s[start];
		index++;
		start++;
		i++;
	}
	sub[index] = '\0';
	return (sub);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x49e9
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leaq 0x1(%rdx), %rdi
callq 0x1080
testq %rax, %rax
je 0x49e9
movq %rax, %rbx
movl %r15d, %r13d
movq %r12, %rdi
callq 0x481c
cmpq %r13, %rax
jae 0x49fd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb (%r12,%r13), %al
testb %al, %al
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x4a34
incl %r15d
xorl %ecx, %ecx
movl %ecx, %edx
movl %ecx, %esi
movb %al, (%rbx,%rsi)
incq %rcx
leal (%r15,%rdx), %eax
movb (%r12,%rax), %al
testb %al, %al
je 0x4a30
cmpq %r14, %rcx
jb 0x4a15
movl %ecx, %eax
jmp 0x4a36
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
jmp 0x49eb
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_nbrcount.c
// Function: ft_nbrcount
size_t	ft_nbrcount(intmax_t nbr)
{
	size_t count;

	count = 0;
	if (nbr == 0)
		return (1);
	if (nbr < 0)
	{
		nbr *= -1;
		count++;
	}
	while (nbr > 0)
	{
		nbr /= 10;
		count++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x4a75
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
shrq $0x3f, %rdi
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
incq %rdi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x4a5d
jmp 0x4a7a
movl $0x1, %edi
movq %rdi, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: set_ids
t_tags	*set_ids(t_tags *ids)
{
	ids->i = 0;
	ids->printed_chars = 0;
	ids->flag = "#0 +-";
	ids->arg_type = "%cCspdDiouxXf";
	ids->modifiers = "hlL";
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
leaq 0x2fa6(%rip), %rcx      # 0x7a3b
movq %rcx, 0x8(%rdi)
leaq 0x2fa1(%rip), %rcx      # 0x7a41
movq %rcx, 0x48(%rdi)
leaq 0x2fa4(%rip), %rcx      # 0x7a4f
movq %rcx, 0x50(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: ft_printf
int		ft_printf(const char *format, ...)
{
	t_tags	*ids;

	if (!(ids = (t_tags*)malloc(sizeof(t_tags))))
		return (-1);
	ids->format = format;
	set_ids(ids);
	if (format)
	{
		va_start(ids->arguments, format);
		read_format(ids);
		va_end(ids->arguments);
	}
	free(ids);
	return (ids->printed_chars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r14
movq %rsi, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rcx, -0xa8(%rbp)
movq %r8, -0xa0(%rbp)
movq %r9, -0x98(%rbp)
testb %al, %al
je 0x4b37
movaps %xmm0, -0x90(%rbp)
movaps %xmm1, -0x80(%rbp)
movaps %xmm2, -0x70(%rbp)
movaps %xmm3, -0x60(%rbp)
movaps %xmm4, -0x50(%rbp)
movaps %xmm5, -0x40(%rbp)
movaps %xmm6, -0x30(%rbp)
movaps %xmm7, -0x20(%rbp)
movl $0x80, %edi
callq 0x1080
testq %rax, %rax
je 0x4baf
movq %rax, %rbx
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
leaq 0x2ee1(%rip), %rax      # 0x7a3b
movq %rax, 0x8(%rbx)
leaq 0x2edc(%rip), %rax      # 0x7a41
movq %rax, 0x48(%rbx)
leaq 0x2edf(%rip), %rax      # 0x7a4f
movq %rax, 0x50(%rbx)
testq %r14, %r14
je 0x4ba2
leaq -0xc0(%rbp), %rax
movq %rax, 0x78(%rbx)
leaq 0x10(%rbp), %rax
movq %rax, 0x70(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, 0x68(%rbx)
movq %rbx, %rdi
callq 0x4c69
movq %rbx, %rdi
callq 0x1030
movl 0x30(%rbx), %eax
jmp 0x4bb4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/set_tags_and_print.c
// Function: read_arg_type
t_tags			*read_arg_type(t_tags *ids)
{
	if (ids->current_type == 'c')
		print_c(ids);
	if (ids->current_type == 's')
		print_s(ids);
	if (ids->current_type == 'p')
		print_p(ids);
	if (ids->current_type == 'd' || ids->current_type == 'i')
		print_d(ids);
	if (ids->current_type == '%')
		print_percent(ids);
	if (ids->current_type == 'o')
		print_o(ids);
	if (ids->current_type == 'u')
		print_u(ids);
	if (ids->current_type == 'x' || ids->current_type == 'X')
		print_x(ids);
	if (ids->current_type == 'f')
		print_f(ids);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x5e(%rdi), %al
cmpb $0x63, %al
jne 0x4bdb
movq %rbx, %rdi
callq 0x4ec4
movb 0x5e(%rbx), %al
cmpb $0x73, %al
jne 0x4bea
movq %rbx, %rdi
callq 0x542c
movb 0x5e(%rbx), %al
cmpb $0x70, %al
jne 0x4bf9
movq %rbx, %rdi
callq 0x52e0
movb 0x5e(%rbx), %al
cmpb $0x69, %al
je 0x4c05
movzbl %al, %ecx
cmpl $0x64, %ecx
jne 0x4c10
movq %rbx, %rdi
callq 0x5f4f
movb 0x5e(%rbx), %al
cmpb $0x25, %al
jne 0x4c1f
movq %rbx, %rdi
callq 0x621c
movb 0x5e(%rbx), %al
cmpb $0x6f, %al
jne 0x4c2e
movq %rbx, %rdi
callq 0x60bc
movb 0x5e(%rbx), %al
cmpb $0x75, %al
jne 0x4c3d
movq %rbx, %rdi
callq 0x63ce
movb 0x5e(%rbx), %al
movzbl %al, %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x4c53
movq %rbx, %rdi
callq 0x5520
movb 0x5e(%rbx), %al
cmpb $0x66, %al
jne 0x4c5f
movq %rbx, %rdi
callq 0x4f4c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/set_tags_and_print.c
// Function: read_format
int				read_format(t_tags *ids)
{
	while (ids->format[ids->i])
	{
		if (ids->format[ids->i] == '%' && ids->format[ids->i + 1] == '%')
		{
			write(1, &ids->format[ids->i], 1);
			ids->i += 2;
			ids->printed_chars++;
		}
		else if (ids->format[ids->i] == '%')
			call_identifier_readers(ids);
		else
		{
			write(1, &ids->format[ids->i], 1);
			ids->printed_chars++;
			ids->i++;
		}
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rsi
movq 0x28(%rbx), %rax
movzbl (%rsi,%rax), %ecx
addq %rax, %rsi
cmpl $0x25, %ecx
je 0x4ca2
testl %ecx, %ecx
je 0x4d06
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
incq 0x28(%rbx)
jmp 0x4c72
cmpb $0x25, 0x1(%rsi)
jne 0x4cc2
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
addq $0x2, 0x28(%rbx)
incq 0x30(%rbx)
jmp 0x4c72
incq %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x4ab1
movq %rbx, %rdi
callq 0x5809
movq %rbx, %rdi
callq 0x57a5
movq %rbx, %rdi
callq 0x572d
movq %rbx, %rdi
callq 0x56b4
movq %rbx, %rdi
callq 0x5674
movq %rbx, %rdi
callq 0x4bc0
jmp 0x4c72
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/get_next_line.c
// Function: get_next_line
int			get_next_line(const int fd, char **line)
{
	char		buff[BUFF_SIZE + 1];
	static char	*str[MAX_FD];
	char		*ptr;
	int			ret;

	if (!line || fd > MAX_FD || fd < 0)
		return (-1);
	if (str[fd] == NULL)
		if (!(str[fd] = ft_strnew(0)))
			return (-1);
	while ((ret = read(fd, buff, BUFF_SIZE)) > 0)
	{
		buff[ret] = '\0';
		ptr = ft_strjoin(str[fd], buff);
		free(str[fd]);
		str[fd] = ptr;
		if (ft_strchr(str[fd], '\n'))
			break ;
	}
	if (ret < 0)
		return (-1);
	if (ret == 0 && str[fd][0] == '\0')
		return (0);
	else
		return (rest_of_line(&str[fd], line));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
sete %al
cmpl $0x1301, %edi           # imm = 0x1301
setae %cl
orb %al, %cl
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jne 0x4e2b
movq %rsi, %r14
movl %edi, %r12d
movl %edi, %eax
leaq 0x6323(%rip), %rcx      # 0xb070
leaq (%rcx,%rax,8), %rbx
cmpq $0x0, (%rbx)
jne 0x4d6a
xorl %edi, %edi
callq 0x4840
movq %rax, (%rbx)
testq %rax, %rax
je 0x4e2b
movq %r14, -0x38(%rbp)
leaq -0x2a(%rbp), %r13
movl $0x1, %edx
movl %r12d, %edi
movq %r13, %rsi
callq 0x1070
testl %eax, %eax
jle 0x4dc0
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, -0x2a(%rbp,%rax)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x4794
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
movq %r14, %rdi
movl $0xa, %esi
callq 0x4694
testq %rax, %rax
je 0x4d72
movq (%rbx), %rdi
jmp 0x4dca
js 0x4e2b
movq (%rbx), %rdi
cmpb $0x0, (%rdi)
je 0x4e3d
xorl %r15d, %r15d
movq -0x38(%rbp), %r14
movzbl (%rdi,%r15), %eax
testl %eax, %eax
je 0x4e10
cmpl $0xa, %eax
je 0x4de4
incq %r15
jmp 0x4dd1
xorl %esi, %esi
movq %r15, %rdx
callq 0x49ac
movq %rax, (%r14)
movq (%rbx), %rax
leaq (%rax,%r15), %rdi
incq %rdi
callq 0x471c
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
jmp 0x4e25
xorl %esi, %esi
movq %r15, %rdx
callq 0x49ac
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x46f8
movl $0x1, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x4e2b
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	int i;

	i = 0;
	while (src[i] != '\0')
	{
		dst[i] = src[i];
		i++;
	}
	dst[i] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movb (%rsi), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x4ebb
movb %dl, (%rax,%rcx)
movb 0x1(%rsi,%rcx), %dl
incq %rcx
jmp 0x4eab
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_c.c
// Function: print_c
t_tags	*print_c(t_tags *ids)
{
	char	c;

	c = (char)va_arg(ids->arguments, int);
	if (ids->minwth > 0 && ids->current_flag[4] == '\0')
		minwth_print(ids, 1);
	write(1, &c, 1);
	ids->printed_chars++;
	if (ids->minwth > 0 && ids->current_flag[4] != '\0')
		minwth_print(ids, 1);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4ee5
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x4ef1
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movb (%rax), %al
movb %al, -0x9(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0x4f10
cmpb $0x0, 0x5c(%rbx)
jne 0x4f10
movl $0x1, %esi
movq %rbx, %rdi
callq 0x6764
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x4f41
cmpb $0x0, 0x5c(%rbx)
je 0x4f41
movl $0x1, %esi
movq %rbx, %rdi
callq 0x6764
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_p.c
// Function: print_p
t_tags			*print_p(t_tags *ids)
{
	uintmax_t	ptr;
	char		*str;

	ptr = (unsigned long)va_arg(ids->arguments, unsigned long int);
	str = imaxtoa_base(ptr, 16);
	if (ids->minwth > 0 && ids->current_flag[4] != '-')
		minwth_print(ids, ft_strlen(str) + 2);
	ft_putstr("0x");
	if (ids->period == 1 && ids->maxwth == 0 && ptr == 0)
	{
		ids->printed_chars += 2;
		period_zero(ids);
		return (ids);
	}
	if ((ids->current_flag[1] == '0' && ft_strlen(str) + 2 < ids->minwth &&
	ids->minwth > 0) || (ids->period == 1 && ids->maxwth > ft_strlen(str)))
		put_zero_p(ids, ft_strlen(str));
	ft_putstr(str);
	ids->printed_chars += ft_strlen(str) + 2;
	if (ids->current_flag[4] == '-' && ((ids->maxwth >= ft_strlen(str) + 2
	&& ids->period == 1) || ids->minwth > 0))
		minwth_print(ids, ft_strlen(str) + 2);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5305
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5311
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x5aea
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x5345
cmpb $0x2d, 0x5c(%rbx)
je 0x5345
movq %r14, %rdi
callq 0x481c
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x6764
leaq 0x274e(%rip), %rdi      # 0x7a9a
callq 0x4668
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5365
orq 0x20(%rbx), %r15
je 0x541d
cmpb $0x30, 0x59(%rbx)
jne 0x5381
movq %r14, %rdi
callq 0x481c
addq $0x2, %rax
cmpq 0x10(%rbx), %rax
jb 0x5398
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x53ab
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x481c
cmpq %rax, %r15
jbe 0x53ab
movq %r14, %rdi
callq 0x481c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x65a4
movq %r14, %rdi
callq 0x4668
movq %r14, %rdi
callq 0x481c
movq 0x30(%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x30(%rbx)
cmpb $0x2d, 0x5c(%rbx)
jne 0x5407
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x481c
addq $0x2, %rax
cmpq %rax, %r15
jb 0x53ec
cmpq $0x1, 0x18(%rbx)
je 0x53f3
cmpq $0x0, 0x10(%rbx)
je 0x5407
movq %r14, %rdi
callq 0x481c
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x6764
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x2, 0x30(%rbx)
movq %rbx, %rdi
callq 0x62dc
jmp 0x540f
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_s.c
// Function: print_s
t_tags			*print_s(t_tags *ids)
{
	char	*str;
	size_t	len;

	str = va_arg(ids->arguments, char*);
	if (str == NULL)
		str = "(null)";
	if (ids->period == 1 && ids->maxwth < ft_strlen(str))
		str = ft_strsub(str, 0, ids->maxwth);
	else
		str = ft_strsub(str, 0, ft_strlen(str));
	len = ft_strlen(str);
	if (ids->minwth > 0 && ids->current_flag[4] == '\0'
		&& ids->current_flag[1] == '\0')
		minwth_print(ids, len);
	if (ids->current_flag[1] == '0' && len < ids->minwth)
		put_zero_df(ids, len);
	ft_putstr(str);
	ids->printed_chars += len;
	if (ids->minwth > 0 && ids->current_flag[4] == '-')
		minwth_print(ids, len);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5451
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x545d
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %rax
testq %rax, %rax
leaq 0x2633(%rip), %r14      # 0x7a9d
cmovneq %rax, %r14
cmpq $0x1, 0x18(%rbx)
jne 0x548c
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x481c
cmpq %rax, %r15
jae 0x548c
movq 0x20(%rbx), %rdx
jmp 0x5497
movq %r14, %rdi
callq 0x481c
movq %rax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x49ac
movq %rax, %r14
movq %rax, %rdi
callq 0x481c
movq %rax, %r15
cmpq $0x0, 0x10(%rbx)
je 0x54cd
cmpb $0x0, 0x5c(%rbx)
jne 0x54cd
cmpb $0x0, 0x59(%rbx)
jne 0x54cd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
cmpb $0x30, 0x59(%rbx)
jne 0x54e4
cmpq 0x10(%rbx), %r15
jae 0x54e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x649c
movq %r14, %rdi
callq 0x4668
addq %r15, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x5508
cmpb $0x2d, 0x5c(%rbx)
jne 0x5508
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop