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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, 0x106c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1050(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1064(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1060(%rax)
jge 0x292a
movq -0x8(%rbp), %rsi
leaq 0x9c22(%rip), %rdi      # 0xc547
callq 0x4f60
movq -0x8(%rbp), %rdi
callq 0x2360
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x296e
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x5c(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2933
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x63a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6200
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
je 0x29bd
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x29bd
movq -0x8(%rbp), %rdi
callq 0x5a90
movq -0x8(%rbp), %rdi
callq 0x3500
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: split_link_string
void	split_link_string(t_info *info, int index)
{
	info->rooms[index]->links =
	ft_strsplit(info->rooms[index]->link_string, ' ');
	free(info->rooms[index]->link_string);
	if (info->rooms[index]->start_or_end != 0)
	{
		if (info->rooms[index]->start_or_end == 1)
			info->start_index = index;
		else
			info->end_index = index;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x7260
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x2a84
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x58(%rax)
jne 0x2a75
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1078(%rax)
jmp 0x2a82
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x103c(%rax)
jmp 0x2a84
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: first_from_index
void	first_from_index(t_info *info, int i)
{
	int		first;
	int		placement;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2be7
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x6f10
cmpl $0x0, %eax
jge 0x2b06
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2be2
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x60(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x60(%rcx), %eax
jne 0x2b96
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x64(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x64(%rcx), %eax
jne 0x2b96
movq -0x8(%rbp), %rsi
leaq 0x99ce(%rip), %rdi      # 0xc55d
callq 0x4f60
jmp 0x2be0
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x6f10
cmpl $0x0, %eax
jne 0x2bde
movq -0x8(%rbp), %rsi
leaq 0x99ad(%rip), %rdi      # 0xc586
callq 0x4f60
jmp 0x2be0
jmp 0x2be2
jmp 0x2aae
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x4410
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2c1d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x29d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: malloc_for_valid_indexes
void	malloc_for_valid_indexes(t_info *info, int i, int x)
{
	if (!(info->valid_indexes =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_indexes_2 =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_paths =
	(char**)malloc(sizeof(char*) * info->max_paths + 1))
	|| !(info->valid_paths_2 =
	(char**)malloc(sizeof(char*) * info->max_paths + 1)))
		exit_error(ERR_MALLOC, info);
	while (i < info->max_paths + 1)
	{
		if (!(info->valid_indexes[i] = (int*)malloc(sizeof(int) * 513))
		|| !(info->valid_indexes_2[i] = (int*)malloc(sizeof(int) * 513)))
			exit_error(ERR_MALLOC, info);
		while (x < 513)
		{
			info->valid_indexes[i][x] = EMPTY;
			info->valid_indexes_2[i][x] = EMPTY;
			x++;
		}
		x = 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq 0x105c(%rax), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x1898(%rcx)
cmpq $0x0, %rax
je 0x2ce0
movq -0x8(%rbp), %rax
movslq 0x105c(%rax), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x18a0(%rcx)
cmpq $0x0, %rax
je 0x2ce0
movq -0x8(%rbp), %rax
movslq 0x105c(%rax), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
je 0x2ce0
movq -0x8(%rbp), %rax
movslq 0x105c(%rax), %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x1070
movq -0x8(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x2cf0
movq -0x8(%rbp), %rsi
leaq 0x98be(%rip), %rdi      # 0xc5a9
callq 0x4f60
jmp 0x2cf2
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x105c(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2dc7
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
je 0x2d50
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x2d60
movq -0x8(%rbp), %rsi
leaq 0x984e(%rip), %rdi      # 0xc5a9
callq 0x4f60
jmp 0x2d62
cmpl $0x201, -0x10(%rbp)     # imm = 0x201
jge 0x2db2
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2d62
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cf2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: sort_rooms
void	sort_rooms(t_info *info)
{
	int		i;
	int		x;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2e1c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2dea
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x29d0
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1078(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2e63
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e2f
jmp 0x2e65
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x103c(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2e99
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2e65
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2ea9
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2eaf
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x105c(%rax)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2c30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: reset_valid_indexes_2
void		reset_valid_indexes_2(t_info *info)
{
	int		y;
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x105c(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3002
jmp 0x2f00
cmpl $0x201, -0x10(%rbp)     # imm = 0x201
jge 0x2fed
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x2fc1
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2f00
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ee6
movq -0x8(%rbp), %rax
movl $0x0, 0x1064(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: path_set_insert
void		path_set_insert(t_info *info, int i, int y)
{
	info->rooms[info->valid_indexes[y][i]]->length =
	info->rooms[info->valid_indexes[y][i]]->length_2;
	info->rooms[info->valid_indexes[y][i]]->cost =
	info->rooms[info->valid_indexes[y][i]]->cost_2;
	info->rooms[info->valid_indexes[y][i]]->path =
	info->rooms[info->valid_indexes[y][i]]->path_2;
	info->rooms[info->valid_indexes[y][i]]->path_2 = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1898(%rdx), %rdx
movslq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0xc(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1898(%rdx), %rdx
movslq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0xc(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1898(%rdx), %rdx
movslq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0xc(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: change_path_sets
void		change_path_sets(t_info *info)
{
	int		y;
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x105c(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3252
jmp 0x31a4
cmpl $0x201, -0x10(%rbp)     # imm = 0x201
jge 0x323d
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x3211
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x3020
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x31a4
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x318a
movq -0x8(%rbp), %rax
movl 0x1064(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1060(%rax)
movq -0x8(%rbp), %rax
movl 0x188c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1888(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x188c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1064(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1064(%rax)
jge 0x3527
movq -0x8(%rbp), %rdi
callq 0x2ed0
jmp 0x35ef
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x1, %ecx
callq 0x32a0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x2, %ecx
callq 0x32a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x357d
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x904c(%rip), %rdi      # 0xc5c2
movb $0x0, %al
callq 0x7790
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x1890(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jle 0x35a5
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x1890(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x35b3
movq -0x8(%rbp), %rax
movl $0x1, 0x1894(%rax)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x35e6
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x35db
leaq 0x8ffe(%rip), %rdi      # 0xc5d2
movb $0x0, %al
callq 0x7790
movq -0x8(%rbp), %rdi
callq 0x3170
jmp 0x35ef
movq -0x8(%rbp), %rdi
callq 0x2ed0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/divide_ants_to_paths.c
// Function: divide_paths_data
static int	divide_paths_data(t_info *info, int antnb, int i, int tab)
{
	tab = info->rooms[info->valid_indexes[i][0]]->ants;
	info->rooms[info->valid_indexes[i][0]]->ant_queue[tab] = antnb;
	info->rooms[info->valid_indexes[i][0]]->ants++;
	info->rooms[info->valid_indexes[i][0]]->cost++;
	info->ants_at_start--;
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/divide_ants_to_paths.c
// Function: cmp_loop
static int	cmp_loop(t_info *info, int cmp, int i)
{
	cmp = info->rooms[info->valid_indexes[i][0]]->cost;
	i = 0;
	while (info->rooms[info->valid_indexes[i][0]]->cost > cmp)
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x3c(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x3c(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x3998
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3960
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x39ea
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x39b4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3a4e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a23
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/lem_in.c
// Function: main
int				main(int ac, char **av)
{
	t_info		*info;

	if (!(info = (t_info*)malloc(sizeof(t_info))))
		exit_error_no_info(ERR_MALLOC);
	parse_flags(ac, av, info);
	if (ac > 0 && !(info->flag_storage & HELP))
	{
		if (info->flag_storage & VERBOSE)
			ft_printf(BOLD_MAGENTA "Verbose mode activated!\n" RESET);
		lem_in(ac, av[1], info);
	}
	else if (info->flag_storage & HELP)
		help_print();
	else
		exit_error(ERR_USAGE, info);
	if (info->flag_storage & LEAKS)
		system("leaks lem-in");
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18b0, %edi           # imm = 0x18B0
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3a96
leaq 0x8b18(%rip), %rdi      # 0xc5a9
callq 0x4f30
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1cc0
cmpl $0x0, -0x8(%rbp)
jle 0x3af4
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x3af4
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x3ade
leaq 0x8b2f(%rip), %rdi      # 0xc606
movb $0x0, %al
callq 0x7790
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b50
jmp 0x3b1f
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3b0d
callq 0x1b90
jmp 0x3b1d
movq -0x18(%rbp), %rsi
leaq 0x8b12(%rip), %rdi      # 0xc62a
callq 0x4f60
jmp 0x3b1f
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3b3d
leaq 0x8b0b(%rip), %rdi      # 0xc643
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/lem_in.c
// Function: lem_in
static void		lem_in(int ac, char *av, t_info *info)
{
	char		*line;
	t_output	*output;

	if (!(output = (t_output*)malloc(sizeof(t_output))))
		exit_error(ERR_MALLOC, info);
	if (ac > 1)
		av[0] += 0;
	info->fd = 0;
	init_info(info);
	if (!(get_next_line(info->fd, &line)))
		exit_error(ERR_NO_MAP, info);
	output->line = ft_strdup(line);
	parse_ants(info, output);
	free(line);
	parse_map(output, info);
	if (info->start_end_link)
		all_ants_to_end_at_once(info);
	else
		lem_in_dispatcher(info);
	if (info->flag_storage & LINES)
		ft_printf(BOLD_RED "\nlines required: %d\nlines: %d (%+d)\n" RESET,
		info->required, info->lines, info->lines - info->required);
	lst_free(output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0x1070
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3b87
movq -0x18(%rbp), %rsi
leaq 0x8a27(%rip), %rdi      # 0xc5a9
callq 0x4f60
cmpl $0x1, -0x4(%rbp)
jle 0x3b99
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
addl $0x0, %ecx
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1880(%rax)
movq -0x18(%rbp), %rdi
callq 0x3c90
movq -0x18(%rbp), %rax
movl 0x1880(%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x7b00
cmpl $0x0, %eax
jne 0x3bd8
movq -0x18(%rbp), %rsi
leaq 0x8a7d(%rip), %rdi      # 0xc650
callq 0x4f60
movq -0x20(%rbp), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x22d0
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5390
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1884(%rax)
je 0x3c26
movq -0x18(%rbp), %rdi
callq 0x3de0
jmp 0x3c2f
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3c77
movq -0x18(%rbp), %rax
movl 0x1890(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x1054(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x1054(%rax), %ecx
movq -0x18(%rbp), %rax
subl 0x1890(%rax), %ecx
leaq 0x89f4(%rip), %rdi      # 0xc664
movb $0x0, %al
callq 0x7790
movq -0x28(%rbp), %rdi
callq 0x39a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/lem_in.c
// Function: init_info
static void		init_info(t_info *info)
{
	int			i;

	i = 0;
	while (i < 513)
		info->tmp_string[i++] = EMPTY;
	if (!(info->flag_storage & ANTS))
		info->ants = -1;
	info->ants_at_start = 0;
	info->ants_at_end = 0;
	info->last_found_used = 1;
	info->last_found_used_2 = 1;
	info->path_n_1 = 0;
	info->path_n_2 = 0;
	info->phase = 1;
	info->level = 1;
	info->lines = 1;
	info->link_amnt = 0;
	info->max_paths = INT_MAX;
	info->path_saved = 0;
	info->rooms_to_check = (char**)malloc(sizeof(char*) * 1);
	info->rooms_to_check[0] = NULL;
	info->round = 0;
	info->required = 0;
	info->accurate = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x201, -0xc(%rbp)      # imm = 0x201
jge 0x3ccb
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x3ca3
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3ce8
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1888(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x188c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1060(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1064(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x106c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1050(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1054(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1058(%rax)
movq -0x8(%rbp), %rax
movl $0x7fffffff, 0x105c(%rax) # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x1068(%rax)
movl $0x8, %edi
callq 0x1070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1070(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1890(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1894(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/lem_in.c
// Function: all_ants_to_end_at_once
static void		all_ants_to_end_at_once(t_info *info)
{
	int			i;

	i = 1;
	write(1, "\n", 1);
	while (i <= info->ants)
	{
		write(1, "L", 1);
		ft_putnbr(i);
		write(1, "-", 1);
		ft_putstr(info->end);
		write(1, " ", 1);
		i++;
	}
	write(1, "\n", 1);
	info->ants_at_end = info->ants_at_start;
	info->ants_at_start = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x1, %edi
leaq 0x88ae(%rip), %rsi      # 0xc6ad
movl $0x1, %edx
callq 0x1040
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jg 0x3e76
movl $0x1, %edi
leaq 0x8bb5(%rip), %rsi      # 0xc9d6
movl $0x1, %edx
callq 0x1040
movl -0xc(%rbp), %edi
callq 0x6dc0
movl $0x1, %edi
leaq 0x8b85(%rip), %rsi      # 0xc9c4
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6e40
movl $0x1, %edi
leaq 0x8b08(%rip), %rsi      # 0xc969
movl $0x1, %edx
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e09
movl $0x1, %edi
leaq 0x882b(%rip), %rsi      # 0xc6ad
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/lem_in.c
// Function: lem_in_dispatcher
static void		lem_in_dispatcher(t_info *info)
{
	get_links(info);
	second_round(info);
	third_round(info);
	sort_paths(info);
	if (info->flag_storage & PATHS)
	{
		ft_printf("\nants: %d\n\nPATHS  SAVED:\n\n", info->ants);
		print_paths(info);
	}
	else
		write(1, "\n", 1);
	ant_flow(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5280
movq -0x8(%rbp), %rdi
callq 0x28d0
movq -0x8(%rbp), %rdi
callq 0x2690
movq -0x8(%rbp), %rdi
callq 0x6890
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x3f12
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x8794(%rip), %rdi      # 0xc694
movb $0x0, %al
callq 0x7790
movq -0x8(%rbp), %rdi
callq 0x5a90
jmp 0x3f28
movl $0x1, %edi
leaq 0x878f(%rip), %rsi      # 0xc6ad
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1190
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x8a0b(%rip), %rdi      # 0xc969
callq 0x7100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x89f7(%rip), %rsi      # 0xc969
callq 0x7100
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x7450
cmpq $0x0, %rax
je 0x3fb0
movq -0x8(%rbp), %rsi
leaq 0x8704(%rip), %rdi      # 0xc6af
callq 0x4f60
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x7100
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4112
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x7080
cmpl $0x0, %eax
je 0x40bc
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3f40
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x40fc
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x7080
cmpl $0x0, %eax
je 0x40fa
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x3f40
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x40fc
cmpl $0x2, -0x20(%rbp)
jne 0x4104
jmp 0x4122
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4062
movq -0x8(%rbp), %rsi
leaq 0x85ae(%rip), %rdi      # 0xc6cb
callq 0x4f60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x4167
movq -0x8(%rbp), %rsi
leaq 0x857d(%rip), %rdi      # 0xc6df
callq 0x4f60
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4182
movq -0x8(%rbp), %rsi
leaq 0x8581(%rip), %rdi      # 0xc6fe
callq 0x4f60
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4198
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x41a8
movq -0x8(%rbp), %rsi
leaq 0x857a(%rip), %rdi      # 0xc71d
callq 0x4f60
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x38(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x42a3
movq -0x10(%rbp), %rdi
leaq 0x84b5(%rip), %rsi      # 0xc73b
callq 0x7450
cmpq $0x0, %rax
je 0x42a3
movq -0x8(%rbp), %rsi
leaq 0x84a7(%rip), %rdi      # 0xc743
callq 0x4f60
jmp 0x42d5
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x42d3
movq -0x10(%rbp), %rdi
leaq 0x84a9(%rip), %rsi      # 0xc761
callq 0x7450
cmpq $0x0, %rax
je 0x42d3
movq -0x8(%rbp), %rsi
leaq 0x8499(%rip), %rdi      # 0xc767
callq 0x4f60
jmp 0x42d5
movq -0x10(%rbp), %rdi
leaq 0x845b(%rip), %rsi      # 0xc73b
callq 0x7450
movq %rax, %rdx
movl $0x2, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1074(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4358
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4406
jmp 0x435a
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x43ff
movq -0x10(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f10
cmpl $0x0, %eax
jne 0x4393
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4406
movq -0x10(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f10
cmpl $0x0, %eax
jle 0x43d1
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
jmp 0x43f8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x43fa
jmp 0x435a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x68, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4446
movq -0x8(%rbp), %rsi
leaq 0x8168(%rip), %rdi      # 0xc5a9
callq 0x4f60
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x44e0
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x44e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x44e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x456b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x6fa0
movq -0x20(%rbp), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6fd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6fa0
movq -0x20(%rbp), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x4599
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x48fd
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1060(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x48f8
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1048(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x1060(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0x10(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x50(%rax)
jmp 0x49ca
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1064(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x49c8
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1048(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl 0x38(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x1064(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x1048(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0x10(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x54(%rax)
jmp 0x49ca
popq %rbp
retq
nopl (%rax)