LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/save_path.c
// Function: set_lengths
void	set_lengths(t_info *info, int path_i, int i)
{
	if (info->phase == 1)
	{
		info->rooms[info->index_stack[path_i][0]]->length = i - 1;
		info->rooms[info->index_stack[path_i][0]]->cost = i - 1;
	}
	else
	{
		info->rooms[info->index_stack[path_i][0]]->length_2 = i - 1;
		info->rooms[info->index_stack[path_i][0]]->cost_2 = i - 1;
	}
	if (!(info->rooms[info->index_stack[path_i][0]]->ant_queue)
	&& !(info->rooms[info->index_stack[path_i][0]]->ant_queue =
	(int*)malloc(sizeof(int) * info->ants + 1)))
		exit_error(ERR_MALLOC, info);
	i = 0;
	while (i < info->ants + 1)
	{
		info->rooms[info->index_stack[path_i][0]]->ant_queue[i] = 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x4a4d
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x44(%rax)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x3c(%rax)
jmp 0x4aa9
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x48(%rax)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1048(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4b29
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rdi
shlq $0x2, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x4b29
movq -0x8(%rbp), %rsi
leaq 0x7a85(%rip), %rdi      # 0xc5a9
callq 0x4f60
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4b80
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1048(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4b30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/save_path.c
// Function: save_path
void	save_path(t_info *info, int path_i, int i)
{
	if (info->phase == 2 && info->last_found_used_2 == 0)
		return ;
	while (info->index_stack[path_i][i] != EMPTY)
	{
		copy_path_to_valid_indexes(info, path_i, i);
		i++;
	}
	set_lengths(info, path_i, i);
	i = 0;
	info->phase == 1 ? info->path_n_1++ : info->path_n_2++;
	info->path_saved = 1;
	sort_paths(info);
	if ((info->phase == 1 && enough_paths(info, info->path_n_1 - 1, 0, 0))
	|| (info->phase == 2 && enough_paths(info, info->path_n_2 - 1, 0, 0)))
	{
		info->path_saved = 2;
		return ;
	}
	reset_rooms(info);
	reset_tmp_stacks(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x106c(%rax)
jne 0x4bc1
movq -0x8(%rbp), %rax
cmpl $0x0, 0x188c(%rax)
jne 0x4bc1
jmp 0x4cd6
jmp 0x4bc3
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x4bfa
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4810
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4bc3
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x49d0
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x4c32
movq -0x8(%rbp), %rax
movl 0x1060(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1060(%rax)
jmp 0x4c45
movq -0x8(%rbp), %rax
movl 0x1064(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1064(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1068(%rax)
movq -0x8(%rbp), %rdi
callq 0x6890
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x4c88
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1060(%rax), %esi
subl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4600
cmpl $0x0, %eax
jne 0x4cb4
movq -0x8(%rbp), %rax
cmpl $0x2, 0x106c(%rax)
jne 0x4cc4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1064(%rax), %esi
subl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4600
cmpl $0x0, %eax
je 0x4cc4
movq -0x8(%rbp), %rax
movl $0x2, 0x1068(%rax)
jmp 0x4cd6
movq -0x8(%rbp), %rdi
callq 0x2580
movq -0x8(%rbp), %rdi
callq 0x2360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/delete_dead_end.c
// Function: delete_branch
void	delete_branch(t_info *info, int index)
{
	int		i;
	int		prev;

	i = 0;
	while (info->rooms[index]->links[i] != NULL)
	{
		i++;
		if (i > 2)
			return ;
	}
	prev = find_a_room(info, info->rooms[index]->links[0]);
	if (info->rooms[prev]->level > info->rooms[index]->level)
		prev = find_a_room(info, info->rooms[index]->links[1]);
	free_2d_array(info->rooms[index]->links);
	if (!(info->rooms[index]->links = (char**)malloc(sizeof(char*) * 1)))
		exit_error(ERR_MALLOC, info);
	info->rooms[index]->links[0] = NULL;
	info->ants_at_start += 1;
	if (info->flag_storage & VERBOSE)
		ft_printf(BOLD_GREEN "ROOMS DELETED: %d\n" RESET,
		info->ants_at_start - info->ants);
	delete_branch(info, prev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4d2e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jle 0x4d2c
jmp 0x4e61
jmp 0x4cf6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x4310
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x4c(%rcx), %eax
jle 0x4da9
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4310
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x3a10
movl $0x8, %edi
callq 0x1070
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x4dfc
movq -0x8(%rbp), %rsi
leaq 0x77b2(%rip), %rdi      # 0xc5a9
callq 0x4f60
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4e55
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x8(%rbp), %rax
subl 0x28(%rax), %esi
leaq 0x7935(%rip), %rdi      # 0xc783
movb $0x0, %al
callq 0x7790
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/delete_dead_end.c
// Function: delete_dead_end
void	delete_dead_end(t_info *info, int dead_end)
{
	int		i;
	int		prev;

	i = 0;
	while (info->rooms[dead_end]->links[i] != NULL)
	{
		i++;
		if (i > 1)
			return ;
	}
	prev = find_a_room(info, info->rooms[dead_end]->links[0]);
	if (prev < 0 || prev == info->end_index || info->rooms[prev]->path > -1)
		return ;
	delete_branch(info, prev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4ebb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jle 0x4eb9
jmp 0x4f1d
jmp 0x4e86
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x4310
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4f0f
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x4f0f
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x50(%rax)
jle 0x4f11
jmp 0x4f1d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/error_management.c
// Function: exit_error
void		exit_error(const char *str, t_info *info)
{
	if (info->flag_storage & ERROR)
		ft_putendl_fd(str, 2);
	else
	{
		(void)str;
		ft_putendl_fd("ERROR", 2);
	}
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f92
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6d70
jmp 0x4fa3
leaq 0x7808(%rip), %rdi      # 0xc7a1
movl $0x2, %esi
callq 0x6d70
movl $0x1, %edi
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x34(%rax,%rcx,4)
je 0x4fe9
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x34(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4fbf
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
je 0x5028
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x107c(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ff0
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
je 0x505f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x502f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x0, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x50cf
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
jne 0x50d1
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
jne 0x50d1
jmp 0x5102
jmp 0x50d3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
je 0x50f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50d3
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x107c(%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x5175
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jl 0x5175
movq -0x8(%rbp), %rax
cmpl $0x0, 0x107c(%rax)
jl 0x5175
movq -0x8(%rbp), %rdi
callq 0x4fb0
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1050(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6200
jmp 0x51b3
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1068(%rax)
jne 0x51b1
movq -0x8(%rbp), %rax
movl $0x0, 0x1068(%rax)
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x63a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6200
jmp 0x51b3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x58(%rax), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x2, %edx
cmovel %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x2, 0x58(%rax)
jne 0x522e
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x523b
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2100
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq 0x1058(%rax), %rdi
shlq $0x3, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x1048(%rcx)
cmpq $0x0, %rax
jne 0x52cf
movq -0x8(%rbp), %rsi
leaq 0x72df(%rip), %rdi      # 0xc5a9
callq 0x4f60
jmp 0x52d1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1058(%rcx), %eax
jge 0x535c
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq -0x8(%rbp), %rcx
movq 0x1048(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x5313
movq -0x8(%rbp), %rsi
leaq 0x729b(%rip), %rdi      # 0xc5a9
callq 0x4f60
jmp 0x5315
cmpl $0x201, -0x10(%rbp)     # imm = 0x201
jge 0x5347
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5315
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52d1
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x63a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/parse.c
// Function: parse_map
void		parse_map(t_output *output, t_info *info)
{
	t_output	*tmp;
	t_output	*tmp2;
	char		*line;
	int			rooms;

	tmp2 = output;
	rooms = 0;
	while (get_next_line(info->fd, &line))
	{
		if (!(tmp = (t_output*)malloc(sizeof(t_output))))
			exit_error(ERR_MALLOC, info);
		if (ft_strchr(line, ' ') && line[0] != '#' && line[0] != 'L')
			rooms++;
		if (ft_strchr(line, '-') && !(ft_strchr(line, ' ')))
			info->link_amnt++;
		if (ft_strstr(line, "#Here is the number of lines required:"))
			get_required_lines(info, line);
		tmp->line = ft_strdup(line);
		output->next = tmp;
		output = output->next;
		output->next = NULL;
		free(line);
	}
	run_data_parsing(info, tmp2, rooms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1880(%rax), %edi
leaq -0x28(%rbp), %rsi
callq 0x7b00
cmpl $0x0, %eax
je 0x54c7
movl $0x10, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x53ef
movq -0x10(%rbp), %rsi
leaq 0x71bf(%rip), %rdi      # 0xc5a9
callq 0x4f60
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x5424
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x5424
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
je 0x5424
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2d, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x545f
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0x6e80
cmpq $0x0, %rax
jne 0x545f
movq -0x10(%rbp), %rax
movl 0x1058(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1058(%rax)
movq -0x28(%rbp), %rdi
leaq 0x733d(%rip), %rsi      # 0xc7a7
callq 0x7450
cmpq $0x0, %rax
je 0x5482
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2620
movq -0x28(%rbp), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x53af
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x54e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/parse.c
// Function: run_data_parsing
static void	run_data_parsing(t_info *info, t_output *tmp2, int rooms)
{
	t_output	*tmp;

	tmp = tmp2;
	if (rooms == 0 || info->link_amnt == 0)
		rooms == 0 ? exit_error(ERR_ROOM_NO_ROOMS, info) :
		exit_error(ERR_NO_LINK, info);
	if (!(info->rooms = (t_room**)malloc(sizeof(t_room*) * rooms + 1)))
		exit_error(ERR_MALLOC, info);
	info->rooms[rooms] = NULL;
	info->room_amnt = rooms;
	parse_rooms_and_links(tmp2, info, 0, 0);
	if (!info->start || !info->end)
		!info->start ? exit_error(ERR_ROOM_NO_START, info) :
		exit_error(ERR_ROOM_NO_END, info);
	while (tmp != NULL)
	{
		ft_putendl(tmp->line);
		tmp = tmp->next;
	}
	sort_rooms(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x550e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1058(%rax)
jne 0x5538
cmpl $0x0, -0x14(%rbp)
jne 0x5526
movq -0x8(%rbp), %rsi
leaq 0x72af(%rip), %rdi      # 0xc7ce
callq 0x4f60
jmp 0x5536
movq -0x8(%rbp), %rsi
leaq 0x72b4(%rip), %rdi      # 0xc7e5
callq 0x4f60
jmp 0x5538
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x18a8(%rcx)
cmpq $0x0, %rax
jne 0x556a
movq -0x8(%rbp), %rsi
leaq 0x7044(%rip), %rdi      # 0xc5a9
callq 0x4f60
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1074(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x5620
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x55b4
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x55e3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x55d1
movq -0x8(%rbp), %rsi
leaq 0x7231(%rip), %rdi      # 0xc7fb
callq 0x4f60
jmp 0x55e1
movq -0x8(%rbp), %rsi
leaq 0x7235(%rip), %rdi      # 0xc811
callq 0x4f60
jmp 0x55e3
jmp 0x55e5
cmpq $0x0, -0x20(%rbp)
je 0x5606
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x6d20
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x55e5
movq -0x8(%rbp), %rdi
callq 0x2dd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/parse.c
// Function: parse_rooms_and_links
static void	parse_rooms_and_links(t_output *op, t_info *info, int rms, int lnk)
{
	int			start_end;
	int			tmp;

	tmp = -1;
	while (op != NULL)
	{
		if (!(ft_isprint(op->line[0])))
			return ;
		if (ft_strstr(op->line, "##start") || ft_strstr(op->line, "##end"))
		{
			start_end = validate_command(info, op->line);
			tmp = 2;
		}
		tmp--;
		if (ft_strchr(op->line, ' ') && op->line[0] != '#')
		{
			if (lnk)
				exit_error(ERR_BAD_LINK, info);
			start_end = tmp == 0 ? start_end : 0;
			room_info(info, op->line, rms++, start_end);
		}
		if (ft_strchr(op->line, '-') && !(ft_strchr(op->line, ' ')))
			add_link(info, op->line, lnk++);
		op = op->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x8(%rbp)
je 0x5785
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x6bf0
cmpl $0x0, %eax
jne 0x5661
jmp 0x5785
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x70cc(%rip), %rsi      # 0xc73b
callq 0x7450
cmpq $0x0, %rax
jne 0x5693
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x70d9(%rip), %rsi      # 0xc761
callq 0x7450
cmpq $0x0, %rax
je 0x56ad
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4260
movl %eax, -0x1c(%rbp)
movl $0x2, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x572b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x572b
cmpl $0x0, -0x18(%rbp)
je 0x56f2
movq -0x10(%rbp), %rsi
leaq 0x6fde(%rip), %rdi      # 0xc6cb
callq 0x4f60
cmpl $0x0, -0x20(%rbp)
jne 0x5700
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x5707
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x5707
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %ecx
callq 0x5790
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x5774
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x6e80
cmpq $0x0, %rax
jne 0x5774
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
callq 0x5990
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x563d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/parse.c
// Function: add_link
static int	add_link(t_info *info, char *line, int link)
{
	char		**link_data;

	link_data = ft_strsplit(line, '-');
	add_links_for_rooms(info, link_data[0], link_data[1]);
	if (!info->start)
		exit_error(ERR_ROOM_NO_START, info);
	if (!info->end)
		exit_error(ERR_ROOM_NO_END, info);
	if ((ft_strequ(link_data[0], info->start)
	&& ft_strequ(link_data[1], info->end))
	|| (ft_strequ(link_data[0], info->end)
	&& ft_strequ(link_data[1], info->start)))
		info->start_end_link = 1;
	free_2d_array(link_data);
	return (link);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2d, %esi
callq 0x7260
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x4040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x59e8
movq -0x8(%rbp), %rsi
leaq 0x6e18(%rip), %rdi      # 0xc7fb
callq 0x4f60
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5a02
movq -0x8(%rbp), %rsi
leaq 0x6e14(%rip), %rdi      # 0xc811
callq 0x4f60
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x7080
cmpl $0x0, %eax
je 0x5a34
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x7080
cmpl $0x0, %eax
jne 0x5a66
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x7080
cmpl $0x0, %eax
je 0x5a74
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x7080
cmpl $0x0, %eax
je 0x5a74
movq -0x8(%rbp), %rax
movl $0x1, 0x1884(%rax)
movq -0x20(%rbp), %rdi
callq 0x3a10
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
je 0x5b48
movl $0x0, -0x10(%rbp)
movl $0x5b, %edi
callq 0x6cf0
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x5b2e
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x5b80
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5ad0
leaq 0x6d13(%rip), %rdi      # 0xc848
callq 0x6e40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5aa3
movl $0xa, %edi
callq 0x6cf0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1064(%rax)
jle 0x5b6c
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x5cd0
movl $0xa, %edi
callq 0x6cf0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: path_color
static void		path_color(char *room, int n)
{
	int			color;

	color = n % 10;
	if (color == 0)
		ft_printf(WHITE "%s" RESET " ", room);
	else if (color == 1)
		ft_printf(GREEN "%s" RESET " ", room);
	else if (color == 2)
		ft_printf(YELLOW "%s" RESET " ", room);
	else if (color == 3)
		ft_printf(BLUE "%s" RESET " ", room);
	else if (color == 4)
		ft_printf(MAGENTA "%s" RESET " ", room);
	else if (color == 5)
		ft_printf(CYAN "%s" RESET " ", room);
	else if (color == 6)
		ft_printf(RED "%s" RESET " ", room);
	else if (color == 7)
		ft_printf(BOLD_GREEN "%s" RESET " ", room);
	else if (color == 8)
		ft_printf(BOLD_YELLOW "%s" RESET " ", room);
	else if (color == 9)
		ft_printf(BOLD_CYAN "%s" RESET " ", room);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x5bba
movq -0x8(%rbp), %rsi
leaq 0x6c9d(%rip), %rdi      # 0xc84b
movb $0x0, %al
callq 0x7790
jmp 0x5cc0
cmpl $0x1, -0x10(%rbp)
jne 0x5bd7
movq -0x8(%rbp), %rsi
leaq 0x6c8f(%rip), %rdi      # 0xc85a
movb $0x0, %al
callq 0x7790
jmp 0x5cbe
cmpl $0x2, -0x10(%rbp)
jne 0x5bf4
movq -0x8(%rbp), %rsi
leaq 0x6c81(%rip), %rdi      # 0xc869
movb $0x0, %al
callq 0x7790
jmp 0x5cbc
cmpl $0x3, -0x10(%rbp)
jne 0x5c11
movq -0x8(%rbp), %rsi
leaq 0x6c73(%rip), %rdi      # 0xc878
movb $0x0, %al
callq 0x7790
jmp 0x5cba
cmpl $0x4, -0x10(%rbp)
jne 0x5c2e
movq -0x8(%rbp), %rsi
leaq 0x6c65(%rip), %rdi      # 0xc887
movb $0x0, %al
callq 0x7790
jmp 0x5cb8
cmpl $0x5, -0x10(%rbp)
jne 0x5c48
movq -0x8(%rbp), %rsi
leaq 0x6c57(%rip), %rdi      # 0xc896
movb $0x0, %al
callq 0x7790
jmp 0x5cb6
cmpl $0x6, -0x10(%rbp)
jne 0x5c62
movq -0x8(%rbp), %rsi
leaq 0x6c4c(%rip), %rdi      # 0xc8a5
movb $0x0, %al
callq 0x7790
jmp 0x5cb4
cmpl $0x7, -0x10(%rbp)
jne 0x5c7c
movq -0x8(%rbp), %rsi
leaq 0x6c41(%rip), %rdi      # 0xc8b4
movb $0x0, %al
callq 0x7790
jmp 0x5cb2
cmpl $0x8, -0x10(%rbp)
jne 0x5c96
movq -0x8(%rbp), %rsi
leaq 0x6c36(%rip), %rdi      # 0xc8c3
movb $0x0, %al
callq 0x7790
jmp 0x5cb0
cmpl $0x9, -0x10(%rbp)
jne 0x5cae
movq -0x8(%rbp), %rsi
leaq 0x6c2c(%rip), %rdi      # 0xc8d3
movb $0x0, %al
callq 0x7790
jmp 0x5cb0
jmp 0x5cb2
jmp 0x5cb4
jmp 0x5cb6
jmp 0x5cb8
jmp 0x5cba
jmp 0x5cbc
jmp 0x5cbe
jmp 0x5cc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: print_other_paths
static void		print_other_paths(t_info *info, int i, int y)
{
	ft_putstr("OR\n");
	while (info->valid_indexes_2[y][0] != EMPTY)
	{
		ft_putchar('[');
		while (info->valid_indexes_2[y][i] != EMPTY)
		{
			path_color(info->rooms[info->valid_indexes_2[y][i]]->name, y);
			i++;
		}
		ft_putstr("]\n");
		i = 0;
		y++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x6bf9(%rip), %rdi      # 0xc8e2
callq 0x6e40
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
je 0x5d93
movl $0x5b, %edi
callq 0x6cf0
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x5d72
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x5b80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5d14
leaq 0x6acf(%rip), %rdi      # 0xc848
callq 0x6e40
movl $0x0, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5cee
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x5de9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x5e50
jmp 0x5e3d
movl $0x1, %edi
leaq 0x6be1(%rip), %rsi      # 0xc9d6
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x6e40
movl $0x1, %edi
leaq 0x6bb0(%rip), %rsi      # 0xc9c4
movl $0x1, %edx
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x6e40
movl $0x1, %edi
leaq 0x6b36(%rip), %rsi      # 0xc969
movl $0x1, %edx
callq 0x1040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: ant_color
static void		ant_color(char *ant, char *room, int color)
{
	if (color == 0)
		ft_printf(WHITE "L%s-%s" RESET " ", ant, room);
	else if (color == 1)
		ft_printf(GREEN "L%s-%s" RESET " ", ant, room);
	else if (color == 2)
		ft_printf(YELLOW "L%s-%s" RESET " ", ant, room);
	else if (color == 3)
		ft_printf(BLUE "L%s-%s" RESET " ", ant, room);
	else if (color == 4)
		ft_printf(MAGENTA "L%s-%s" RESET " ", ant, room);
	else if (color == 5)
		ft_printf(CYAN "L%s-%s" RESET " ", ant, room);
	else if (color == 6)
		ft_printf(RED "L%s-%s" RESET " ", ant, room);
	else if (color == 7)
		ft_printf(BOLD_GREEN "L%s-%s" RESET " ", ant, room);
	else if (color == 8)
		ft_printf(BOLD_YELLOW "L%s-%s" RESET " ", ant, room);
	else if (color == 9)
		ft_printf(BOLD_CYAN "L%s-%s" RESET " ", ant, room);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5e84
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a6e(%rip), %rdi      # 0xc8e6
movb $0x0, %al
callq 0x7790
jmp 0x5fae
cmpl $0x1, -0x14(%rbp)
jne 0x5ea5
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a60(%rip), %rdi      # 0xc8f9
movb $0x0, %al
callq 0x7790
jmp 0x5fac
cmpl $0x2, -0x14(%rbp)
jne 0x5ec6
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a52(%rip), %rdi      # 0xc90c
movb $0x0, %al
callq 0x7790
jmp 0x5faa
cmpl $0x3, -0x14(%rbp)
jne 0x5ee7
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a44(%rip), %rdi      # 0xc91f
movb $0x0, %al
callq 0x7790
jmp 0x5fa8
cmpl $0x4, -0x14(%rbp)
jne 0x5f08
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a36(%rip), %rdi      # 0xc932
movb $0x0, %al
callq 0x7790
jmp 0x5fa6
cmpl $0x5, -0x14(%rbp)
jne 0x5f26
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a28(%rip), %rdi      # 0xc945
movb $0x0, %al
callq 0x7790
jmp 0x5fa4
cmpl $0x6, -0x14(%rbp)
jne 0x5f44
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a1d(%rip), %rdi      # 0xc958
movb $0x0, %al
callq 0x7790
jmp 0x5fa2
cmpl $0x7, -0x14(%rbp)
jne 0x5f62
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a12(%rip), %rdi      # 0xc96b
movb $0x0, %al
callq 0x7790
jmp 0x5fa0
cmpl $0x8, -0x14(%rbp)
jne 0x5f80
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x6a07(%rip), %rdi      # 0xc97e
movb $0x0, %al
callq 0x7790
jmp 0x5f9e
cmpl $0x9, -0x14(%rbp)
jne 0x5f9c
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x69fd(%rip), %rdi      # 0xc992
movb $0x0, %al
callq 0x7790
jmp 0x5f9e
jmp 0x5fa0
jmp 0x5fa2
jmp 0x5fa4
jmp 0x5fa6
jmp 0x5fa8
jmp 0x5faa
jmp 0x5fac
jmp 0x5fae
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x1070(%rax)
jne 0x6057
jmp 0x5fe9
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x34(%rax,%rcx,4)
je 0x601e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x107c(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5fe9
jmp 0x6020
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x6055
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movl 0x107c(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
jmp 0x6020
jmp 0x6084
movq -0x8(%rbp), %rax
cmpl $0x3, 0x1070(%rax)
jne 0x6074
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x60c0
jmp 0x6082
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x60c0
jmp 0x6084
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x201, %eax            # imm = 0x201
jge 0x60b0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x608b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, 0x34(%rax,%rcx,4)
je 0x6121
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0x107c(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, 0x34(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x60dd
cmpl $0x1, -0xc(%rbp)
jne 0x6137
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x6148
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x2, -0xc(%rbp)
movb %al, -0x19(%rbp)
jne 0x616f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6178
jmp 0x61e1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x107c(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movl %edx, 0x34(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
jne 0x61d0
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x61d6
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x614e
cmpl $0x1, -0xc(%rbp)
jne 0x61f3
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6520
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movslq %eax, %rdx
xorl %eax, %eax
cmpl $-0x1, 0x34(%rcx,%rdx,4)
movb %al, -0x19(%rbp)
je 0x6242
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1068(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x624e
jmp 0x6386
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x62a8
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x4c(%rax)
jle 0x62a8
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x50(%rax)
jge 0x62a8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4e70
jmp 0x62aa
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rcx
movslq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x1a(%rbp)
je 0x62e2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1068(%rax)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x62eb
jmp 0x635e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4310
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x6348
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x51c0
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
jne 0x6359
jmp 0x635e
jmp 0x62aa
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movl $0x0, -0x10(%rbp)
jmp 0x6215
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x5110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x201, -0x10(%rbp)     # imm = 0x201
jge 0x63d9
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, 0x34(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x63b5
jmp 0x63db
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1078(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x64cb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1078(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4310
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x64bd
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x4c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x63db
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1070(%rax)
jle 0x64e1
movq -0x8(%rbp), %rdi
callq 0x5fc0
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1078(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl $0x2, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1050(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: to_left
static void	to_left(t_info *info, int i)
{
	int		t;
	int		stop;

	t = -1;
	stop = 0;
	while (i >= 0)
	{
		info->check_rooms[++t] = info->tmp_string[i];
		info->tmp_string[i] = EMPTY;
		i--;
		if (i == -1)
		{
			if (stop)
				return ;
			i = 512;
			stop++;
			while (info->tmp_string[i] == EMPTY)
				i--;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x65c4
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x107c(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, 0x34(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x65bf
cmpl $0x0, -0x14(%rbp)
je 0x6590
jmp 0x65c4
movl $0x200, -0xc(%rbp)      # imm = 0x200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x107c(%rax,%rcx,4)
jne 0x65bd
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x65a0
jmp 0x65bf
jmp 0x6539
popq %rbp
retq
nopw %cs:(%rax,%rax)