LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
pushq $0x68
popq %rdi
callq 0x1070
movq %rax, %rbx
testq %rax, %rax
jne 0x2b95
leaq 0x4a1c(%rip), %rdi      # 0x75a9
movq %r14, %rsi
callq 0x31ab
movq 0x18a8(%r14), %rax
movslq %r12d, %r12
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2c08
movq 0x18a8(%r14), %rax
movslq %r15d, %r13
movq (%rax,%r13,8), %rdi
movq (%rax,%r12,8), %rsi
pushq $0x1
popq %r15
movl %r15d, %edx
callq 0x2c08
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x2c08
movq 0x10(%rbx), %rdi
callq 0x1030
movq (%rbx), %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_O2/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 0x4228
movq %rax, %r15
cmpl $0x1, %r12d
jne 0x2c73
leaq 0x10(%rbx), %rdi
callq 0x4204
movq %r15, %rdi
callq 0x4228
movq %rax, 0x10(%rbx)
movq %r15, %rdi
callq 0x1030
movq (%r14), %rdi
callq 0x4228
movq %rax, %r15
movq %rbx, %rdi
callq 0x4204
movq %r15, %rdi
callq 0x4228
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1030
jmp 0x2c82
movq %r15, 0x10(%rbx)
movq (%r14), %rdi
callq 0x4228
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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), %eax
cmpl $0x1, %eax
jne 0x2ceb
movl 0x1060(%rdi), %r8d
cmpl 0x105c(%rdi), %r8d
je 0x2d10
cmpl $0x1, %r8d
je 0x2d1c
movabsq $0x44, %r9
movl $0x1898, %r10d          # imm = 0x1898
jmp 0x2d1f
movabsq $0x48, %r9
movl $0x18a0, %r10d          # imm = 0x18A0
cmpl $0x2, %eax
jne 0x2d1f
movl 0x1064(%rdi), %r8d
cmpl 0x105c(%rdi), %r8d
jne 0x2d16
movl $0x1, %eax
retq
cmpl $0x1, %r8d
jne 0x2d1f
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %r11d, %r11d
cmpl $0x1, %eax
setne %r11b
movq 0x18a8(%rdi), %r8
movq (%rdi,%r10), %r10
movslq %esi, %rsi
movq (%r10,%rsi,8), %r10
movslq (%r10), %r10
movq (%r8,%r10,8), %r10
movl (%r10,%r9), %r9d
movslq %ecx, %rcx
leaq 0x1898(,%r11,8), %r10
leaq 0x44(,%r11,4), %r11
cmpq %rsi, %rcx
jge 0x2d7e
movq (%rdi,%r10), %rbx
movq (%rbx,%rcx,8), %rbx
movslq (%rbx), %rbx
movq (%r8,%rbx,8), %rbx
addl %r9d, %edx
subl (%rbx,%r11), %edx
incq %rcx
jmp 0x2d5e
movl 0x28(%rdi), %ecx
xorl %esi, %esi
cmpl %ecx, %edx
setl %sil
cmpl $0x1, %eax
popq %rbx
popq %rbp
jne 0x2d98
movl %esi, 0x1888(%rdi)
jmp 0x2d9e
movl %esi, 0x188c(%rdi)
xorl %eax, %eax
cmpl %ecx, %edx
setge %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e0d
movq 0x1898(%rdi), %r8
movslq 0x1060(%rdi), %r9
movq (%r8,%r9,8), %r8
movl %esi, (%r8,%rcx,4)
cmpl 0x103c(%rdi), %esi
je 0x2e4b
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 0x2e4b
movq 0x18a0(%rdi), %r8
movslq 0x1064(%rdi), %r9
movq (%r8,%r9,8), %r8
movl %esi, (%r8,%rcx,4)
cmpl 0x103c(%rdi), %esi
je 0x2e4b
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_O2/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 0x2e90
movl %edx, 0x44(%rsi)
movslq (%rcx), %rsi
movq (%rax,%rsi,8), %rsi
movl %edx, 0x3c(%rsi)
jmp 0x2e9d
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 0x2ed4
movslq 0x28(%rbx), %rax
leaq 0x1(,%rax,4), %rdi
callq 0x1070
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x2ed4
leaq 0x46dd(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x31ab
xorl %eax, %eax
movslq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jg 0x2f05
movq 0x18a8(%rbx), %rcx
movq 0x1048(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %rcx
andl $0x0, (%rcx,%rax,4)
incq %rax
jmp 0x2ed6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x2, 0x106c(%rdi)
jne 0x2f37
cmpl $0x0, 0x188c(%rbx)
je 0x2fe9
movslq %r14d, %r12
movslq %edx, %r15
movq 0x1048(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $-0x1, (%rax,%r15,4)
je 0x2f62
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x2da6
incq %r15
jmp 0x2f3d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x2e4d
cmpl $0x1, 0x106c(%rbx)
jne 0x2f81
incl 0x1060(%rbx)
jmp 0x2f87
incl 0x1064(%rbx)
movl $0x1, 0x1068(%rbx)
movq %rbx, %rdi
callq 0x3eda
movl 0x106c(%rbx), %eax
cmpl $0x1, %eax
jne 0x2fc2
movl 0x1060(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cb8
testl %eax, %eax
jne 0x2fdf
movl 0x106c(%rbx), %eax
cmpl $0x2, %eax
jne 0x2ff2
movl 0x1064(%rbx), %esi
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cb8
testl %eax, %eax
je 0x2ff2
movl $0x2, 0x1068(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1b55
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1a84
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r13d
movq %rdi, %rbx
pushq $0x8
popq %r14
leaq 0x4782(%rip), %r12      # 0x77ad
movq 0x18a8(%rbx), %rax
movslq %r13d, %r15
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3054
incq %rcx
cmpq $0x3, %rcx
jne 0x303f
jmp 0x3108
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2aa0
movl %eax, %r13d
movq 0x18a8(%rbx), %rax
movslq %r13d, %rcx
movq (%rax,%rcx,8), %rcx
movl 0x4c(%rcx), %ecx
movq (%rax,%r15,8), %rax
cmpl 0x4c(%rax), %ecx
jle 0x309a
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2aa0
movl %eax, %r13d
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
callq 0x2527
movq %r14, %rdi
callq 0x1070
movq 0x18a8(%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, 0x8(%rdx)
testq %rax, %rax
jne 0x30d5
leaq 0x44e3(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x31ab
movq 0x18a8(%rbx), %rcx
movq (%rcx,%r15,8), %rax
movq 0x8(%rax), %rax
andq $0x0, (%rax)
movl 0x30(%rbx), %esi
incl %esi
movl %esi, 0x30(%rbx)
testb $0x40, 0x1040(%rbx)
je 0x302b
subl 0x28(%rbx), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x4574
jmp 0x302b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdx
xorl %esi, %esi
cmpq $0x0, (%rax,%rsi,8)
je 0x314c
movq %rdx, %rsi
testb $0x1, %cl
movb $0x1, %cl
je 0x3139
jmp 0x3176
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2aa0
testl %eax, %eax
js 0x3176
cmpl 0x103c(%rbx), %eax
je 0x3176
movq 0x18a8(%rbx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
cmpl $0x0, 0x50(%rcx)
js 0x317d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x300c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x34(%rdi), %rax
cmpl $-0x1, (%rax)
je 0x31e6
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x31d8
addq $0x107c, %rdi           # imm = 0x107C
movq %rdi, %rax
movl (%rax), %ecx
cmpl $-0x1, %ecx
je 0x320a
movl %ecx, -0x1048(%rax)
addq $0x4, %rax
jmp 0x31f0
orl $-0x1, (%rdi)
addq $0x4, %rdi
cmpl $-0x1, (%rdi)
jne 0x3203
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3252
movq 0x18a8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rcx
cmpl $0x1, 0x38(%rcx)
jne 0x323a
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
je 0x3252
pushq %rbp
movq %rsp, %rbp
addq $0x107c, %rdi           # imm = 0x107C
cmpl $-0x1, (%rdi)
leaq 0x4(%rdi), %rdi
jne 0x3245
movl %edx, -0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3283
cmpl $0x0, 0x34(%rbx)
js 0x3283
cmpl $0x0, 0x107c(%rbx)
js 0x3283
movq %rbx, %rdi
callq 0x31d0
incl 0x1050(%rbx)
jmp 0x32a1
cmpl $0x1, 0x1068(%rbx)
jne 0x32b6
andl $0x0, 0x1068(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3cc6
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3bd7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x32f7
movl 0x1050(%r14), %ecx
movl %ecx, 0x4c(%rax)
pushq $-0x1
popq %rcx
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x1914
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3211
// File: /workspace/github_c_makefile_star2_O2/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 0x1070
movq %rax, 0x1048(%rbx)
testq %rax, %rax
jne 0x3359
leaq 0x4258(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x31ab
xorl %r15d, %r15d
leaq 0x4246(%rip), %r14      # 0x75a9
movslq 0x1058(%rbx), %rax
cmpq %rax, %r15
jge 0x33b8
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq 0x1048(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
jne 0x3394
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31ab
movq 0x1048(%rbx), %rax
movq (%rax,%r15,8), %rax
xorl %ecx, %ecx
cmpq $0x201, %rcx            # imm = 0x201
je 0x33b3
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x33a1
incq %r15
jmp 0x3363
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3cc6
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3bd7
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x5b
popq %r15
leaq 0x3fb3(%rip), %r12      # 0x7872
movq 0x1898(%rbx), %rax
movq (%rax,%r14,8), %rax
cmpl $-0x1, (%rax)
je 0x3919
movl %r15d, %edi
callq 0x40c4
xorl %r13d, %r13d
movq 0x1898(%rbx), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%r13), %rax
cmpq $-0x1, %rax
je 0x390c
movq 0x18a8(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdi
movl %r14d, %esi
callq 0x39b4
addq $0x4, %r13
jmp 0x38da
movq %r12, %rdi
callq 0x4194
incq %r14
jmp 0x38bf
pushq $0xa
popq %rdi
callq 0x40c4
cmpl $0x0, 0x1064(%rbx)
jle 0x399e
leaq 0x3fdb(%rip), %rdi      # 0x790c
callq 0x4194
xorl %r14d, %r14d
pushq $0x5b
popq %r15
leaq 0x3f2e(%rip), %r12      # 0x7872
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
cmpl $-0x1, (%rax)
je 0x399e
movl %r15d, %edi
callq 0x40c4
xorl %r13d, %r13d
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%r13), %rax
cmpq $-0x1, %rax
je 0x3991
movq 0x18a8(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdi
movl %r14d, %esi
callq 0x39b4
addq $0x4, %r13
jmp 0x395f
movq %r12, %rdi
callq 0x4194
incq %r14
jmp 0x3944
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40c4
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testb $0x40, 0x1040(%rsi)
jne 0x3a54
leaq 0x404c(%rip), %rsi      # 0x7a51
pushq $0x1
popq %r15
pushq $0x1
popq %r12
movl %r15d, %edi
movq %r12, %rdx
callq 0x1040
movq %r14, %rdi
callq 0x4194
leaq 0x4018(%rip), %rsi      # 0x7a3f
movl %r15d, %edi
movq %r12, %rdx
callq 0x1040
movq %rbx, %rdi
callq 0x4194
leaq 0x3f52(%rip), %rsi      # 0x7993
movl %r15d, %edi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
pushq $0xa
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
cmpl $0x9, %edx
ja 0x3a86
movl %edx, %eax
leaq 0x3f8e(%rip), %rcx      # 0x79f8
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4574
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3ad8
cmpl $0x2, %eax
jne 0x3adc
leaq 0x107c(%rbx), %rax
xorl %ecx, %ecx
movl -0x1048(%rax,%rcx,4), %edx
cmpl $-0x1, %edx
je 0x3ad0
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x3ab2
movl (%rax), %edx
movl %edx, 0x34(%rbx,%rcx,4)
addq $0x4, %rax
subq $0x1, %rcx
jae 0x3ac6
jmp 0x3ae7
pushq $0x2
jmp 0x3ade
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3b05
xorl %eax, %eax
cmpq $0x201, %rax            # imm = 0x201
je 0x3afe
orl $-0x1, 0x107c(%rbx,%rax,4)
incq %rax
jmp 0x3ae9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r8
xorl %eax, %eax
movl (%r8,%rax,4), %ecx
cmpl $-0x1, %ecx
je 0x3b2a
movl %ecx, 0x1048(%r8,%rax,4)
orl $-0x1, (%r8,%rax,4)
incq %rax
jmp 0x3b0f
xorl %ecx, %ecx
cmpl $0x1, %esi
setne %cl
movl $0x2, %r9d
cltd
idivl %r9d
addl %eax, %ecx
movl %ecx, %eax
cmpl $0x2, %esi
jne 0x3b7a
movslq %eax, %r9
movl 0x107c(%rdi,%r9,4), %edx
cmpl $-0x1, %edx
je 0x3b7f
movl %edx, (%r8)
orl $-0x1, 0x107c(%rdi,%r9,4)
xorl %edx, %edx
cmpl $-0x1, 0x1080(%rdi,%r9,4)
je 0x3b72
incl %eax
movl %eax, %edx
addq $0x4, %r8
movl %edx, %eax
jmp 0x3b40
cmpl $0x1, %esi
je 0x3b81
popq %rbp
retq
leaq 0x107c(%rdi), %rax
movb $0x1, %sil
movabsq $-0x1, %rdx
movl %ecx, %r8d
leaq (%rax,%r8,4), %r8
testl %ecx, %ecx
js 0x3b7f
movl (%r8), %r9d
movl %r9d, 0x38(%rdi,%rdx,4)
orl $-0x1, (%r8)
incq %rdx
addq $-0x4, %r8
addl $-0x1, %ecx
jb 0x3b9c
testb $0x1, %sil
je 0x3b7f
movl $0x61f, %ecx            # imm = 0x61F
cmpl $-0x1, (%rdi,%rcx,4)
leaq -0x1(%rcx), %rcx
je 0x3bc3
addl $0xfffffbe2, %ecx       # imm = 0xFFFFFBE2
xorl %esi, %esi
jmp 0x3b95
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edx, %r13
movslq 0x38(%rbx,%r12,4), %r15
cmpq $-0x1, %r15
je 0x3cad
cmpl $0x0, 0x1068(%rbx)
jne 0x3cad
cmpl $0x1, 0x106c(%rbx)
jne 0x3c35
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, 0x4c(%rax)
jl 0x3c35
cmpl $0x0, 0x50(%rax)
jns 0x3c35
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3117
incq %r12
shlq $0x3, %r13
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r13), %rsi
testq %rsi, %rsi
je 0x3ca2
cmpl $0x0, 0x1068(%rbx)
jne 0x3ca2
movq %rbx, %rdi
callq 0x2aa0
movl %eax, %r14d
movq 0x18a8(%rbx), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x3c8a
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x32bd
addq $0x8, %r13
cmpl 0x103c(%rbx), %r14d
jne 0x3c3c
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
incl 0x5c(%rax)
xorl %r13d, %r13d
jmp 0x3bee
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3253
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movslq %edx, %rax
cmpq $0x201, %rax            # imm = 0x201
jge 0x3ceb
orl $-0x1, 0x34(%rbx,%rax,4)
incq %rax
jmp 0x3cd9
movslq %esi, %r15
movq 0x18a8(%rbx), %rcx
shlq $0x3, %r15
movslq 0x1078(%rbx), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r15), %rsi
testq %rsi, %rsi
je 0x3d5b
movq %rbx, %rdi
callq 0x2aa0
movq 0x18a8(%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, 0x5c(%rdx)
jne 0x3d55
movl $0x1, 0x5c(%rdx)
movl 0x1050(%rbx), %esi
movl %esi, 0x4c(%rdx)
movq 0x1048(%rbx), %rdx
movslq %r14d, %r14
movq (%rdx,%r14,8), %rdx
movl %eax, (%rdx)
movl %eax, 0x34(%rbx,%r14,4)
incl %r14d
addq $0x8, %r15
jmp 0x3cf9
cmpl $0x2, 0x1070(%rbx)
jl 0x3d7e
movq %rbx, %rdi
callq 0x3a90
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_O2/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
subq $0x790, %rsp            # imm = 0x790
xorl %eax, %eax
cmpq $0x201, %rax            # imm = 0x201
je 0x3dba
orl $-0x1, -0x810(%rbp,%rax,4)
incq %rax
jmp 0x3da5
movslq %esi, %rax
cmpl $0x1, %edx
jne 0x3e48
movq 0x1898(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
xorl %esi, %esi
cmpq $0x201, %rsi            # imm = 0x201
je 0x3ded
movl (%rcx,%rsi,4), %r8d
movl %r8d, -0x810(%rbp,%rsi,4)
incq %rsi
jmp 0x3dd3
cmpl $0x1, %edx
jne 0x3e48
movq 0x1898(%rdi), %rsi
movq (%rsi,%rax,8), %rcx
movq 0x8(%rsi,%rax,8), %rsi
xorl %r8d, %r8d
cmpq $0x201, %r8             # imm = 0x201
je 0x3e1b
movl (%rsi,%r8,4), %r9d
movl %r9d, (%rcx,%r8,4)
incq %r8
jmp 0x3e05
cmpl $0x1, %edx
jne 0x3e48
movq 0x1898(%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rcx
xorl %esi, %esi
cmpq $0x201, %rsi            # imm = 0x201
je 0x3e48
movl -0x810(%rbp,%rsi,4), %r8d
movl %r8d, (%rcx,%rsi,4)
incq %rsi
jmp 0x3e2e
cmpl $0x2, %edx
jne 0x3ed1
movq 0x18a0(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
xorl %esi, %esi
cmpq $0x201, %rsi            # imm = 0x201
je 0x3e78
movl (%rcx,%rsi,4), %r8d
movl %r8d, -0x810(%rbp,%rsi,4)
incq %rsi
jmp 0x3e5e
cmpl $0x2, %edx
jne 0x3ed1
movq 0x18a0(%rdi), %rsi
movq (%rsi,%rax,8), %rcx
movq 0x8(%rsi,%rax,8), %rsi
xorl %r8d, %r8d
cmpq $0x201, %r8             # imm = 0x201
je 0x3ea6
movl (%rsi,%r8,4), %r9d
movl %r9d, (%rcx,%r8,4)
incq %r8
jmp 0x3e90
cmpl $0x2, %edx
jne 0x3ed1
movq 0x18a0(%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rax
xorl %ecx, %ecx
cmpq $0x201, %rcx            # imm = 0x201
je 0x3ed1
movl -0x810(%rbp,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x3eb9
addq $0x790, %rsp            # imm = 0x790
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/sort_paths.c
// Function: sort_paths
void	sort_paths(t_info *info)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %r15
pushq $0x1
popq %r14
movl %r15d, %esi
cmpl $0x2, 0x1060(%rbx)
jl 0x3f43
movq 0x1898(%rbx), %rax
movslq %esi, %rcx
movq 0x10(%rax,%rcx,8), %rcx
movslq (%rcx), %rcx
cmpq $-0x1, %rcx
je 0x3f43
incl %esi
movq 0x18a8(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x44(%rcx), %ecx
movslq %esi, %rdi
movq (%rax,%rdi,8), %rax
movslq (%rax), %rax
movq (%rdx,%rax,8), %rax
cmpl 0x44(%rax), %ecx
jge 0x3ef2
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3d98
jmp 0x3eef
pushq $-0x1
popq %r15
pushq $0x2
popq %r14
movl %r15d, %esi
cmpl $0x2, 0x1064(%rbx)
jl 0x3f9f
movq 0x18a0(%rbx), %rax
movslq %esi, %rcx
movq 0x10(%rax,%rcx,8), %rcx
movslq (%rcx), %rcx
cmpq $-0x1, %rcx
je 0x3f9f
incl %esi
movq 0x18a8(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x48(%rcx), %ecx
movslq %esi, %rdi
movq (%rax,%rdi,8), %rax
movslq (%rax), %rax
movq (%rdx,%rax,8), %rax
cmpl 0x48(%rax), %ecx
jge 0x3f4e
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3d98
jmp 0x3f4b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	int		res;
	int		sign;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movabsq $0x100003e00, %rax      # imm = 0x100003E00
movzbl (%rdi), %ebx
cmpq $0x20, %rbx
ja 0x3fd1
btq %rbx, %rax
jae 0x3fd1
incq %rdi
jmp 0x3fbd
cmpl $0x2b, %ebx
je 0x3fdb
cmpl $0x2d, %ebx
jne 0x3fde
incq %rdi
xorl %r14d, %r14d
pushq $-0x1
popq %rax
movsbl (%rdi), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x4008
imull $0xa, %r14d, %ecx
movzbl %dl, %r14d
addl %ecx, %r14d
incq %rdi
cmpl $0xf423f, %r14d         # imm = 0xF423F
jle 0x3fe4
jmp 0x402f
testb %cl, %cl
je 0x4023
movl %ecx, %edi
callq 0x4034
testl %eax, %eax
jne 0x4023
leaq 0x3a02(%rip), %rdi      # 0x7a20
callq 0x3190
movl %r14d, %eax
negl %eax
cmpl $0x2d, %ebx
cmovnel %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_itoa.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	size_t		count;
	long		nbr;
	char		*str;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq %edi, %r14
movq %r14, %rdi
callq 0x44d8
movq %rax, %rbx
movq %rax, %rdi
callq 0x4344
movq %rax, %rcx
testq %rax, %rax
je 0x40bc
movq %r14, %rax
negq %rax
cmovsq %r14, %rax
testl %r14d, %r14d
jg 0x409e
sete %dl
movzbl %dl, %edx
leal (%rdx,%rdx,2), %edx
addl $0x2d, %edx
movb %dl, (%rcx)
leaq (%rbx,%rcx), %rsi
decq %rsi
pushq $0xa
popq %rdi
testq %rax, %rax
je 0x40bc
xorl %edx, %edx
divq %rdi
orb $0x30, %dl
movb %dl, (%rsi)
decq %rsi
jmp 0x40a8
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putendl.c
// Function: ft_putendl
void	ft_putendl(char const *s)
{
	int len;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rbx
testl %ebx, %ebx
jns 0x4160
pushq $0x2d
popq %rdi
callq 0x40c4
negq %rbx
cmpq $0xa, %rbx
jl 0x4176
pushq $0xa
popq %rcx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %edi
callq 0x4148
pushq $0xa
popq %rcx
movq %rbx, %rax
cqto
idivq %rcx
addb $0x30, %dl
movsbl %dl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40c4
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edx, %edx
movzbl (%rdi,%rdx), %eax
movzbl (%rsi,%rdx), %ecx
testl %eax, %eax
je 0x41fb
incq %rdx
cmpb %cl, %al
je 0x41e6
jmp 0x41fd
xorl %eax, %eax
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	int		i;
	int		c;
	char	*dst;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x4235
movl %r14d, %edi
callq 0x48e8
testq %rax, %rax
je 0x426b
leaq -0x1(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4265
movb (%rbx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x4253
movb $0x0, -0x1(%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strequ.c
// Function: ft_strequ
int		ft_strequ(char const *s1, char const *s2)
{
	while (s1[0] != '\0' && !(*(s1) ^ *(s2)))
	{
		s1++;
		s2++;
	}
	return (!(*(s1) ^ *(s2)));
}

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

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

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x4308
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x431c
movq %rax, %r12
movq %rbx, %rdi
callq 0x431c
movq %rax, %r14
addl %r12d, %eax
movslq %eax, %rdi
callq 0x4344
xorl %r13d, %r13d
testq %rax, %rax
je 0x430b
movq %rax, %rdi
movq %r15, %rsi
callq 0x4938
movslq %r12d, %rcx
testl %r14d, %r14d
cmovlel %r13d, %r14d
addq %rax, %rcx
cmpq %r13, %r14
je 0x430d
movb (%rbx,%r13), %dl
movb %dl, (%rcx,%r13)
incq %r13
jmp 0x42f6
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsplit.c
// Function: ft_strsplit
char		**ft_strsplit(char const *s, char c)
{
	unsigned int	i;
	size_t			start;
	char			**str;
	int				y;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x43e3
movl %esi, %ebx
movq %rdi, %r14
movsbl %bl, %esi
movl %esi, -0x2c(%rbp)
callq 0x43f8
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x48e8
testq %rax, %rax
je 0x43e3
movq %rax, %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
movl -0x2c(%rbp), %esi
callq 0x43f8
cltq
cmpq %rax, %r13
jge 0x43e6
movl %r15d, %eax
incl %r15d
cmpb %bl, (%r14,%rax)
je 0x43a6
movl %r15d, %esi
decl %esi
movl %esi, %r15d
movl %r15d, %edx
movb (%r14,%rdx), %cl
incl %r15d
testb %cl, %cl
je 0x43cc
cmpb %bl, %cl
jne 0x43ba
subq %rax, %rdx
movq %r14, %rdi
callq 0x446c
movq %rax, (%r12,%r13,8)
incq %r13
testq %rax, %rax
jne 0x4394
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsplit.c
// Function: ft_count
static int	ft_count(const char *str, int d)
{
	int	i;
	int	count;

	i = 0;
	count = 0;
	while (str[i])
	{
		if ((str[i] != d && str[i + 1] == d) ||
				(str[i] != d && str[i + 1] == '\0'))
			count++;
		i++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
movsbl -0x1(%rdi), %ecx
testl %ecx, %ecx
je 0x4426
cmpl %esi, %ecx
je 0x4421
movsbl (%rdi), %ecx
testl %ecx, %ecx
sete %dl
cmpl %esi, %ecx
sete %cl
orb %dl, %cl
movzbl %cl, %ecx
addl %ecx, %eax
incq %rdi
jmp 0x4401
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strstr.c
// Function: ft_strstr
char	*ft_strstr(const char *haystack, const char *needle)
{
	int	i;
	int	t;

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

// Assembly:
movq %rdi, %rax
movb (%rsi), %cl
testb %cl, %cl
je 0x4467
pushq %rbp
movq %rsp, %rbp
movq %rax, %rdi
xorl %edx, %edx
cmpb $0x0, (%rax,%rdx)
je 0x4468
movl %ecx, %r9d
xorl %r8d, %r8d
cmpb %r9b, (%rdi,%r8)
jne 0x445b
movb 0x1(%rsi,%r8), %r9b
incq %r8
testb %r9b, %r9b
jne 0x4446
jmp 0x4463
incq %rdx
incq %rdi
jmp 0x443a
addq %rdx, %rax
popq %rbp
retq
xorl %eax, %eax
jmp 0x4466
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsub.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char			*sub;
	size_t			i;
	unsigned int	index;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x44a6
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
callq 0x1070
testq %rax, %rax
je 0x44a6
movq %rax, %rbx
movl %r12d, %r12d
movq %r15, %rdi
callq 0x431c
cmpq %r12, %rax
jae 0x44b4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
leal (%r12,%rax), %ecx
movb (%r15,%rcx), %cl
movl %eax, %edx
testb %cl, %cl
je 0x44d1
cmpq %r14, %rax
jae 0x44d1
movb %cl, (%rbx,%rdx)
incq %rax
jmp 0x44b6
movb $0x0, (%rbx,%rdx)
jmp 0x44a8
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_nbrcount.c
// Function: ft_nbrcount
size_t	ft_nbrcount(intmax_t nbr)
{
	size_t count;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x4508
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
shrq $0x3f, %rdi
movabsq $0xa, %rcx
testq %rax, %rax
je 0x4512
xorl %edx, %edx
divq %rcx
incq %rdi
jmp 0x44f9
movabsq $0x1, %rdi
movq %rdi, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: set_ids
t_tags	*set_ids(t_tags *ids)
{
	ids->i = 0;
	ids->printed_chars = 0;
	ids->flag = "#0 +-";
	ids->arg_type = "%cCspdDiouxXf";
	ids->modifiers = "hlL";
	return (ids);
}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x5e(%rdi), %al
cmpb $0x63, %al
jne 0x4673
movq %rbx, %rdi
callq 0x4958
movb 0x5e(%rbx), %al
cmpb $0x73, %al
jne 0x4682
movq %rbx, %rdi
callq 0x4e40
movb 0x5e(%rbx), %al
cmpb $0x70, %al
jne 0x4691
movq %rbx, %rdi
callq 0x4cf4
movb 0x5e(%rbx), %al
cmpb $0x69, %al
je 0x469d
movzbl %al, %ecx
cmpl $0x64, %ecx
jne 0x46a8
movq %rbx, %rdi
callq 0x57ef
movb 0x5e(%rbx), %al
cmpb $0x25, %al
jne 0x46b7
movq %rbx, %rdi
callq 0x5a8c
movb 0x5e(%rbx), %al
cmpb $0x6f, %al
jne 0x46c6
movq %rbx, %rdi
callq 0x5938
movb 0x5e(%rbx), %al
cmpb $0x75, %al
jne 0x46d5
movq %rbx, %rdi
callq 0x5c2f
movb 0x5e(%rbx), %al
movzbl %al, %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x46eb
movq %rbx, %rdi
callq 0x4f34
movb 0x5e(%rbx), %al
cmpb $0x66, %al
jne 0x46f7
movq %rbx, %rdi
callq 0x49d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq