LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/handle_paths.c
// Function: create_fork
void	create_fork(t_info *info, int room_i, int y, int t)
{
	int		s;
	int		note;
	int		fork;

	fork = 0;
	note = y;
	while (info->rooms[room_i]->links[t] != NULL && fork == 0)
	{
		s = find_a_room(info, info->rooms[room_i]->links[t]);
		if ((info->rooms[room_i]->level <= info->rooms[s]->level
		|| info->rooms[s]->level == -1) && s != info->end_index)
			fork++;
		else if (info->phase == 2 && s != info->end_index)
			fork++;
		t++;
	}
	if (fork)
	{
		t = -1;
		while (info->index_stack[y][0] != EMPTY)
			y++;
		while (info->index_stack[note][++t] != EMPTY)
			info->index_stack[y][t] = info->index_stack[note][t];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movslq %esi, %r15
movq 0x18a8(%rdi), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdx
movslq %ecx, %rax
movq (%rdx,%rax,8), %rsi
testq %rsi, %rsi
je 0x19d0
movq %rdi, %r14
leaq 0x8(,%rax,8), %r12
movq %r14, %rdi
callq 0x2d20
movq 0x18a8(%r14), %rdx
movq (%rdx,%r15,8), %rcx
movslq %eax, %rsi
movq (%rdx,%rsi,8), %rdx
movl 0x4c(%rdx), %edx
cmpl %edx, 0x4c(%rcx)
jle 0x1961
cmpl $-0x1, %edx
jne 0x196a
cmpl 0x103c(%r14), %eax
jne 0x1999
movb $0x1, %dl
cmpl $0x2, 0x106c(%r14)
jne 0x1980
cmpl 0x103c(%r14), %eax
sete %dl
testb %dl, %dl
je 0x1995
movq 0x8(%rcx), %rax
movq (%rax,%r12), %rsi
addq $0x8, %r12
testq %rsi, %rsi
jne 0x193a
testb %dl, %dl
jne 0x19d0
movq 0x1048(%r14), %rcx
movslq %ebx, %rdx
leaq (%rcx,%rdx,8), %rsi
movq (%rsi), %rax
addq $0x8, %rsi
cmpl $-0x1, (%rax)
jne 0x19a7
movq (%rcx,%rdx,8), %rcx
movl (%rcx), %edx
cmpl $-0x1, %edx
je 0x19d0
xorl %esi, %esi
movl %edx, (%rax,%rsi)
movl 0x4(%rcx,%rsi), %edx
addq $0x4, %rsi
cmpl $-0x1, %edx
jne 0x19c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/handle_paths.c
// Function: add_to_path
void	add_to_path(t_info *info, int last, int next, int y)
{
	int		last_room;
	int		i;

	i = 0;
	if (info->rooms[last]->flow == 1 && info->rooms[next]->flow == 1)
		return ;
	while (info->index_stack[++y][0] != EMPTY)
	{
		last_room = last_on_path(info->index_stack[y]);
		if ((info->phase == 1 && info->rooms[last]->path < 0 && last_room
		== last) || (info->phase == 2 && info->rooms[last]->path_2 < 0
		&& last_room == last))
		{
			create_fork(info, last, y, 0);
			while (info->index_stack[y][i] != EMPTY)
				i++;
			info->index_stack[y][i] = next;
			if (next == info->end_index)
				save_path(info, y, 0);
			return ;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movq 0x18a8(%rdi), %rdx
movslq %esi, %rax
movq (%rdx,%rax,8), %rax
cmpl $0x1, 0x38(%rax)
jne 0x1a2b
movslq %r14d, %rdi
movq (%rdx,%rdi,8), %rdx
cmpl $0x1, 0x38(%rdx)
je 0x1ad6
movq 0x1048(%rbx), %rdx
movslq %ecx, %r15
movq 0x8(%rdx,%r15,8), %rdi
cmpl $-0x1, (%rdi)
je 0x1ad6
incq %r15
movl 0x106c(%rbx), %ecx
movq $-0x1, %r8
cmpl $-0x1, 0x8(%rdi,%r8,4)
leaq 0x1(%r8), %r8
jne 0x1a53
movl %r8d, %r8d
movl (%rdi,%r8,4), %edi
cmpl $0x2, %ecx
je 0x1a78
cmpl $0x1, %ecx
jne 0x1a82
cmpl $0x0, 0x50(%rax)
js 0x1a7e
jmp 0x1a82
cmpl $0x0, 0x54(%rax)
jns 0x1a82
cmpl %esi, %edi
je 0x1a91
movq 0x8(%rdx,%r15,8), %rdi
incq %r15
cmpl $-0x1, (%rdi)
jne 0x1a4c
jmp 0x1ad6
movq %rbx, %rdi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x1900
movq 0x1048(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $-0x1, (%rax)
leaq 0x4(%rax), %rax
jne 0x1aa9
movl %r14d, -0x4(%rax)
cmpl %r14d, 0x103c(%rbx)
jne 0x1ad6
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31c3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/parse_ants.c
// Function: parse_ants
void		parse_ants(t_info *info, t_output *output)
{
	if (ft_isint(output->line))
	{
		if (!(info->flag_storage & ANTS))
		{
			info->ants = ft_atoi(output->line);
			if (info->ants < 1)
				exit_error(ERR_ANTS, info);
		}
		info->ants_at_start = info->ants;
	}
	else
		exit_error(ERR_ANTS, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movb (%r15), %al
incq %r15
movsbl %al, %edi
callq 0x44c8
testl %eax, %eax
je 0x1b7e
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x1b30
testb $0x1, 0x1040(%rbx)
jne 0x1b6d
movq (%r14), %rdi
callq 0x4430
movl %eax, 0x28(%rbx)
testl %eax, %eax
jg 0x1b6d
leaq 0x59b3(%rip), %rdi      # 0x7518
movq %rbx, %rsi
callq 0x348b
movl 0x28(%rbx), %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5993(%rip), %rdi      # 0x7518
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x348b
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: reset_tmp_stacks
void	reset_tmp_stacks(t_info *info)
{
	int		i;
	int		y;

	i = 0;
	y = 0;
	while (i < 513)
	{
		info->tmp_string[i] = EMPTY;
		info->check_rooms[i] = EMPTY;
		i++;
	}
	i = 0;
	while (y < info->link_amnt)
	{
		while (i < 513)
		{
			info->index_stack[y][i] = EMPTY;
			i++;
		}
		i = 0;
		y++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x34, %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
xorl %eax, %eax
movl $0xffffffff, 0x107c(%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq $0x201, %rax            # imm = 0x201
jne 0x1bba
cmpl $0x0, 0x1058(%rbx)
jle 0x1c05
movq 0x1048(%rbx), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
incq %r15
movslq 0x1058(%rbx), %rax
cmpq %rax, %r15
jl 0x1be3
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/reset_paths.c
// Function: room_on_valid_path
int		room_on_valid_path(t_info *info, int i)
{
	int		y;
	int		t;

	y = -1;
	t = -1;
	while (info->phase == 1 && info->valid_indexes[++y][0] != EMPTY)
	{
		while (info->valid_indexes[y][++t] != EMPTY)
		{
			if (info->valid_indexes[y][t] == i)
				return (1);
		}
		t = -1;
	}
	while (info->phase == 2 && info->valid_indexes_2[++y][0] != EMPTY)
	{
		while (info->valid_indexes_2[y][++t] != EMPTY)
		{
			if (info->valid_indexes_2[y][t] == i)
				return (1);
		}
		t = -1;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x106c(%rdi), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x1c5e
movq 0x1898(%rdi), %rdx
movq (%rdx), %r8
cmpl $-0x1, (%r8)
je 0x1c62
xorl %r9d, %r9d
movl (%r8), %r10d
cmpl $-0x1, %r10d
je 0x1c48
addq $0x4, %r8
cmpl %esi, %r10d
jne 0x1c34
jmp 0x1c9a
movq 0x8(%rdx,%r9,8), %r8
incq %r9
cmpl $-0x1, (%r8)
jne 0x1c34
movslq %r9d, %rdx
incq %rdx
jmp 0x1c67
xorl %edx, %edx
jmp 0x1c67
movl $0x1, %edx
cmpl $0x2, %ecx
jne 0x1c9f
movq 0x18a0(%rdi), %rcx
movq (%rcx,%rdx,8), %rdi
cmpl $-0x1, (%rdi)
je 0x1c9f
movl (%rdi), %r8d
cmpl $-0x1, %r8d
je 0x1c90
addq $0x4, %rdi
cmpl %esi, %r8d
jne 0x1c7c
jmp 0x1c9a
movq 0x8(%rcx,%rdx,8), %rdi
incq %rdx
jmp 0x1c77
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: reset_rooms
void	reset_rooms(t_info *info)
{
	int		i;

	i = 0;
	info->level = 1;
	while (info->rooms[i] != NULL)
	{
		if (room_on_valid_path(info, i) && i != info->end_index)
			info->rooms[i]->visited = 2;
		else
			info->rooms[i]->visited = 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, 0x1050(%rdi)
movq 0x18a8(%rdi), %r15
movq (%r15), %r12
testq %r12, %r12
je 0x1cfe
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1c10
testl %eax, %eax
je 0x1cea
movl 0x103c(%rbx), %ecx
movl $0x2, %eax
cmpq %rcx, %r14
jne 0x1cec
xorl %eax, %eax
movl %eax, 0x5c(%r12)
movq 0x8(%r15,%r14,8), %r12
incq %r14
testq %r12, %r12
jne 0x1ccb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: third_round
void		third_round(t_info *info)
{
	int		i;

	info->round = 1;
	while (!info->accurate && info->round < 5)
	{
		i = reset_values(info);
		reset_tmp_stacks(info);
		while (info->rooms[++i] != NULL)
		{
			if (info->round > 1)
				info->rooms[i]->visited = info->rooms[i]->path_2 < 0 ? 0 : 1;
			else
				info->rooms[i]->visited = 0;
			info->rooms[i]->flow = 0;
			info->rooms[i]->path_2 = -1;
		}
		get_links_for_start(info, 0, 0, 0);
		save_first_level_rooms(info);
		dfs_search(info, -1);
		if (info->flag_storage & VERBOSE)
			print_paths(info);
		calculate_moves(info);
		info->round++;
	}
}

// Assembly:
movl $0x1, 0x1070(%rdi)
cmpl $0x0, 0x1894(%rdi)
je 0x1d50
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r14d
movl $0x2, 0x106c(%rbx)
movl %r14d, 0x1050(%rbx)
movq $0x0, 0x1064(%rbx)
movl %r14d, 0x188c(%rbx)
movq %rbx, %rdi
callq 0x1b98
movq 0x18a8(%rbx), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1dd0
movl 0x1070(%rbx), %edx
addq $0x8, %rax
xorl %esi, %esi
cmpl $0x2, %edx
jl 0x1db3
movl 0x54(%rcx), %esi
notl %esi
shrl $0x1f, %esi
movl %esi, 0x5c(%rcx)
movl $0x0, 0x38(%rcx)
movl $0xffffffff, 0x54(%rcx) # imm = 0xFFFFFFFF
movq (%rax), %rcx
addq $0x8, %rax
testq %rcx, %rcx
jne 0x1da4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x410f
movl $0xd, %eax
movl (%rbx,%rax,4), %ecx
movl %ecx, 0x804(%rbx,%rax,4)
movl $0xffffffff, (%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq $0x20e, %rax            # imm = 0x20E
jne 0x1de3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x163c
testb $0x40, 0x1040(%rbx)
je 0x1e1d
movq %rbx, %rdi
callq 0x3c18
movq %rbx, %rdi
callq 0x252b
movl 0x1070(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1070(%rbx)
cmpl $0x0, 0x1894(%rbx)
jne 0x1e46
cmpl $0x4, %eax
jl 0x1d60
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: second_round
void		second_round(t_info *info)
{
	int		i;

	i = 0;
	info->phase = 2;
	info->level = 1;
	info->path_n_2 = 0;
	if (info->path_n_1 < 1)
		exit_error(ERR_NO_PATH, info);
	reset_tmp_stacks(info);
	while (info->rooms[i] != NULL)
	{
		info->rooms[i]->visited = 0;
		i++;
	}
	get_links_for_start(info, 0, 0, 0);
	find_paths(info, -1, 0, 0);
	if (info->valid_indexes_2[0][0] != EMPTY && (info->flag_storage & VERBOSE))
		print_paths(info);
	calculate_moves(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x106c(%rdi)
movl $0x1, 0x1050(%rdi)
movl $0x0, 0x1064(%rdi)
cmpl $0x0, 0x1060(%rdi)
jg 0x1e8a
leaq 0x56c5(%rip), %rdi      # 0x7547
movq %rbx, %rsi
callq 0x348b
movq %rbx, %rdi
callq 0x1b98
movq 0x18a8(%rbx), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1eb8
addq $0x8, %rax
movl $0x0, 0x5c(%rcx)
movq (%rax), %rcx
addq $0x8, %rax
testq %rcx, %rcx
jne 0x1ea5
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
callq 0x3fe6
movq 0x18a0(%rbx), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
je 0x1ef7
testb $0x40, 0x1040(%rbx)
je 0x1ef7
movq %rbx, %rdi
callq 0x3c18
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x252b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: split_link_string
void	split_link_string(t_info *info, int index)
{
	info->rooms[index]->links =
	ft_strsplit(info->rooms[index]->link_string, ' ');
	free(info->rooms[index]->link_string);
	if (info->rooms[index]->start_or_end != 0)
	{
		if (info->rooms[index]->start_or_end == 1)
			info->start_index = index;
		else
			info->end_index = index;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x18a8(%rdi), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4850
movq 0x18a8(%r14), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, 0x8(%rdx)
movq (%rcx,%r15,8), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x18a8(%r14), %rax
movq (%rax,%r15,8), %rax
movl 0x58(%rax), %eax
testl %eax, %eax
je 0x1f74
cmpl $0x1, %eax
jne 0x1f6d
movl %ebx, 0x1078(%r14)
jmp 0x1f74
movl %ebx, 0x103c(%r14)
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_rooms.c
// Function: first_from_index
void	first_from_index(t_info *info, int i)
{
	int		first;
	int		placement;

	first = i + 1;
	placement = i;
	while (info->rooms[i] != NULL)
	{
		if (ft_strcmp(info->rooms[i]->name, info->rooms[first]->name) < 0)
			first = i;
		if (info->rooms[++i] != NULL)
		{
			if (info->rooms[placement]->x == info->rooms[i]->x
			&& info->rooms[placement]->y == info->rooms[i]->y)
				exit_error(ERR_ROOM_DUP_COORD, info);
			else if (!(ft_strcmp(info->rooms[placement]->name,
			info->rooms[i]->name)))
				exit_error(ERR_ROOM_DUP_NAME, info);
		}
	}
	swap_rooms(info, first, placement);
	if (info->rooms[placement + 1] != NULL)
		split_link_string(info, placement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leal 0x1(%rsi), %r15d
movq 0x18a8(%rdi), %rax
movq %rsi, -0x38(%rbp)
movslq %esi, %r13
movq (%rax,%r13,8), %rcx
movl %r15d, -0x2c(%rbp)
testq %rcx, %rcx
je 0x2044
leaq 0x1(%r13), %r12
movq -0x38(%rbp), %rdx
movl %edx, %ebx
movl -0x2c(%rbp), %r15d
movq 0x10(%rcx), %rdi
movslq %r15d, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x46c8
movl %ebx, %ecx
testl %eax, %eax
js 0x1fe1
movl %r15d, %ecx
movl %ecx, %r15d
movq 0x18a8(%r14), %rcx
movq (%rcx,%r12,8), %rax
testq %rax, %rax
je 0x202f
movq (%rcx,%r13,8), %rcx
movl 0x60(%rcx), %edx
cmpl 0x60(%rax), %edx
jne 0x200f
movl 0x64(%rcx), %edx
leaq 0x5553(%rip), %rdi      # 0x755d
cmpl 0x64(%rax), %edx
je 0x2027
movq 0x10(%rcx), %rdi
movq 0x10(%rax), %rsi
callq 0x46c8
leaq 0x5563(%rip), %rdi      # 0x7586
testl %eax, %eax
jne 0x202f
movq %r14, %rsi
callq 0x348b
movq 0x18a8(%r14), %rax
movq (%rax,%r12,8), %rcx
incl %ebx
incq %r12
testq %rcx, %rcx
jne 0x1fc4
movq %r14, %rdi
movl %r15d, %esi
movq -0x38(%rbp), %rbx
movl %ebx, %edx
callq 0x2df0
movq 0x18a8(%r14), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x207f
movq %r14, %rdi
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f08
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: malloc_for_valid_indexes
void	malloc_for_valid_indexes(t_info *info, int i, int x)
{
	if (!(info->valid_indexes =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_indexes_2 =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_paths =
	(char**)malloc(sizeof(char*) * info->max_paths + 1))
	|| !(info->valid_paths_2 =
	(char**)malloc(sizeof(char*) * info->max_paths + 1)))
		exit_error(ERR_MALLOC, info);
	while (i < info->max_paths + 1)
	{
		if (!(info->valid_indexes[i] = (int*)malloc(sizeof(int) * 513))
		|| !(info->valid_indexes_2[i] = (int*)malloc(sizeof(int) * 513)))
			exit_error(ERR_MALLOC, info);
		while (x < 513)
		{
			info->valid_indexes[i][x] = EMPTY;
			info->valid_indexes_2[i][x] = EMPTY;
			x++;
		}
		x = 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movslq 0x105c(%rdi), %r13
leaq 0x1(,%r13,8), %r12
movq %r12, %rdi
callq 0x1080
movq %rax, 0x1898(%rbx)
testq %rax, %rax
je 0x20fe
movq %r12, %rdi
callq 0x1080
movq %rax, 0x18a0(%rbx)
testq %rax, %rax
je 0x20fe
movq %r12, %rdi
callq 0x1080
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x20fe
movq %r12, %rdi
callq 0x1080
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x2114
leaq 0x54a4(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x348b
movl 0x105c(%rbx), %r13d
cmpl %r15d, %r13d
jl 0x21c7
movslq %r15d, %r12
leaq 0x5482(%rip), %r15      # 0x75a9
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0x804, %edi            # imm = 0x804
callq 0x1080
movq 0x1898(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
testq %rax, %rax
je 0x2161
movl $0x804, %edi            # imm = 0x804
callq 0x1080
movq 0x18a0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
testq %rax, %rax
jne 0x216c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x348b
cmpl $0x200, %r14d           # imm = 0x200
jg 0x21ac
movq 0x1898(%rbx), %rax
movq 0x18a0(%rbx), %rcx
movq (%rax,%r12,8), %rax
movq (%rcx,%r12,8), %rcx
movslq %r14d, %rdx
incq %rdx
movq %rdx, %rsi
movl %r13d, -0x4(%rax,%rdx,4)
movl %r13d, -0x4(%rcx,%rdx,4)
incq %rsi
cmpl $0x201, %edx            # imm = 0x201
movq %rsi, %rdx
jne 0x2194
leaq 0x1(%r12), %rax
movslq 0x105c(%rbx), %rcx
xorl %r14d, %r14d
cmpq %rcx, %r12
movq %rax, %r12
jl 0x212d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: sort_rooms
void	sort_rooms(t_info *info)
{
	int		i;
	int		x;

	i = 0;
	x = 0;
	while (info->rooms[i + 1] != NULL)
	{
		first_from_index(info, i);
		i++;
	}
	split_link_string(info, i);
	i = 0;
	while (info->rooms[info->start_index]->links[i] != NULL)
		i++;
	while (info->rooms[info->end_index]->links[x] != NULL)
		x++;
	info->max_paths = i < x ? i : x;
	malloc_for_valid_indexes(info, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18a8(%rdi), %rax
cmpq $0x0, 0x8(%rax)
je 0x2210
xorl %esi, %esi
movq %rsi, %r14
movq %rbx, %rdi
callq 0x1f7f
movq 0x18a8(%rbx), %rax
leaq 0x1(%r14), %rsi
cmpq $0x0, 0x10(%rax,%r14,8)
jne 0x21f0
jmp 0x2212
xorl %esi, %esi
movq %rbx, %rdi
callq 0x1f08
movq 0x18a8(%rbx), %rcx
movslq 0x1078(%rbx), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpq $0x0, (%rdx)
leaq 0x8(%rdx), %rdx
jne 0x2235
movslq 0x103c(%rbx), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpq $0x0, (%rdx)
leaq 0x8(%rdx), %rdx
jne 0x2255
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, 0x105c(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x208e
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: reset_valid_indexes_2
void		reset_valid_indexes_2(t_info *info)
{
	int		y;
	int		i;

	y = 0;
	i = 0;
	while (y < info->max_paths + 1)
	{
		while (i < 513)
		{
			if (info->valid_indexes_2[y][i] > 0)
			{
				info->rooms[info->valid_indexes_2[y][i]]->length_2 = 0;
				info->rooms[info->valid_indexes_2[y][i]]->cost_2 = 0;
				info->rooms[info->valid_indexes_2[y][i]]->path_2 = -1;
			}
			info->valid_indexes_2[y][i] = EMPTY;
			i++;
		}
		i = 0;
		y++;
	}
	info->path_n_2 = 0;
}

// Assembly:
cmpl $0x0, 0x105c(%rdi)
js 0x22f7
pushq %rbp
movq %rsp, %rbp
movq 0x18a0(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
xorl %r8d, %r8d
movslq (%rsi,%r8,4), %r9
testq %r9, %r9
jle 0x22cf
movq 0x18a8(%rdi), %r10
movq (%r10,%r9,8), %r9
movl %ecx, 0x48(%r9)
movslq (%rsi,%r8,4), %r9
movq (%r10,%r9,8), %r9
movl %ecx, 0x40(%r9)
movslq (%rsi,%r8,4), %r9
movq (%r10,%r9,8), %r9
movl $0xffffffff, 0x54(%r9)  # imm = 0xFFFFFFFF
movl $0xffffffff, (%rsi,%r8,4) # imm = 0xFFFFFFFF
incq %r8
cmpq $0x201, %r8             # imm = 0x201
jne 0x229b
leaq 0x1(%rdx), %rsi
movslq 0x105c(%rdi), %r8
cmpq %r8, %rdx
movq %rsi, %rdx
jl 0x2294
popq %rbp
movl $0x0, 0x1064(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: change_path_sets
void		change_path_sets(t_info *info)
{
	int		y;
	int		i;

	y = 0;
	i = 0;
	while (y < info->max_paths + 1)
	{
		while (i < 513)
		{
			info->valid_indexes[y][i] = info->valid_indexes_2[y][i];
			if (info->valid_indexes[y][i] != EMPTY)
				path_set_insert(info, i, y);
			info->valid_indexes_2[y][i] = EMPTY;
			i++;
		}
		i = 0;
		y++;
	}
	info->path_n_1 = info->path_n_2;
	info->last_found_used = info->last_found_used_2;
	info->last_found_used_2 = 1;
	info->path_n_2 = 0;
}

// Assembly:
cmpl $0x0, 0x105c(%rdi)
js 0x2404
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x1898(%rdi), %rax
movq 0x18a0(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq (%rax,%rdx,8), %r8
xorl %r9d, %r9d
movslq (%rsi,%r9,4), %r10
movl %r10d, (%r8,%r9,4)
cmpq $-0x1, %r10
je 0x23d7
movq 0x18a8(%rdi), %r11
movq (%r11,%r10,8), %r10
movl 0x48(%r10), %ebx
movl %ebx, 0x44(%r10)
movslq (%r8,%r9,4), %r10
movq (%r11,%r10,8), %r10
movl 0x40(%r10), %ebx
movl %ebx, 0x3c(%r10)
movslq (%r8,%r9,4), %r10
movq (%r11,%r10,8), %r10
movl 0x54(%r10), %ebx
movl %ebx, 0x50(%r10)
movslq (%r8,%r9,4), %r10
movq (%r11,%r10,8), %r10
movl $0xffffffff, 0x54(%r10) # imm = 0xFFFFFFFF
movl $0xffffffff, (%rsi,%r9,4) # imm = 0xFFFFFFFF
incq %r9
cmpq $0x201, %r9             # imm = 0x201
jne 0x2386
leaq 0x1(%rdx), %rsi
movslq 0x105c(%rdi), %r8
cmpq %r8, %rdx
movq %rsi, %rdx
jl 0x237b
popq %rbx
popq %rbp
movl 0x1064(%rdi), %eax
movl %eax, 0x1060(%rdi)
movl 0x188c(%rdi), %eax
movl %eax, 0x1888(%rdi)
movl $0x1, 0x188c(%rdi)
movl $0x0, 0x1064(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: calculate_more
int			calculate_more(t_info *info, int i, int rooms, int set)
{
	int		moves;
	int		d;

	if (set == 1)
	{
		while (++i < info->path_n_1)
			rooms += info->rooms[info->valid_indexes[i][0]]->length;
		rooms -= info->last_found_used == 1 ? 0 :
		info->rooms[info->valid_indexes[i - 1][0]]->length;
		d = info->last_found_used == 1 ? info->path_n_1 : info->path_n_1 - 1;
		d = d == 0 ? 1 : d;
		moves = ((rooms + info->ants) / d) + ((rooms + info->ants) % d ? 1 : 0);
	}
	else
	{
		while (++i < info->path_n_2)
			rooms += info->rooms[info->valid_indexes_2[i][0]]->length_2;
		rooms -= info->last_found_used_2 == 1 ? 0 :
		info->rooms[info->valid_indexes_2[i - 1][0]]->length_2;
		d = info->last_found_used_2 == 1 ? info->path_n_2 : info->path_n_2 - 1;
		d = d == 0 ? 1 : d;
		moves = ((rooms + info->ants) / d) + ((rooms + info->ants) % d ? 1 : 0);
	}
	return (moves);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
leal 0x1(%rsi), %edx
cmpl $0x1, %ecx
jne 0x24ad
movl 0x1060(%rdi), %ecx
cmpl %ecx, %edx
jge 0x247f
movslq %edx, %rdx
shlq $0x3, %rdx
addq 0x1898(%rdi), %rdx
movq 0x18a8(%rdi), %r8
notl %esi
addl %ecx, %esi
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movslq (%r10), %r10
movq (%r8,%r10,8), %r10
addl 0x44(%r10), %eax
incq %r9
cmpl %r9d, %esi
jne 0x2465
leal -0x1(%rcx), %esi
cmpl $0x1, 0x1888(%rdi)
je 0x2517
movq 0x1898(%rdi), %rdx
movq 0x18a8(%rdi), %r8
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%r8,%rdx,8), %rdx
subl 0x44(%rdx), %eax
jmp 0x2515
movl 0x1064(%rdi), %ecx
cmpl %ecx, %edx
jge 0x24ed
movslq %edx, %rdx
shlq $0x3, %rdx
addq 0x18a0(%rdi), %rdx
movq 0x18a8(%rdi), %r8
notl %esi
addl %ecx, %esi
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movslq (%r10), %r10
movq (%r8,%r10,8), %r10
addl 0x48(%r10), %eax
incq %r9
cmpl %r9d, %esi
jne 0x24d3
leal -0x1(%rcx), %esi
cmpl $0x1, 0x188c(%rdi)
je 0x2517
movq 0x18a0(%rdi), %rdx
movq 0x18a8(%rdi), %r8
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%r8,%rdx,8), %rdx
subl 0x48(%rdx), %eax
decl %ecx
cmpl $0x1, %ecx
adcl $0x0, %ecx
addl 0x28(%rdi), %eax
cltd
idivl %ecx
cmpl $0x1, %edx
sbbl $-0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: calculate_moves
void		calculate_moves(t_info *info)
{
	int		moves;
	int		cmp;

	if (info->path_n_2 < 1)
	{
		reset_valid_indexes_2(info);
		return ;
	}
	moves = calculate_more(info, -1, 0, 1);
	cmp = calculate_more(info, -1, 0, 2);
	if (info->flag_storage & VERBOSE)
		ft_printf("%d  %d\n```````\n", moves, cmp);
	if (moves <= info->required + 2 || cmp <= info->required + 2)
		info->accurate = 1;
	if (cmp < moves)
	{
		if (info->flag_storage & VERBOSE)
			ft_printf("><><><><C H A N G I N G  P A T H  S E T><><><><><\n\n");
		change_path_sets(info);
	}
	else
		reset_valid_indexes_2(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1064(%rdi)
jle 0x25e1
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2431
movl %eax, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x2, %ecx
callq 0x2431
movl %eax, %r15d
testb $0x40, 0x1040(%rbx)
je 0x2590
leaq 0x503f(%rip), %rdi      # 0x75c2
movl %r14d, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4adc
movl 0x1890(%rbx), %eax
addl $0x2, %eax
cmpl %eax, %r14d
setg %cl
cmpl %eax, %r15d
setg %al
testb %al, %cl
jne 0x25b3
movl $0x1, 0x1894(%rbx)
cmpl %r14d, %r15d
jge 0x25e1
testb $0x40, 0x1040(%rbx)
je 0x25cf
leaq 0x500a(%rip), %rdi      # 0x75d2
xorl %eax, %eax
callq 0x4adc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2359
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x227c
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/divide_ants_to_paths.c
// Function: divide_to_paths
void		divide_to_paths(t_info *info, int i, int tab, int cmp)
{
	int		antnb;

	antnb = 1;
	while (info->ants_at_start > 0)
	{
		if (info->path_n_1 == 1)
			tab = divide_paths_data(info, antnb++, i, tab);
		else if (info->rooms[info->valid_indexes[i][0]]->cost
		<= info->rooms[info->valid_indexes[i + 1][0]]->cost)
		{
			if (info->rooms[info->valid_indexes[i][0]]->cost
			== info->rooms[info->valid_indexes[i + 1][0]]->cost)
				i = cmp_loop(info, cmp, i);
			tab = divide_paths_data(info, antnb++, i, tab);
		}
		else if (info->rooms[info->valid_indexes[i][0]]->cost
		> info->rooms[info->valid_indexes[i + 1][0]]->cost)
			tab = divide_paths_data(info, antnb++, ++i, tab);
		if (i == info->path_n_1 - 1
		|| info->rooms[info->valid_indexes[i][0]]->cost
		< info->rooms[info->valid_indexes[i + 1][0]]->cost)
			i = 0;
	}
}

// Assembly:
cmpl $0x0, 0x30(%rdi)
jle 0x2713
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x1060(%rdi), %r10d
movq 0x18a8(%rdi), %rax
movq 0x1898(%rdi), %rcx
movl $0x1, %edx
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r9       # imm = 0x100000000
movslq %esi, %r14
movq (%rcx,%r14,8), %r11
movslq (%r11), %rbx
movq (%rax,%rbx,8), %rbx
cmpl $0x1, %r10d
je 0x269e
movl 0x3c(%rbx), %r10d
movq 0x8(%rcx,%r14,8), %r14
movslq (%r14), %r15
movq (%rax,%r15,8), %r15
cmpl 0x3c(%r15), %r10d
jle 0x2669
incl %esi
movq %r15, %rbx
movq %r14, %r11
jmp 0x269e
jne 0x269e
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rcx, %rbx
movq %r8, %r11
addq %r9, %r11
movq (%rbx), %r14
movslq (%r14), %r14
movq (%rax,%r14,8), %r14
incl %esi
addq $0x8, %rbx
cmpl %r10d, 0x3c(%r14)
jg 0x2676
sarq $0x1d, %r11
movq (%rcx,%r11), %r11
movslq (%r11), %r10
movq (%rax,%r10,8), %rbx
movslq 0x30(%rbx), %r10
movq 0x20(%rbx), %rbx
movl %edx, (%rbx,%r10,4)
movslq (%r11), %r10
movq (%rax,%r10,8), %r10
incl 0x30(%r10)
movslq (%r11), %r10
movq (%rax,%r10,8), %r10
incl 0x3c(%r10)
movl 0x30(%rdi), %r11d
leal -0x1(%r11), %r10d
movl %r10d, 0x30(%rdi)
movl 0x1060(%rdi), %r10d
leal -0x1(%r10), %ebx
cmpl %ebx, %esi
je 0x26ff
movslq %esi, %rbx
movq (%rcx,%rbx,8), %r14
movq 0x8(%rcx,%rbx,8), %rbx
movslq (%r14), %r14
movq (%rax,%r14,8), %r14
movl 0x3c(%r14), %r14d
movslq (%rbx), %rbx
movq (%rax,%rbx,8), %rbx
cmpl 0x3c(%rbx), %r14d
jge 0x2701
xorl %esi, %esi
incl %edx
cmpl $0x1, %r11d
jg 0x2635
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/free_memory.c
// Function: free_2d_array
void			free_2d_array(char **arr)
{
	int			i;

	i = 0;
	while (arr[i] != NULL)
	{
		free(arr[i]);
		i++;
	}
	free(arr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2786
leaq 0x8(%rbx), %r14
callq 0x1030
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x2775
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: add_new_link
void	add_new_link(t_info *info, int i, char *room)
{
	char	*add;
	char	*add2;
	char	*tmp;

	add2 = ft_strjoin(" ", room);
	add = ft_strjoin(add2, " ");
	if (ft_strstr(info->rooms[i]->link_string, add))
		exit_error(ERR_DUP_LINK, info);
	tmp = ft_strjoin(info->rooms[i]->link_string, add);
	free(info->rooms[i]->link_string);
	info->rooms[i]->link_string = ft_strdup(tmp);
	free(tmp);
	free(add);
	free(add2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
leaq 0x4ee4(%rip), %r15      # 0x7993
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4794
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4794
movq %rax, %r15
movq 0x18a8(%r14), %rax
movslq %r12d, %r13
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x4958
testq %rax, %rax
je 0x2af8
leaq 0x4be9(%rip), %rdi      # 0x76d9
movq %r14, %rsi
callq 0x348b
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x4794
movq %rax, %r12
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
callq 0x1030
movq %r12, %rdi
callq 0x471c
movq 0x18a8(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: add_links_for_rooms
void	add_links_for_rooms(t_info *info, char *room1, char *room2)
{
	int			i;
	int			added;

	i = 0;
	added = 0;
	while (info->rooms[i] != NULL)
	{
		if (ft_strequ(info->rooms[i]->name, room1))
		{
			add_new_link(info, i, room2);
			added++;
		}
		else if (ft_strequ(info->rooms[i]->name, room2))
		{
			add_new_link(info, i, room1);
			added++;
		}
		if (added == 2)
			return ;
		i++;
	}
	exit_error(ERR_BAD_LINK, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18a8(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2be5
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x476c
movq %r14, %rdx
testl %eax, %eax
jne 0x2bbd
movq 0x18a8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x476c
movq %r15, %rdx
testl %eax, %eax
je 0x2bd1
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2a94
incl %r13d
cmpl $0x2, %r13d
je 0x2c02
movq 0x18a8(%rbx), %rax
movq 0x8(%rax,%r12,8), %rax
incq %r12
testq %rax, %rax
jne 0x2b8c
leaq 0x4b09(%rip), %rdi      # 0x76f5
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x348b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: room_error_check
void	room_error_check(t_info *info, char **room_data)
{
	if (ft_strchr(room_data[0], '-'))
		exit_error(ERR_ROOM_NAME_DASH, info);
	if (room_data[3] != NULL)
		exit_error(ERR_ROOM_ARGS_MANY, info);
	if (room_data[1] == NULL || room_data[2] == NULL)
		exit_error(ERR_ROOM_ARGS_FEW, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x2d, %esi
callq 0x4694
testq %rax, %rax
je 0x2c3f
leaq 0x4ad2(%rip), %rdi      # 0x7709
movq %rbx, %rsi
callq 0x348b
cmpq $0x0, 0x18(%r14)
je 0x2c55
leaq 0x4adb(%rip), %rdi      # 0x7728
movq %rbx, %rsi
callq 0x348b
cmpq $0x0, 0x8(%r14)
je 0x2c68
cmpq $0x0, 0x10(%r14)
je 0x2c68
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4ad8(%rip), %rdi      # 0x7747
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x348b
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: validate_command
int		validate_command(t_info *info, char *line)
{
	int		start_end;

	if (info->start && ft_strstr(line, "##start"))
		exit_error(ERR_ROOM_M_START, info);
	else if (info->end && ft_strstr(line, "##end"))
		exit_error(ERR_ROOM_M_END, info);
	start_end = ft_strstr(line, "##start") ? 1 : 2;
	return (start_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x2cd8
leaq 0x4aa3(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x4958
testq %rax, %rax
je 0x2cd8
leaq 0x4a97(%rip), %rdi      # 0x776d
jmp 0x2cf9
cmpq $0x0, (%r14)
je 0x2d01
leaq 0x4aa6(%rip), %rsi      # 0x778b
movq %rbx, %rdi
callq 0x4958
testq %rax, %rax
je 0x2d01
leaq 0x4a98(%rip), %rdi      # 0x7791
movq %r14, %rsi
callq 0x348b
leaq 0x4a5d(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x4958
xorl %ecx, %ecx
cmpq $0x1, %rax
adcl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/room_sorting_utils.c
// Function: find_a_room
int			find_a_room(t_info *info, char *to_find)
{
	int		start;
	int		end;
	int		cmp;

	start = 0;
	end = info->room_amnt - 1;
	cmp = end / 2;
	if (to_find == NULL)
		return (-1);
	while (start <= end)
	{
		if (ft_strcmp(info->rooms[cmp]->name, to_find) == 0)
			return (cmp);
		else if (ft_strcmp(info->rooms[cmp]->name, to_find) > 0)
		{
			end = cmp - 1;
			cmp /= 2;
		}
		else
		{
			start = cmp + 1;
			cmp = start + ((end - start) / 2);
		}
	}
	return (-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2def
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x1074(%rdi), %edx
testl %edx, %edx
jle 0x2de1
movq %rsi, %r12
decl %edx
movl %edx, %esi
shrl %esi
xorl %r15d, %r15d
movl %edx, -0x2c(%rbp)
movq 0x18a8(%r14), %rax
movq %rsi, %r13
movslq %esi, %rbx
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x46c8
testl %eax, %eax
je 0x2dde
movq %r12, %rsi
movq %r14, %r12
movq 0x18a8(%r14), %rax
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %rsi, %rbx
callq 0x46c8
testl %eax, %eax
jle 0x2db1
leal -0x1(%r13), %edx
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
movl %eax, %esi
jmp 0x2dcc
leal 0x1(%r13), %r15d
movl -0x2c(%rbp), %edx
movl %edx, %eax
subl %r15d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leal (%rcx,%r13), %esi
incl %esi
cmpl %edx, %r15d
movq %r12, %r14
movq %rbx, %r12
jle 0x2d59
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2de1
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/room_sorting_utils.c
// Function: swap_rooms
void		swap_rooms(t_info *info, int a, int b)
{
	t_room	*swap;

	if (!(swap = (t_room*)malloc(sizeof(t_room))))
		exit_error(ERR_MALLOC, info);
	copy_room(info->rooms[a], swap, 0);
	copy_room(info->rooms[b], info->rooms[a], 1);
	copy_room(swap, info->rooms[b], 1);
	free(swap->name);
	free(swap->link_string);
	free(swap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movl $0x68, %edi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
je 0x2e30
movq 0x18a8(%r14), %rax
addq $0x18a8, %r14           # imm = 0x18A8
movslq %r12d, %r12
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
jmp 0x2e56
leaq 0x4772(%rip), %rdi      # 0x75a9
movq %r14, %rsi
callq 0x348b
movq 0x18a8(%r14), %rax
addq $0x18a8, %r14           # imm = 0x18A8
movslq %r12d, %r12
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2eaa
movq (%r14), %rax
movslq %r15d, %r15
movq (%rax,%r15,8), %rdi
movq (%rax,%r12,8), %rsi
movl $0x1, %edx
callq 0x2eaa
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2eaa
movq 0x10(%rbx), %rdi
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/room_sorting_utils.c
// Function: copy_room
static void	copy_room(t_room *src, t_room *dst, int mallocs)
{
	char	*tmp;

	if (mallocs == 1)
	{
		tmp = ft_strdup(src->name);
		ft_strdel(&dst->name);
		dst->name = ft_strdup(tmp);
		free(tmp);
		tmp = ft_strdup(src->link_string);
		ft_strdel(&dst->link_string);
		dst->link_string = ft_strdup(tmp);
		free(tmp);
	}
	else
	{
		dst->name = ft_strdup(src->name);
		dst->link_string = ft_strdup(src->link_string);
	}
	dst->start_or_end = src->start_or_end;
	dst->visited = src->visited;
	dst->path = src->path;
	dst->level = src->level;
	dst->y = src->y;
	dst->x = src->x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x471c
movq %rax, %r15
cmpl $0x1, %r12d
jne 0x2f15
leaq 0x10(%rbx), %rdi
callq 0x46f8
movq %r15, %rdi
callq 0x471c
movq %rax, 0x10(%rbx)
movq %r15, %rdi
callq 0x1030
movq (%r14), %rdi
callq 0x471c
movq %rax, %r15
movq %rbx, %rdi
callq 0x46f8
movq %r15, %rdi
callq 0x471c
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1030
jmp 0x2f24
movq %r15, 0x10(%rbx)
movq (%r14), %rdi
callq 0x471c
movq %rax, (%rbx)
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
movl 0x5c(%r14), %eax
movl %eax, 0x5c(%rbx)
movl 0x50(%r14), %eax
movl %eax, 0x50(%rbx)
movl 0x4c(%r14), %eax
movl %eax, 0x4c(%rbx)
movl 0x64(%r14), %eax
movl %eax, 0x64(%rbx)
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/save_path.c
// Function: enough_paths
int		enough_paths(t_info *info, int path_index, int sum, int i)
{
	int		cmp_length;

	if ((info->phase == 1 && info->path_n_1 == info->max_paths)
	|| (info->phase == 2 && info->path_n_2 == info->max_paths))
		return (1);
	else if ((info->phase == 1 && info->path_n_1 == 1)
	|| (info->phase == 2 && info->path_n_2 == 1))
		return (0);
	cmp_length = info->phase == 1 ?
	info->rooms[info->valid_indexes[path_index][0]]->length :
	info->rooms[info->valid_indexes_2[path_index][0]]->length_2;
	while (i < path_index)
	{
		sum += info->phase == 1 ?
		(cmp_length - info->rooms[info->valid_indexes[i][0]]->length) :
		(cmp_length - info->rooms[info->valid_indexes_2[i][0]]->length_2);
		i++;
	}
	if (info->phase == 1)
		info->last_found_used = sum >= info->ants ? 0 : 1;
	else
		info->last_found_used_2 = sum >= info->ants ? 0 : 1;
	return (sum >= info->ants);
}

// Assembly:
movl 0x106c(%rdi), %r8d
cmpl $0x1, %r8d
jne 0x2f92
movl 0x1060(%rdi), %r9d
movl $0x1, %eax
cmpl 0x105c(%rdi), %r9d
je 0x304b
cmpl $0x1, %r9d
je 0x2fc3
movl $0x44, %r9d
movl $0x1898, %r10d          # imm = 0x1898
jmp 0x2fc6
movl $0x48, %r9d
movl $0x18a0, %r10d          # imm = 0x18A0
cmpl $0x2, %r8d
jne 0x2fc6
movl 0x1064(%rdi), %r11d
movl $0x1, %eax
cmpl 0x105c(%rdi), %r11d
je 0x304b
cmpl $0x1, %r11d
jne 0x2fc6
xorl %eax, %eax
retq
cmpl %esi, %ecx
jge 0x3026
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x18a8(%rdi), %rax
movq (%rdi,%r10), %r10
movslq %esi, %rsi
movq (%r10,%rsi,8), %r10
movslq (%r10), %r10
movq (%rax,%r10,8), %r10
movl (%r10,%r9), %r9d
xorl %r11d, %r11d
cmpl $0x1, %r8d
setne %r11b
movslq %ecx, %rcx
leaq 0x44(,%r11,4), %r10
movq 0x1898(%rdi,%r11,8), %r11
addl %r9d, %edx
movq (%r11,%rcx,8), %rbx
movslq (%rbx), %rbx
movq (%rax,%rbx,8), %rbx
subl (%rbx,%r10), %edx
incq %rcx
cmpq %rcx, %rsi
jne 0x300a
popq %rbx
popq %rbp
movl 0x28(%rdi), %ecx
xorl %eax, %eax
cmpl %ecx, %edx
setl %al
cmpl $0x1, %r8d
jne 0x303e
movl %eax, 0x1888(%rdi)
jmp 0x3044
movl %eax, 0x188c(%rdi)
xorl %eax, %eax
cmpl %ecx, %edx
setge %al
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/source/save_path.c
// Function: copy_path_to_valid_indexes
void	copy_path_to_valid_indexes(t_info *info, int path_i, int i)
{
	if (info->phase == 1)
	{
		info->valid_indexes[info->path_n_1][i] = info->index_stack[path_i][i];
		if (info->index_stack[path_i][i] != info->end_index)
		{
			info->rooms[info->index_stack[path_i][i]]->flow = 1;
			info->rooms[info->index_stack[path_i][i]]->path = info->path_n_1;
		}
	}
	else
	{
		info->valid_indexes_2[info->path_n_2][i] = info->index_stack[path_i][i];
		if (info->index_stack[path_i][i] != info->end_index)
		{
			info->rooms[info->index_stack[path_i][i]]->flow += 2;
			info->rooms[info->index_stack[path_i][i]]->path_2 = info->path_n_2;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x106c(%rdi)
movq 0x1048(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %esi
movslq %esi, %rdx
jne 0x30b3
movq 0x1898(%rdi), %r8
movslq 0x1060(%rdi), %r9
movq (%r8,%r9,8), %r8
movl %esi, (%r8,%rcx,4)
cmpl 0x103c(%rdi), %esi
je 0x30f1
movq 0x18a8(%rdi), %rsi
movq (%rsi,%rdx,8), %rdx
movl $0x1, 0x38(%rdx)
movl 0x1060(%rdi), %edx
movslq (%rax,%rcx,4), %rax
movq (%rsi,%rax,8), %rax
movl %edx, 0x50(%rax)
jmp 0x30f1
movq 0x18a0(%rdi), %r8
movslq 0x1064(%rdi), %r9
movq (%r8,%r9,8), %r8
movl %esi, (%r8,%rcx,4)
cmpl 0x103c(%rdi), %esi
je 0x30f1
movq 0x18a8(%rdi), %rsi
movq (%rsi,%rdx,8), %rdx
addl $0x2, 0x38(%rdx)
movl 0x1064(%rdi), %edx
movslq (%rax,%rcx,4), %rax
movq (%rsi,%rax,8), %rax
movl %edx, 0x54(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %edx
cmpl $0x1, 0x106c(%rdi)
movq 0x18a8(%rdi), %rax
movq 0x1048(%rdi), %rcx
movslq %esi, %r14
movq (%rcx,%r14,8), %rcx
movslq (%rcx), %rsi
movq (%rax,%rsi,8), %rsi
jne 0x3136
movl %edx, 0x44(%rsi)
movslq (%rcx), %rsi
movq (%rax,%rsi,8), %rsi
movl %edx, 0x3c(%rsi)
jmp 0x3143
movl %edx, 0x48(%rsi)
movslq (%rcx), %rsi
movq (%rax,%rsi,8), %rsi
movl %edx, 0x40(%rsi)
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %r15
cmpq $0x0, 0x20(%r15)
jne 0x317a
movslq 0x28(%rbx), %rax
leaq 0x1(,%rax,4), %rdi
callq 0x1080
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x317a
leaq 0x4437(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x348b
cmpl $0x0, 0x28(%rbx)
js 0x31b8
movq 0x18a8(%rbx), %rax
movq 0x1048(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq $-0x1, %rdx
movslq (%rcx), %rsi
movq (%rax,%rsi,8), %rsi
movq 0x20(%rsi), %rsi
movl $0x0, 0x4(%rsi,%rdx,4)
movslq 0x28(%rbx), %rsi
incq %rdx
cmpq %rsi, %rdx
jl 0x3199
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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, 0x106c(%rdi)
jne 0x31f0
cmpl $0x0, 0x188c(%rbx)
je 0x32b9
movslq %r15d, %r12
movq 0x1048(%rbx), %rax
movq (%rax,%r12,8), %rax
movslq %r14d, %r13
cmpl $-0x1, (%rax,%r13,4)
je 0x3232
incq %r13
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x304c
movq 0x1048(%rbx), %rax
movq (%rax,%r12,8), %rax
incl %r14d
cmpl $-0x1, (%rax,%r13,4)
leaq 0x1(%r13), %r13
jne 0x320b
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x30f3
cmpl $0x1, 0x106c(%rbx)
jne 0x3251
incl 0x1060(%rbx)
jmp 0x3257
incl 0x1064(%rbx)
movl $0x1, 0x1068(%rbx)
movq %rbx, %rdi
callq 0x4350
movl 0x106c(%rbx), %eax
cmpl $0x1, %eax
jne 0x3292
movl 0x1060(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f58
testl %eax, %eax
jne 0x32af
movl 0x106c(%rbx), %eax
cmpl $0x2, %eax
jne 0x32c8
movl 0x1064(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f58
testl %eax, %eax
je 0x32c8
movl $0x2, 0x1068(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1ca1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b98
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x42a6(%rip), %r14      # 0x75a9
leaq 0x44a3(%rip), %r15      # 0x77ad
movq 0x18a8(%rbx), %rax
movslq %r12d, %r13
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3333
incq %rcx
cmpq $0x3, %rcx
jne 0x331e
jmp 0x33e8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d20
movl %eax, %r12d
movq 0x18a8(%rbx), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rcx
movl 0x4c(%rcx), %ecx
movq (%rax,%r13,8), %rax
cmpl 0x4c(%rax), %ecx
jle 0x3379
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2d20
movl %eax, %r12d
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rdi
callq 0x275f
movl $0x8, %edi
callq 0x1080
movq 0x18a8(%rbx), %rcx
movq (%rcx,%r13,8), %rdx
movq %rax, 0x8(%rdx)
testq %rax, %rax
jne 0x33b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x348b
movq 0x18a8(%rbx), %rcx
movq (%rcx,%r13,8), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movl 0x30(%rbx), %esi
incl %esi
movl %esi, 0x30(%rbx)
testb $0x40, 0x1040(%rbx)
je 0x330a
subl 0x28(%rbx), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4adc
jmp 0x330a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18a8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x0, (%rax,%rdx,8)
je 0x342b
movl $0x1, %edx
testb $0x1, %cl
movb $0x1, %cl
je 0x3416
jmp 0x3455
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d20
testl %eax, %eax
js 0x3455
cmpl 0x103c(%rbx), %eax
je 0x3455
movq 0x18a8(%rbx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
cmpl $0x0, 0x50(%rcx)
js 0x345c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32e8