LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x24e8
movl 0x1060(%rdi), %ecx
cmpl %ecx, %edx
jge 0x24b3
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 0x2499
leal -0x1(%rcx), %esi
xorl %r8d, %r8d
cmpl $0x1, 0x1888(%rdi)
setne %dl
je 0x2557
movq 0x1898(%rdi), %r8
movq 0x18a8(%rdi), %r9
movslq %esi, %rsi
movq (%r8,%rsi,8), %rsi
movslq (%rsi), %rsi
movq (%r9,%rsi,8), %rsi
movl 0x44(%rsi), %r8d
jmp 0x2557
movl 0x1064(%rdi), %ecx
cmpl %ecx, %edx
jge 0x2528
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 0x250e
leal -0x1(%rcx), %esi
xorl %r8d, %r8d
cmpl $0x1, 0x188c(%rdi)
setne %dl
je 0x2557
movq 0x18a0(%rdi), %r8
movq 0x18a8(%rdi), %r9
movslq %esi, %rsi
movq (%r8,%rsi,8), %rsi
movslq (%rsi), %rsi
movq (%r9,%rsi,8), %rsi
movl 0x48(%rsi), %r8d
subl %r8d, %eax
movzbl %dl, %edx
subl %edx, %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_O1/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 0x2629
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2465
movl %eax, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x2, %ecx
callq 0x2465
movl %eax, %r15d
testb $0x40, 0x1040(%rbx)
je 0x25d8
leaq 0x4ff7(%rip), %rdi      # 0x75c2
movl %r14d, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4b78
movl 0x1890(%rbx), %eax
addl $0x2, %eax
cmpl %eax, %r14d
setg %cl
cmpl %eax, %r15d
setg %al
testb %al, %cl
jne 0x25fb
movl $0x1, 0x1894(%rbx)
cmpl %r14d, %r15d
jge 0x2629
testb $0x40, 0x1040(%rbx)
je 0x2617
leaq 0x4fc2(%rip), %rdi      # 0x75d2
xorl %eax, %eax
callq 0x4b78
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2381
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22a4
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2743
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x1, 0x1060(%rdi)
movslq %esi, %r8
jne 0x266f
movq 0x18a8(%rdi), %rcx
shlq $0x3, %r8
addq 0x1898(%rdi), %r8
jmp 0x26c9
movq 0x1898(%rdi), %rdx
movq 0x18a8(%rdi), %rcx
movq (%rdx,%r8,8), %r9
movslq (%r9), %r9
movq (%rcx,%r9,8), %r9
movl 0x3c(%r9), %r9d
movq 0x8(%rdx,%r8,8), %r8
movslq (%r8), %r10
movq (%rcx,%r10,8), %r10
cmpl 0x3c(%r10), %r9d
jle 0x26a2
incl %esi
jmp 0x26d3
jne 0x26c2
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rdx, %r8
movq (%r8), %r10
movslq (%r10), %r10
movq (%rcx,%r10,8), %r10
incl %esi
addq $0x8, %r8
cmpl %r9d, 0x3c(%r10)
jg 0x26ac
movslq %esi, %r8
leaq (%rdx,%r8,8), %r8
movq (%r8), %r8
movslq (%r8), %rdx
movq (%rcx,%rdx,8), %r10
movslq 0x30(%r10), %rdx
movq 0x20(%r10), %r9
movl %eax, (%r9,%rdx,4)
movslq (%r8), %rdx
movq (%rcx,%rdx,8), %rdx
incl 0x30(%rdx)
movslq (%r8), %rdx
movq (%rcx,%rdx,8), %rcx
incl 0x3c(%rcx)
decl 0x30(%rdi)
movl 0x1060(%rdi), %ecx
decl %ecx
cmpl %ecx, %esi
je 0x2734
movq 0x1898(%rdi), %rcx
movq 0x18a8(%rdi), %rdx
movslq %esi, %r8
movq (%rcx,%r8,8), %r9
movq 0x8(%rcx,%r8,8), %rcx
movslq (%r9), %r8
movq (%rdx,%r8,8), %r8
movl 0x3c(%r8), %r8d
movslq (%rcx), %rcx
movq (%rdx,%rcx,8), %rcx
cmpl 0x3c(%rcx), %r8d
jge 0x2736
xorl %esi, %esi
incl %eax
cmpl $0x0, 0x30(%rdi)
jg 0x264f
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/free_memory.c
// Function: lst_free
void			lst_free(t_output *op)
{
	t_output	*current;
	t_output	*tmp;

	current = op;
	while (current->next)
	{
		tmp = current;
		current = current->next;
		free(tmp->line);
		free(tmp);
	}
	free(current->line);
	free(current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2778
movq %rax, %rbx
movq (%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq %rbx, %r14
testq %rax, %rax
jne 0x2757
jmp 0x277b
movq %r14, %rbx
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x27b6
leaq 0x8(%rbx), %r14
callq 0x1030
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x27a5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4f06(%rip), %r15      # 0x79e5
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4848
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4848
movq %rax, %r15
movq 0x18a8(%r14), %rax
movslq %r12d, %r13
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x49f8
testq %rax, %rax
je 0x2b28
leaq 0x4bb9(%rip), %rdi      # 0x76d9
movq %r14, %rsi
callq 0x34cb
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x4848
movq %rax, %r12
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
callq 0x1030
movq %r12, %rdi
callq 0x47cc
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_O1/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 0x2c15
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x4820
movq %r14, %rdx
testl %eax, %eax
jne 0x2bed
movq 0x18a8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x4820
movq %r15, %rdx
testl %eax, %eax
je 0x2bfb
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2ac4
incl %r13d
cmpl $0x2, %r13d
je 0x2c32
movq 0x18a8(%rbx), %rax
movq 0x8(%rax,%r12,8), %rax
incq %r12
testq %rax, %rax
jne 0x2bbc
leaq 0x4ad9(%rip), %rdi      # 0x76f5
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x474c
testq %rax, %rax
je 0x2c6f
leaq 0x4aa2(%rip), %rdi      # 0x7709
movq %rbx, %rsi
callq 0x34cb
cmpq $0x0, 0x18(%r14)
je 0x2c85
leaq 0x4aab(%rip), %rdi      # 0x7728
movq %rbx, %rsi
callq 0x34cb
cmpq $0x0, 0x8(%r14)
je 0x2c98
cmpq $0x0, 0x10(%r14)
je 0x2c98
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4aa8(%rip), %rdi      # 0x7747
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x34cb
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: init_room_info
void	init_room_info(t_info *info, int i)
{
	info->rooms[i]->visited = 0;
	info->rooms[i]->ants = 0;
	info->rooms[i]->ants_2 = 0;
	info->rooms[i]->path = -1;
	info->rooms[i]->path_2 = -1;
	info->rooms[i]->flow = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18a8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
movl %ecx, 0x5c(%rax)
movq $0x0, 0x30(%rax)
movq $-0x1, 0x50(%rax)
movl %ecx, 0x38(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d08
leaq 0x4a73(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x49f8
testq %rax, %rax
je 0x2d08
leaq 0x4a67(%rip), %rdi      # 0x776d
jmp 0x2d29
cmpq $0x0, (%r14)
je 0x2d31
leaq 0x4a76(%rip), %rsi      # 0x778b
movq %rbx, %rdi
callq 0x49f8
testq %rax, %rax
je 0x2d31
leaq 0x4a68(%rip), %rdi      # 0x7791
movq %r14, %rsi
callq 0x34cb
leaq 0x4a2d(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x49f8
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_O1/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 0x2e28
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 0x2e1a
movq %rsi, %r12
movl %edx, %esi
decl %esi
movl %esi, %ecx
shrl $0x1f, %ecx
addl %ecx, %edx
decl %edx
sarl %edx
xorl %r15d, %r15d
movl %esi, -0x2c(%rbp)
movq 0x18a8(%r14), %rax
movq %rdx, %r13
movslq %edx, %rbx
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x4780
testl %eax, %eax
je 0x2e17
movq %r12, %rsi
movq %r14, %r12
movq 0x18a8(%r14), %rax
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %rsi, %rbx
callq 0x4780
testl %eax, %eax
jle 0x2dea
leal -0x1(%r13), %esi
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
movl %eax, %edx
jmp 0x2e05
leal 0x1(%r13), %r15d
movl -0x2c(%rbp), %esi
movl %esi, %eax
subl %r15d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leal (%rcx,%r13), %edx
incl %edx
cmpl %esi, %r15d
movq %r12, %r14
movq %rbx, %r12
jle 0x2d92
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2e1a
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_O1/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
jne 0x2e5e
leaq 0x4753(%rip), %rdi      # 0x75a9
movq %r14, %rsi
callq 0x34cb
movq 0x18a8(%r14), %rax
movslq %r12d, %r12
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2ecb
movq 0x18a8(%r14), %rax
movslq %r15d, %r15
movq (%rax,%r15,8), %rdi
movq (%rax,%r12,8), %rsi
movl $0x1, %edx
callq 0x2ecb
movq 0x18a8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2ecb
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_O1/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 0x47cc
movq %rax, %r15
cmpl $0x1, %r12d
jne 0x2f36
leaq 0x10(%rbx), %rdi
callq 0x47a8
movq %r15, %rdi
callq 0x47cc
movq %rax, 0x10(%rbx)
movq %r15, %rdi
callq 0x1030
movq (%r14), %rdi
callq 0x47cc
movq %rax, %r15
movq %rbx, %rdi
callq 0x47a8
movq %r15, %rdi
callq 0x47cc
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1030
jmp 0x2f45
movq %r15, 0x10(%rbx)
movq (%r14), %rdi
callq 0x47cc
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
// File: /workspace/github_c_makefile_star2_O1/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 0x2f9e
movl 0x1060(%rdi), %r9d
movl $0x1, %eax
cmpl 0x105c(%rdi), %r9d
je 0x307b
cmpl $0x2, %r8d
jne 0x2fbd
movl 0x1064(%rdi), %r9d
movl $0x1, %eax
cmpl 0x105c(%rdi), %r9d
je 0x307b
cmpl $0x1, %r8d
jne 0x2fcc
cmpl $0x1, 0x1060(%rdi)
je 0x2fdb
cmpl $0x2, %r8d
jne 0x2fde
cmpl $0x1, 0x1064(%rdi)
jne 0x2fde
xorl %eax, %eax
retq
xorl %r9d, %r9d
cmpl $0x1, %r8d
setne %r10b
cmpl %esi, %ecx
jge 0x3057
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x18a8(%rdi), %r11
movslq %esi, %rax
movb %r10b, %r9b
movq 0x1898(%rdi,%r9,8), %rsi
movq (%rsi,%rax,8), %rsi
movslq (%rsi), %rsi
movq (%r11,%rsi,8), %rsi
movl 0x44(%rsi,%r9,4), %esi
xorl %r11d, %r11d
cmpl $0x1, %r8d
setne %r11b
movslq %ecx, %rcx
leaq 0x44(,%r11,4), %r9
movq 0x18a8(%rdi), %r10
movq 0x1898(%rdi,%r11,8), %r11
addl %esi, %edx
movq (%r11,%rcx,8), %rbx
movslq (%rbx), %rbx
movq (%r10,%rbx,8), %rbx
subl (%rbx,%r9), %edx
incq %rcx
cmpq %rcx, %rax
jne 0x303c
popq %rbx
popq %rbp
xorl %eax, %eax
cmpl 0x28(%rdi), %edx
setl %al
cmpl $0x1, %r8d
jne 0x306d
movl %eax, 0x1888(%rdi)
jmp 0x3073
movl %eax, 0x188c(%rdi)
xorl %eax, %eax
cmpl 0x28(%rdi), %edx
setge %al
retq
// File: /workspace/github_c_makefile_star2_O1/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), %edx
jne 0x30e3
movq 0x1898(%rdi), %rsi
movslq 0x1060(%rdi), %r8
movq (%rsi,%r8,8), %rsi
movl %edx, (%rsi,%rcx,4)
movslq (%rax,%rcx,4), %rdx
cmpl 0x103c(%rdi), %edx
je 0x3124
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 0x3124
movq 0x18a0(%rdi), %rsi
movslq 0x1064(%rdi), %r8
movq (%rsi,%r8,8), %rsi
movl %edx, (%rsi,%rcx,4)
movslq (%rax,%rcx,4), %rdx
cmpl 0x103c(%rdi), %edx
je 0x3124
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_O1/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 0x3169
movl %edx, 0x44(%rsi)
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl %edx, 0x3c(%rax)
jmp 0x3176
movl %edx, 0x48(%rsi)
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl %edx, 0x40(%rax)
movq 0x18a8(%rbx), %rax
movq 0x1048(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %r15
cmpq $0x0, 0x20(%r15)
jne 0x31bf
movslq 0x28(%rbx), %rax
leaq 0x1(,%rax,4), %rdi
callq 0x1080
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x31bf
leaq 0x43f2(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x34cb
cmpl $0x0, 0x28(%rbx)
js 0x31fd
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 0x31de
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3235
cmpl $0x0, 0x188c(%rbx)
je 0x32fa
movslq %r15d, %r12
movq 0x1048(%rbx), %rax
movq (%rax,%r12,8), %rax
movslq %r14d, %r13
cmpl $-0x1, (%rax,%r13,4)
je 0x3277
incq %r13
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x307c
movq 0x1048(%rbx), %rax
movq (%rax,%r12,8), %rax
incl %r14d
cmpl $-0x1, (%rax,%r13,4)
leaq 0x1(%r13), %r13
jne 0x3250
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x3126
cmpl $0x1, 0x106c(%rbx)
jne 0x3296
incl 0x1060(%rbx)
jmp 0x329c
incl 0x1064(%rbx)
movl $0x1, 0x1068(%rbx)
movq %rbx, %rdi
callq 0x43f7
cmpl $0x1, 0x106c(%rbx)
jne 0x32cf
movl 0x1060(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f78
testl %eax, %eax
jne 0x32f0
cmpl $0x2, 0x106c(%rbx)
jne 0x3309
movl 0x1064(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f78
testl %eax, %eax
je 0x3309
movl $0x2, 0x1068(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1cc8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1bc4
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4266(%rip), %r14      # 0x75a9
leaq 0x4463(%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 0x3373
incq %rcx
cmpq $0x3, %rcx
jne 0x335e
jmp 0x3428
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d50
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 0x33ae
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2d50
movl %eax, %r12d
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rdi
callq 0x278f
movl $0x8, %edi
callq 0x1080
movq 0x18a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
jne 0x33eb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34cb
movq 0x18a8(%rbx), %rax
movq (%rax,%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 0x334a
subl 0x28(%rbx), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4b78
jmp 0x334a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x346b
movl $0x1, %edx
testb $0x1, %cl
movb $0x1, %cl
je 0x3456
jmp 0x3495
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d50
testl %eax, %eax
js 0x3495
cmpl 0x103c(%rbx), %eax
je 0x3495
movq 0x18a8(%rbx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
cmpl $0x0, 0x50(%rcx)
js 0x349c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3328
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/get_links.c
// Function: copy_check_rooms
void	copy_check_rooms(t_info *info)
{
	int		i;

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1058(%rdi), %rdi
shlq $0x3, %rdi
callq 0x1080
movq %rax, 0x1048(%rbx)
testq %rax, %rax
jne 0x36a6
leaq 0x3f0b(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x34cb
cmpl $0x0, 0x1058(%rbx)
jle 0x3707
xorl %r15d, %r15d
leaq 0x3ef0(%rip), %r14      # 0x75a9
movl $0x804, %edi            # imm = 0x804
callq 0x1080
movq 0x1048(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
jne 0x36de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34cb
movq 0x1048(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
incq %r15
movslq 0x1058(%rbx), %rax
cmpq %rax, %r15
jl 0x36b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4153
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4028
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/print.c
// Function: print_paths
void			print_paths(t_info *info)
{
	int			y;
	int			i;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testb $0x40, 0x1040(%rsi)
jne 0x3e1e
leaq 0x3c83(%rip), %rsi      # 0x7a52
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
movq %r14, %rdi
callq 0x4720
leaq 0x3c53(%rip), %rsi      # 0x7a40
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
movq %rbx, %rdi
callq 0x4720
leaq 0x3bda(%rip), %rsi      # 0x79e5
movl $0x1, %edx
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $0x9, %eax
ja 0x3ea2
leaq 0x3a2c(%rip), %rcx      # 0x7874
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3b0a(%rip), %rdi      # 0x7962
jmp 0x3eae
leaq 0x3b4d(%rip), %rdi      # 0x79ae
jmp 0x3eae
leaq 0x3ba4(%rip), %rdi      # 0x7a0e
jmp 0x3eae
leaq 0x3b15(%rip), %rdi      # 0x7988
jmp 0x3eae
leaq 0x3b1f(%rip), %rdi      # 0x799b
jmp 0x3eae
leaq 0x3b62(%rip), %rdi      # 0x79e7
jmp 0x3eae
leaq 0x3ae7(%rip), %rdi      # 0x7975
jmp 0x3eae
leaq 0x3b2a(%rip), %rdi      # 0x79c1
jmp 0x3eae
leaq 0x3b34(%rip), %rdi      # 0x79d4
jmp 0x3eae
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3b4c(%rip), %rdi      # 0x79fa
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4b78
nop
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: reorder_check_rooms
void		reorder_check_rooms(t_info *info)
{
	int		i;
	int		t;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1070(%rdi), %eax
cmpl $0x3, %eax
je 0x3f11
cmpl $0x2, %eax
jne 0x3f18
movl 0x34(%rbx), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x3ef3
movl %ecx, 0x107c(%rbx,%rax,4)
movl 0x38(%rbx,%rax,4), %ecx
incq %rax
jmp 0x3ede
testl %eax, %eax
jle 0x3f25
leaq 0x107c(%rbx), %rcx
movl %eax, %eax
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, 0x30(%rbx,%rax,4)
decq %rax
jne 0x3f00
jmp 0x3f25
movl $0x2, %esi
jmp 0x3f1d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3f44
addq $0x107c, %rbx           # imm = 0x107C
movl $0x804, %edx            # imm = 0x804
movq %rbx, %rdi
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x34(%rdi), %rax
movl 0x34(%rdi), %edx
cmpl $-0x1, %edx
je 0x3f7f
xorl %ecx, %ecx
movl %edx, 0x1048(%rax,%rcx,4)
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x4(%rax,%rcx,4), %edx
incq %rcx
cmpl $-0x1, %edx
jne 0x3f56
movl %ecx, %r8d
shrl $0x1f, %r8d
addl %ecx, %r8d
sarl %r8d
jmp 0x3f82
xorl %r8d, %r8d
xorl %edx, %edx
cmpl $0x1, %esi
setne %dl
addl %r8d, %edx
cmpl $0x2, %esi
jne 0x3fce
movslq %edx, %r8
movl 0x107c(%rdi,%r8,4), %ecx
cmpl $-0x1, %ecx
je 0x3fce
movl %ecx, (%rax)
movl $0xffffffff, 0x107c(%rdi,%r8,4) # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $-0x1, 0x1080(%rdi,%r8,4)
je 0x3fc1
incl %edx
movl %edx, %ecx
addq $0x4, %rax
movl %ecx, %edx
cmpl $0x2, %esi
je 0x3f92
jmp 0x3fd0
movl %edx, %ecx
cmpl $0x1, %esi
jne 0x4026
testl %ecx, %ecx
js 0x4026
xorl %edx, %edx
movq $-0x1, %rax
movl %ecx, %esi
movl 0x107c(%rdi,%rsi,4), %r8d
movl %r8d, 0x38(%rdi,%rax,4)
movl $0xffffffff, 0x107c(%rdi,%rsi,4) # imm = 0xFFFFFFFF
subl $0x1, %ecx
jae 0x401f
testl %edx, %edx
jne 0x4026
movl $0x61f, %ecx            # imm = 0x61F
cmpl $-0x1, (%rdi,%rcx,4)
leaq -0x1(%rcx), %rcx
je 0x400a
addl $0xfffffbe2, %ecx       # imm = 0xFFFFFBE2
movl $0x1, %edx
incq %rax
testl %ecx, %ecx
jns 0x3fe2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: find_paths
void		find_paths(t_info *info, int i, int j, int s)
{
	int		l;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r12
movl 0x38(%rdi,%r12,4), %ecx
incq %r12
movslq %edx, %r14
cmpl $0x0, 0x1068(%rbx)
jne 0x413a
cmpl $0x1, 0x106c(%rbx)
movslq %ecx, %r13
jne 0x4087
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
cmpl $0x2, 0x4c(%rax)
jl 0x4087
cmpl $0x0, 0x50(%rax)
jns 0x4087
movq %rbx, %rdi
movl %ecx, %esi
movl %ecx, -0x2c(%rbp)
callq 0x3437
movl -0x2c(%rbp), %ecx
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rsi
testq %rsi, %rsi
je 0x40ab
movl %ecx, -0x2c(%rbp)
cmpl $0x0, 0x1068(%rbx)
je 0x40d2
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
incl 0x5c(%rax)
movl 0x38(%rbx,%r12,4), %ecx
incq %r12
movl $0x0, %r14d
cmpl $-0x1, %ecx
jne 0x4047
jmp 0x413a
leaq 0x8(,%r14,8), %r14
movq %rbx, %rdi
callq 0x2d50
movl %eax, %r15d
movq 0x18a8(%rbx), %rax
movslq %r15d, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x4107
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
movl %r15d, %edx
callq 0x3608
cmpl 0x103c(%rbx), %r15d
je 0x40ab
movq 0x18a8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14), %rsi
testq %rsi, %rsi
je 0x40ab
addq $0x8, %r14
cmpl $0x0, 0x1068(%rbx)
je 0x40da
jmp 0x40ab
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3599
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/source/run_path_finding.c
// Function: get_links_for_start
void		get_links_for_start(t_info *info, int i, int s, int t)
{
	while (s < 513)
	{
		info->check_rooms[s] = EMPTY;
		s++;
	}
	while (info->rooms[info->start_index]->links[i] != NULL)
	{
		s = find_a_room(info, info->rooms[info->start_index]->links[i]);
		if (info->rooms[s]->visited == 0)
		{
			info->rooms[s]->visited = 1;
			info->rooms[s]->level = info->level;
			info->index_stack[t][0] = s;
			info->check_rooms[t] = s;
			t++;
		}
		i++;
	}
	if (info->round > 1)
		reorder_check_rooms(info);
	info->rooms[info->start_index]->visited = 2;
	info->level++;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq -0x820(%rbp), %rdi
movl $0x804, %edx            # imm = 0x804
movl $0xff, %esi
callq 0x1060
movslq %r15d, %rax
cmpl $0x1, %ebx
jne 0x433d
movq 0x1898(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq $-0x1, %rdx
movl 0x4(%rcx,%rdx,4), %esi
movl %esi, -0x81c(%rbp,%rdx,4)
cmpl $0x1, %ebx
jne 0x42cc
leaq 0x1(%rdx), %rsi
cmpq $0x1ff, %rdx            # imm = 0x1FF
movq %rsi, %rdx
jl 0x42ac
cmpl $0x1, %ebx
jne 0x433d
movq 0x1898(%r14), %rdx
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
movq $-0x1, %rsi
movl 0x4(%rdx,%rsi,4), %edi
movl %edi, 0x4(%rcx,%rsi,4)
cmpl $0x1, %ebx
jne 0x4305
leaq 0x1(%rsi), %rdi
cmpq $0x1ff, %rsi            # imm = 0x1FF
movq %rdi, %rsi
jl 0x42e8
cmpl $0x1, %ebx
jne 0x433d
movq 0x1898(%r14), %rcx
movq 0x8(%rcx,%rax,8), %rcx
movq $-0x1, %rdx
movl -0x81c(%rbp,%rdx,4), %esi
movl %esi, 0x4(%rcx,%rdx,4)
cmpl $0x1, %ebx
jne 0x433d
leaq 0x1(%rdx), %rsi
cmpq $0x1ff, %rdx            # imm = 0x1FF
movq %rsi, %rdx
jl 0x431d
cmpl $0x2, %ebx
jne 0x43e9
movq 0x18a0(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq $-0x1, %rdx
movl 0x4(%rcx,%rdx,4), %esi
movl %esi, -0x81c(%rbp,%rdx,4)
cmpl $0x2, %ebx
jne 0x4378
leaq 0x1(%rdx), %rsi
cmpq $0x1ff, %rdx            # imm = 0x1FF
movq %rsi, %rdx
jl 0x4358
cmpl $0x2, %ebx
jne 0x43e9
movq 0x18a0(%r14), %rdx
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
movq $-0x1, %rsi
movl 0x4(%rdx,%rsi,4), %edi
movl %edi, 0x4(%rcx,%rsi,4)
cmpl $0x2, %ebx
jne 0x43b1
leaq 0x1(%rsi), %rdi
cmpq $0x1ff, %rsi            # imm = 0x1FF
movq %rdi, %rsi
jl 0x4394
cmpl $0x2, %ebx
jne 0x43e9
movq 0x18a0(%r14), %rcx
movq 0x8(%rcx,%rax,8), %rax
movq $-0x1, %rcx
movl -0x81c(%rbp,%rcx,4), %edx
movl %edx, 0x4(%rax,%rcx,4)
cmpl $0x2, %ebx
jne 0x43e9
leaq 0x1(%rcx), %rdx
cmpq $0x1ff, %rcx            # imm = 0x1FF
movq %rdx, %rcx
jl 0x43c9
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq