LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/michaelnmmeyer[P]gourgandine/cmd/gourgandine.c
// Function: process
static int process(struct mascara *mr, struct gourgandine *gn, const char *path)
{
   size_t len;
   char *str = read_file(path, &len);
   if (!str)
      return -1;

   mr_set_text(mr, str, len);

   struct mr_token *sent;
   while ((len = mr_next(mr, &sent))) {
      struct gn_acronym def = {0};
      while (gn_search(gn, sent, len, &def))
         printf("%s\t%s\n", def.acronym, def.expansion);
   }
   free(str);
   return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x3a89
movq %rdx, %r12
leaq 0x943ab(%rip), %rsi     # 0x97e19
movq %rdx, %rdi
callq 0x2220
testq %rax, %rax
je 0x3b33
movq %rax, %r15
movq %r14, 0x8(%rsp)
jmp 0x3a9f
movq %r14, 0x8(%rsp)
movq 0x10d53b(%rip), %rax    # 0x110fd0
movq (%rax), %r15
leaq 0x599d(%rip), %r12      # 0x943c
leaq 0x10d70a(%rip), %r13    # 0x1111b0
pushq $0x1
popq %rbp
movl $0x2000, %esi           # imm = 0x2000
movq %r13, %rdi
movq %rbp, %rdx
callq 0x2a3a
movq %rax, %r14
leaq -0x10(%rax), %r13
movq -0x10(%rax), %rdi
addq %rax, %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %rbp, %rsi
movq %r15, %rcx
callq 0x20a0
testq %rax, %rax
je 0x3b04
addq (%r13), %rax
movq %rax, (%r13)
cmpq $0x3200001, %rax        # imm = 0x3200001
jb 0x3aa9
leaq 0x5951(%rip), %rdi      # 0x9444
movq %r12, %rsi
movl $0x3200000, %edx        # imm = 0x3200000
xorl %eax, %eax
callq 0x32a2
jmp 0x3b21
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x3b56
leaq 0x5955(%rip), %rdi      # 0x946c
movq %r12, %rsi
xorl %eax, %eax
callq 0x32a2
movq %r13, %rdi
callq 0x3c37
movq %r15, %rdi
callq 0x20d0
jmp 0x3b44
leaq 0x58f0(%rip), %rdi      # 0x942a
movq %r12, %rsi
xorl %eax, %eax
callq 0x32a2
pushq $-0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x10(%r14), %rsi
leaq 0x20(%rsp), %rdx
pushq $0xa
popq %rcx
movq %r14, %rdi
callq 0x8b91
movq %rax, %r14
testq %rax, %rax
js 0x3c16
movq %r13, %rdi
callq 0x3c37
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x3b44
movq 0x8(%rsp), %rdi
movq %rsi, 0x10(%rsp)
movq %r14, %rdx
movq %rdi, %r14
callq 0x4465
leaq 0x18(%rsp), %r12
leaq 0x20(%rsp), %r13
leaq 0x5875(%rip), %rbp      # 0x9423
movq %r14, %rdi
movq %r12, %rsi
callq 0x4493
testq %rax, %rax
je 0x3c05
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq 0x236c
testl %eax, %eax
je 0x3bae
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbp, %rdi
xorl %eax, %eax
callq 0x2100
jmp 0x3bd8
movq 0x10(%rsp), %rdi
callq 0x2040
xorl %eax, %eax
jmp 0x3b47
movq %r14, %rdi
callq 0x7e3c
leaq 0x5859(%rip), %rdi      # 0x947e
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x32a2
jmp 0x3b21
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/mem.c
// Function: allocate_memory
void
allocate_memory(int n)
{
	const unsigned int chunksize = _STRESS_MB(1);
	int i = 0;
	void* p;

	printf("%d MB will be allocated\n", n);
	for (; i++ < n;) {
		_STRESS_MUST((p = malloc(chunksize * sizeof(char))),
		             "Couldn't allocate.");
		memset(p, 0xA, chunksize);
		printf("\rAllocated: %d", i);
	}
	printf("\nDone.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xa8c(%rip), %rdi       # 0x2108
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
testl %ebx, %ebx
movl $0x0, %r15d
cmovgl %ebx, %r15d
negl %r15d
pushq $0x1
popq %rbx
leaq 0xa83(%rip), %r14       # 0x2121
leal (%r15,%rbx), %eax
cmpl $0x1, %eax
je 0x16b7
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
incl %ebx
jmp 0x169e
leaq 0xa72(%rip), %rdi       # 0x2130
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/mem.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);
	allocate_memory(args.n);
	stress_wait_until_signalized();

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x28d3(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1090
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x129d
movl (%r14), %edi
callq 0x166e
callq 0x156e
xorl %eax, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/8-Synchronization/pthread_strtok.c
// Function: thread_func
void *thread_func(void *input)
{
	char *token;
	int i = 0, thread_num;

	thread_num = ((char *) input)[strlen(input) - 1] - '0';		
	printf("Thread %d: I start with the input %s\n", thread_num, (char *) input);

	token = strtok((char *) input, " ");		// 1st step for strtok()
	do
	{
		printf("Thread %d: Token %d = %s\n", thread_num, i++, token);
		sleep(1);
	}
	while((token = strtok(NULL, " ")) != NULL);	// later steps for strtok()

	printf("Thread %d: terminated.\n", thread_num);

	pthread_exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
callq 0x1030
movsbl -0x1(%r15,%rax), %ebx
addl $-0x30, %ebx
leaq 0xe38(%rip), %rdi       # 0x2004
movl %ebx, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1040
leaq 0xe4b(%rip), %r14       # 0x202a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1070
leaq 0xe3b(%rip), %r15       # 0x202c
pushq $0x1
popq %rbp
xorl %edx, %edx
leal 0x1(%rdx), %r12d
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x1040
movl %ebp, %edi
callq 0x10a0
xorl %edi, %edi
movq %r14, %rsi
callq 0x1070
movl %r12d, %edx
testq %rax, %rax
jne 0x11f6
leaq 0xe1d(%rip), %rdi       # 0x2046
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/dfs_search.c
// Function: dfs_start_over_or_continue
void	dfs_start_over_or_continue(t_info *info, int index)
{
	if (index != info->end_index
	&& info->tmp_string[0] >= 0)
	{
		copy_check_rooms(info);
		info->level++;
		search_from_room(info);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl %esi, 0x103c(%rdi)
je 0x143e
movq %rdi, %rbx
cmpl $0x0, 0x107c(%rdi)
js 0x143e
movq %rbx, %rdi
callq 0x31d0
incl 0x1050(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1445
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/dfs_search.c
// Function: search_from_room
void	search_from_room(t_info *info)
{
	int		c;
	int		s;
	int		l;
	int		j;

	c = -1;
	j = -1;
	while (info->check_rooms[++c] != EMPTY && info->path_saved == 0)
	{
		s = info->check_rooms[c];
		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 = -1;
	}
	dfs_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
pushq $-0x1
popq %r12
movslq 0x38(%rbx,%r12,4), %r15
cmpq $-0x1, %r15
je 0x14e2
cmpl $0x0, 0x1068(%rbx)
jne 0x14e2
incq %r12
xorl %r13d, %r13d
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r13), %rsi
testq %rsi, %rsi
je 0x14da
cmpl $0x0, 0x1068(%rbx)
jne 0x14da
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 0x14c2
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x32bd
addq $0x8, %r13
cmpl 0x103c(%rbx), %r14d
jne 0x1474
movq 0x18a8(%rbx), %rax
movq (%rax,%r15,8), %rax
incl 0x5c(%rax)
jmp 0x145a
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1408
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/dfs_search.c
// Function: get_lvl_2_rooms
void	get_lvl_2_rooms(t_info *info, int i)
{
	int		j;
	int		s;
	int		t;

	j = 0;
	t = 0;
	while (info->rooms[info->lvl_1_rooms[i]]->links[j] != NULL)
	{
		s = find_a_room(info, info->rooms[info->lvl_1_rooms[i]]->links[j]);
		if (info->rooms[info->lvl_1_rooms[i]]->path_2 < 0
		&& info->rooms[s]->visited == 0)
		{
			info->rooms[s]->visited = 1;
			info->rooms[s]->level = info->level;
			info->index_stack[t][0] = info->lvl_1_rooms[i];
			info->index_stack[t][1] = s;
			info->check_rooms[t] = s;
			t++;
		}
		j++;
	}
	info->rooms[info->lvl_1_rooms[i]]->visited = 2;
	info->level++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
movq 0x18a8(%rdi), %rcx
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x838(%rbx,%r14,4), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r15), %rsi
testq %rsi, %rsi
je 0x1599
movq %rbx, %rdi
callq 0x2aa0
movq 0x18a8(%rbx), %rcx
movslq 0x838(%rbx,%r14,4), %rdx
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, 0x54(%rdx)
jns 0x1593
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, 0x5c(%rdx)
jne 0x1593
movl $0x1, 0x5c(%rdx)
movl 0x1050(%rbx), %esi
movl %esi, 0x4c(%rdx)
movl 0x838(%rbx,%r14,4), %edx
movq 0x1048(%rbx), %rsi
movslq %r12d, %r12
movq (%rsi,%r12,8), %rsi
movl %edx, (%rsi)
movl %eax, 0x4(%rsi)
movl %eax, 0x34(%rbx,%r12,4)
incl %r12d
addq $0x8, %r15
jmp 0x1519
movl $0x2, 0x5c(%rax)
incl 0x1050(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/dfs_search.c
// Function: dfs_search
void	dfs_search(t_info *info, int i)
{
	while (info->lvl_1_rooms[++i] != EMPTY)
	{
		info->level = 2;
		get_lvl_2_rooms(info, i);
		search_from_room(info);
		reset_tmp_stacks(info);
		if (info->last_found_used_2 == 0)
			return ;
		info->path_saved = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
leal 0x1(%rax), %r14d
leaq (%rdi,%rax,4), %r15
addq $0x83c, %r15            # imm = 0x83C
cmpl $-0x1, (%r15)
je 0x1612
movl $0x2, 0x1050(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14fb
movq %rbx, %rdi
callq 0x1445
movq %rbx, %rdi
callq 0x1a84
cmpl $0x0, 0x188c(%rbx)
je 0x1612
andl $0x0, 0x1068(%rbx)
incl %r14d
addq $0x4, %r15
jmp 0x15ce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/flag_management.c
// Function: parse_flags
void			parse_flags(int ac, char **av, t_info *info)
{
	int			i;

	info->ants = -1;
	info->flag_storage = 0;
	while (ac > 1 && av[1] && av[1][0] == '-')
	{
		i = 1;
		while (av[1][i] && ft_strchr("aehlpvx", av[1][i]))
			save_flag(info, av[1][i++]);
		av++;
	}
	if (info->flag_storage & ANTS)
		info->ants = ft_atoi(av[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
orl $-0x1, 0x28(%rdx)
andl $0x0, 0x1040(%rdx)
movq %rsi, %r13
movl %edi, -0x2c(%rbp)
leaq 0x5da3(%rip), %r12      # 0x7510
pushq $0x1
popq %r14
movq %rsi, -0x38(%rbp)
cmpl $0x2, -0x2c(%rbp)
jl 0x17f8
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x17fc
cmpb $0x2d, (%rax)
jne 0x17fc
addq $0x8, %r13
pushq $0x1
popq %r15
movsbl (%rax,%r15), %esi
testl %esi, %esi
je 0x1775
movq %r12, %rdi
callq 0x41bc
testq %rax, %rax
je 0x1775
movq (%r13), %rax
movzbl (%rax,%r15), %ecx
movl %r14d, %edx
cmpl $0x61, %ecx
je 0x17ed
cmpl $0x65, %ecx
je 0x17ea
cmpl $0x68, %ecx
je 0x17e6
cmpl $0x6c, %ecx
je 0x17da
cmpl $0x70, %ecx
je 0x17e2
cmpl $0x76, %ecx
je 0x17de
cmpl $0x78, %ecx
jne 0x17f3
pushq $0x8
jmp 0x17ec
pushq $0x10
jmp 0x17ec
pushq $0x40
jmp 0x17ec
pushq $0x20
jmp 0x17ec
pushq $0x4
jmp 0x17ec
pushq $0x2
popq %rdx
orl %edx, 0x1040(%rbx)
incq %r15
jmp 0x1791
movq -0x38(%rbp), %r13
testb $0x1, 0x1040(%rbx)
je 0x1811
movq 0x8(%r13), %rdi
callq 0x3fac
movl %eax, 0x28(%rbx)
addq $0x18, %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/handle_paths.c
// Function: create_fork
void	create_fork(t_info *info, int room_i, int y, int t)
{
	int		s;
	int		note;
	int		fork;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movslq %esi, %r15
movslq %ecx, %r12
movq 0x18a8(%rdi), %rax
movq (%rax,%r15,8), %rcx
shlq $0x3, %r12
xorl %edx, %edx
pushq $0x1
popq %r13
testl %edx, %edx
jne 0x18b0
movq 0x8(%rcx), %rax
movq (%rax,%r12), %rsi
testq %rsi, %rsi
je 0x18b0
movq %r14, %rdi
callq 0x2aa0
movq 0x18a8(%r14), %rdx
movq (%rdx,%r15,8), %rcx
movslq %eax, %rsi
movq (%rdx,%rsi,8), %rdx
movl 0x4c(%rdx), %edx
cmpl %edx, 0x4c(%rcx)
jle 0x1886
cmpl $-0x1, %edx
jne 0x1892
movl %r13d, %edx
cmpl 0x103c(%r14), %eax
jne 0x18aa
xorl %edx, %edx
cmpl $0x2, 0x106c(%r14)
jne 0x18aa
xorl %edx, %edx
cmpl 0x103c(%r14), %eax
setne %dl
addq $0x8, %r12
jmp 0x184e
testl %edx, %edx
je 0x18e5
movq 0x1048(%r14), %rcx
movslq %ebx, %rdx
leaq (%rcx,%rdx,8), %rsi
movq (%rsi), %rax
addq $0x8, %rsi
cmpl $-0x1, (%rax)
jne 0x18c2
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
movl (%rcx,%rdx), %esi
cmpl $-0x1, %esi
je 0x18e5
movl %esi, (%rax,%rdx)
addq $0x4, %rdx
jmp 0x18d4
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/handle_paths.c
// Function: add_to_path
void	add_to_path(t_info *info, int last, int next, int y)
{
	int		last_room;
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movl %esi, %r12d
movq %rdi, %rbx
movq 0x18a8(%rdi), %rax
movslq %esi, %rdx
movq (%rax,%rdx,8), %r13
cmpl $0x1, 0x38(%r13)
jne 0x1952
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
cmpl $0x1, 0x38(%rax)
je 0x19df
movq 0x1048(%rbx), %r14
movslq %ecx, %r15
incq %r15
movq (%r14,%r15,8), %rdi
cmpl $-0x1, (%rdi)
je 0x19df
callq 0x18f4
movl 0x106c(%rbx), %ecx
cmpl $0x1, %ecx
je 0x1986
cmpl $0x2, %ecx
jne 0x195c
cmpl $0x0, 0x54(%r13)
js 0x198d
jmp 0x195c
cmpl $0x0, 0x50(%r13)
jns 0x195c
cmpl %r12d, %eax
jne 0x195c
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x1820
movq 0x1048(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $-0x1, (%rax)
leaq 0x4(%rax), %rax
jne 0x19ad
movl -0x2c(%rbp), %ecx
movl %ecx, -0x4(%rax)
cmpl %ecx, 0x103c(%rbx)
jne 0x19df
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/parse_ants.c
// Function: parse_ants
void		parse_ants(t_info *info, t_output *output)
{
	if (ft_isint(output->line))
	{
		if (!(info->flag_storage & ANTS))
		{
			info->ants = ft_atoi(output->line);
			if (info->ants < 1)
				exit_error(ERR_ANTS, info);
		}
		info->ants_at_start = info->ants;
	}
	else
		exit_error(ERR_ANTS, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x19f0
testl %eax, %eax
je 0x1a6e
testb $0x1, 0x1040(%rbx)
jne 0x1a63
movq (%r14), %rdi
callq 0x3fac
movl %eax, 0x28(%rbx)
testl %eax, %eax
jg 0x1a63
leaq 0x5abd(%rip), %rdi      # 0x7518
movq %rbx, %rsi
callq 0x31ab
movl 0x28(%rbx), %eax
movl %eax, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5aa3(%rip), %rdi      # 0x7518
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x31ab
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: reset_tmp_stacks
void	reset_tmp_stacks(t_info *info)
{
	int		i;
	int		y;

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

// Assembly:
xorl %eax, %eax
cmpq $0x201, %rax            # imm = 0x201
je 0x1aa0
orl $-0x1, 0x107c(%rdi,%rax,4)
orl $-0x1, 0x34(%rdi,%rax,4)
incq %rax
jmp 0x1a86
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movslq 0x1058(%rdi), %rcx
cmpq %rcx, %rax
jge 0x1ad6
movq 0x1048(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
cmpq $0x201, %rdx            # imm = 0x201
je 0x1ad1
orl $-0x1, (%rcx,%rdx,4)
incq %rdx
jmp 0x1abf
incq %rax
jmp 0x1aa6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: room_on_valid_path
int		room_on_valid_path(t_info *info, int i)
{
	int		y;
	int		t;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x106c(%rdi), %r8d
movabsq $-0x1, %rdx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x1, %r8d
jne 0x1b23
movq 0x1898(%rdi), %r9
movq 0x8(%r9,%rdx,8), %r9
cmpl $-0x1, (%r9)
je 0x1b21
incq %rdx
movl (%r9), %eax
cmpl $-0x1, %eax
je 0x1af2
addq $0x4, %r9
cmpl %esi, %eax
jne 0x1b0f
movl %ecx, %eax
popq %rbp
retq
cmpl $0x2, %r8d
jne 0x1b21
movq 0x18a0(%rdi), %rdi
movslq %edx, %rdx
movq 0x8(%rdi,%rdx,8), %r8
cmpl $-0x1, (%r8)
je 0x1b21
incq %rdx
movl (%r8), %r9d
cmpl $-0x1, %r9d
je 0x1b33
addq $0x4, %r8
cmpl %esi, %r9d
jne 0x1b41
jmp 0x1b1f
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: reset_rooms
void	reset_rooms(t_info *info)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x1050(%rdi)
movq 0x18a8(%rdi), %r15
xorl %r14d, %r14d
pushq $0x2
popq %r12
movq (%r15,%r14,8), %r13
testq %r13, %r13
je 0x1baf
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1ad8
testl %eax, %eax
je 0x1ba4
movl 0x103c(%rbx), %ecx
movl %r12d, %eax
cmpq %rcx, %r14
jne 0x1ba6
xorl %eax, %eax
movl %eax, 0x5c(%r13)
incq %r14
jmp 0x1b7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: third_round
void		third_round(t_info *info)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r15
pushq $0xd
popq %r12
pushq $-0x1
popq %r14
movl %r15d, %eax
movl %eax, 0x1070(%rbx)
cmpl $0x0, 0x1894(%rbx)
jne 0x1ce5
cmpl $0x4, %eax
jg 0x1ce5
movl $0x2, 0x106c(%rbx)
movl %r15d, 0x1050(%rbx)
andq $0x0, 0x1064(%rbx)
movl %r15d, 0x188c(%rbx)
movq %rbx, %rdi
callq 0x1a84
movq 0x18a8(%rbx), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1c88
xorl %edx, %edx
cmpl $0x2, 0x1070(%rbx)
jl 0x1c77
movl 0x54(%rcx), %edx
notl %edx
shrl $0x1f, %edx
movl %edx, 0x5c(%rcx)
andl $0x0, 0x38(%rcx)
orl $-0x1, 0x54(%rcx)
addq $0x8, %rax
jmp 0x1c5c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3cc6
movq %r12, %rax
cmpq $0x20e, %rax            # imm = 0x20E
je 0x1cb4
movl (%rbx,%rax,4), %ecx
movl %ecx, 0x804(%rbx,%rax,4)
orl $-0x1, (%rbx,%rax,4)
incq %rax
jmp 0x1c99
movq %rbx, %rdi
movl %r14d, %esi
callq 0x15af
testb $0x40, 0x1040(%rbx)
je 0x1cd0
movq %rbx, %rdi
callq 0x38a0
movq %rbx, %rdi
callq 0x2314
movl 0x1070(%rbx), %eax
incl %eax
jmp 0x1c11
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: second_round
void		second_round(t_info *info)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x106c(%rdi)
movl $0x1, 0x1050(%rdi)
andl $0x0, 0x1064(%rdi)
cmpl $0x0, 0x1060(%rdi)
jg 0x1d2a
leaq 0x5825(%rip), %rdi      # 0x7547
movq %rbx, %rsi
callq 0x31ab
movq %rbx, %rdi
callq 0x1a84
movq 0x18a8(%rbx), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1d4b
andl $0x0, 0x5c(%rcx)
addq $0x8, %rax
jmp 0x1d39
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
callq 0x3bd7
movq 0x18a0(%rbx), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
je 0x1d88
testb $0x40, 0x1040(%rbx)
je 0x1d88
movq %rbx, %rdi
callq 0x38a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2314
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: split_link_string
void	split_link_string(t_info *info, int index)
{
	info->rooms[index]->links =
	ft_strsplit(info->rooms[index]->link_string, ' ');
	free(info->rooms[index]->link_string);
	if (info->rooms[index]->start_or_end != 0)
	{
		if (info->rooms[index]->start_or_end == 1)
			info->start_index = index;
		else
			info->end_index = index;
	}
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leal 0x1(%rsi), %r15d
movq %rsi, -0x38(%rbp)
movslq %esi, %r12
movq %r12, %r13
movl %r15d, -0x2c(%rbp)
movq 0x18a8(%r14), %rax
movq (%rax,%r13,8), %rcx
testq %rcx, %rcx
je 0x1eb8
movq 0x10(%rcx), %rdi
movslq %r15d, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x41e0
movl %r13d, %ebx
testl %eax, %eax
js 0x1e61
movl %r15d, %ebx
movq 0x18a8(%r14), %rcx
movq 0x8(%rcx,%r13,8), %rax
testq %rax, %rax
je 0x1ead
movq (%rcx,%r12,8), %rcx
movl 0x60(%rcx), %edx
cmpl 0x60(%rax), %edx
jne 0x1e8d
movl 0x64(%rcx), %edx
leaq 0x56d5(%rip), %rdi      # 0x755d
cmpl 0x64(%rax), %edx
je 0x1ea5
movq 0x10(%rcx), %rdi
movq 0x10(%rax), %rsi
callq 0x41e0
leaq 0x56e5(%rip), %rdi      # 0x7586
testl %eax, %eax
jne 0x1ead
movq %r14, %rsi
callq 0x31ab
incq %r13
movl %ebx, %r15d
jmp 0x1e33
movq %r14, %rdi
movl %r15d, %esi
movq -0x38(%rbp), %rbx
movl %ebx, %edx
callq 0x2b5f
movq 0x18a8(%r14), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1ef3
movq %r14, %rdi
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d98
addq $0x18, %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/sort_rooms.c
// Function: malloc_for_valid_indexes
void	malloc_for_valid_indexes(t_info *info, int i, int x)
{
	if (!(info->valid_indexes =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_indexes_2 =
	(int**)malloc(sizeof(int*) * info->max_paths + 1))
	|| !(info->valid_paths =
	(char**)malloc(sizeof(char*) * info->max_paths + 1))
	|| !(info->valid_paths_2 =
	(char**)malloc(sizeof(char*) * info->max_paths + 1)))
		exit_error(ERR_MALLOC, info);
	while (i < info->max_paths + 1)
	{
		if (!(info->valid_indexes[i] = (int*)malloc(sizeof(int) * 513))
		|| !(info->valid_indexes_2[i] = (int*)malloc(sizeof(int) * 513)))
			exit_error(ERR_MALLOC, info);
		while (x < 513)
		{
			info->valid_indexes[i][x] = EMPTY;
			info->valid_indexes_2[i][x] = EMPTY;
			x++;
		}
		x = 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movslq 0x105c(%rdi), %rax
leaq 0x1(,%rax,8), %r12
movq %r12, %rdi
callq 0x1070
movq %rax, 0x1898(%rbx)
testq %rax, %rax
je 0x1f6f
movq %r12, %rdi
callq 0x1070
movq %rax, 0x18a0(%rbx)
testq %rax, %rax
je 0x1f6f
movq %r12, %rdi
callq 0x1070
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1f6f
movq %r12, %rdi
callq 0x1070
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x1f7e
leaq 0x5633(%rip), %rdi      # 0x75a9
movq %rbx, %rsi
callq 0x31ab
movslq %r15d, %r15
movslq %r14d, %r12
leaq 0x561e(%rip), %r14      # 0x75a9
movslq 0x105c(%rbx), %rax
cmpq %rax, %r15
jg 0x200f
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq 0x1898(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
je 0x1fcb
movl $0x804, %edi            # imm = 0x804
callq 0x1070
movq 0x18a0(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
jne 0x1ffb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31ab
jmp 0x1ffb
movq 0x1898(%rbx), %rax
movq (%rax,%r15,8), %rax
orl $-0x1, (%rax,%r12,4)
movq 0x18a0(%rbx), %rax
movq (%rax,%r15,8), %rax
orl $-0x1, (%rax,%r12,4)
incq %r12
cmpq $0x200, %r12            # imm = 0x200
jle 0x1fd8
incq %r15
xorl %r12d, %r12d
jmp 0x1f8b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/sort_rooms.c
// Function: sort_rooms
void	sort_rooms(t_info *info)
{
	int		i;
	int		x;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x18a8(%rbx), %rax
cmpq $0x0, 0x8(%rax,%r14,8)
je 0x2044
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1e0d
incq %r14
jmp 0x2025
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1d98
movq 0x18a8(%rbx), %rcx
movslq 0x1078(%rbx), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rdx
pushq $-0x1
popq %rax
incl %eax
cmpq $0x0, (%rdx)
leaq 0x8(%rdx), %rdx
jne 0x2068
movslq 0x103c(%rbx), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rdx
pushq $-0x1
popq %rcx
incl %ecx
cmpq $0x0, (%rdx)
leaq 0x8(%rdx), %rdx
jne 0x2086
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, 0x105c(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1f02
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
movslq 0x105c(%rdi), %rcx
cmpq %rcx, %rax
jg 0x2116
movq 0x18a0(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
cmpq $0x201, %rdx            # imm = 0x201
je 0x2111
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
jle 0x2108
movq 0x18a8(%rdi), %r8
movq (%r8,%rsi,8), %rsi
andl $0x0, 0x48(%rsi)
movslq (%rcx,%rdx,4), %rsi
movq (%r8,%rsi,8), %rsi
andl $0x0, 0x40(%rsi)
movslq (%rcx,%rdx,4), %rsi
movq (%r8,%rsi,8), %rsi
orl $-0x1, 0x54(%rsi)
orl $-0x1, (%rcx,%rdx,4)
incq %rdx
jmp 0x20cf
incq %rax
jmp 0x20b6
andl $0x0, 0x1064(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1898(%rdi), %rax
movq 0x18a8(%rdi), %rcx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq %esi, %rdx
movslq (%rax,%rdx,4), %rsi
movq (%rcx,%rsi,8), %rsi
movl 0x48(%rsi), %edi
movl %edi, 0x44(%rsi)
movslq (%rax,%rdx,4), %rsi
movq (%rcx,%rsi,8), %rsi
movl 0x40(%rsi), %edi
movl %edi, 0x3c(%rsi)
movslq (%rax,%rdx,4), %rsi
movq (%rcx,%rsi,8), %rsi
movl 0x54(%rsi), %edi
movl %edi, 0x50(%rsi)
movslq (%rax,%rdx,4), %rax
movq (%rcx,%rax,8), %rax
orl $-0x1, 0x54(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x105c(%rbx), %rax
cmpq %rax, %r14
jg 0x21e6
xorl %r15d, %r15d
cmpq $0x201, %r15            # imm = 0x201
je 0x21e1
movq 0x1898(%rbx), %rcx
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r15,4), %edx
movq (%rcx,%r14,8), %rcx
movl %edx, (%rcx,%r15,4)
cmpl $-0x1, %edx
je 0x21d7
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x211f
movq 0x18a0(%rbx), %rax
movq (%rax,%r14,8), %rax
orl $-0x1, (%rax,%r15,4)
incq %r15
jmp 0x2192
incq %r14
jmp 0x2183
movl 0x1064(%rbx), %eax
movl %eax, 0x1060(%rbx)
movl 0x188c(%rbx), %eax
movl %eax, 0x1888(%rbx)
movl $0x1, 0x188c(%rbx)
andl $0x0, 0x1064(%rbx)
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/calculate_moves.c
// Function: calculate_more
int			calculate_more(t_info *info, int i, int rooms, int set)
{
	int		moves;
	int		d;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movabsq $0x100000000, %rdx      # imm = 0x100000000
movslq %esi, %rsi
cmpl $0x1, %ecx
jne 0x229b
movl 0x1060(%rdi), %ecx
movslq %ecx, %r9
movq %rsi, %r8
shlq $0x20, %r8
incq %rsi
cmpq %r9, %rsi
jge 0x226c
movq 0x1898(%rdi), %r10
movq 0x18a8(%rdi), %r11
movq (%r10,%rsi,8), %r10
movslq (%r10), %r10
movq (%r11,%r10,8), %r10
addl 0x44(%r10), %eax
addq %rdx, %r8
jmp 0x2242
cmpl $0x1, 0x1888(%rdi)
je 0x2300
movq 0x1898(%rdi), %rdx
movq 0x18a8(%rdi), %rsi
sarq $0x1d, %r8
movq (%rdx,%r8), %rdx
movslq (%rdx), %rdx
movq (%rsi,%rdx,8), %rdx
subl 0x44(%rdx), %eax
jmp 0x22fe
movl 0x1064(%rdi), %ecx
movslq %ecx, %r9
movq %rsi, %r8
shlq $0x20, %r8
incq %rsi
cmpq %r9, %rsi
jge 0x22d5
movq 0x18a0(%rdi), %r10
movq 0x18a8(%rdi), %r11
movq (%r10,%rsi,8), %r10
movslq (%r10), %r10
movq (%r11,%r10,8), %r10
addl 0x48(%r10), %eax
addq %rdx, %r8
jmp 0x22ab
cmpl $0x1, 0x188c(%rdi)
je 0x2300
movq 0x18a0(%rdi), %rdx
movq 0x18a8(%rdi), %rsi
sarq $0x1d, %r8
movq (%rdx,%r8), %rdx
movslq (%rdx), %rdx
movq (%rsi,%rdx,8), %rdx
subl 0x48(%rdx), %eax
decl %ecx
cmpl $0x1, %ecx
adcl $0x0, %ecx
addl 0x28(%rdi), %eax
cltd
idivl %ecx
cmpl $0x1, %edx
sbbl $-0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/calculate_moves.c
// Function: calculate_moves
void		calculate_moves(t_info *info)
{
	int		moves;
	int		cmp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1064(%rdi)
jle 0x23c6
pushq $-0x1
popq %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x221a
movl %eax, %r14d
pushq $0x2
popq %rcx
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x221a
movl %eax, %r15d
testb $0x40, 0x1040(%rbx)
je 0x2375
leaq 0x525a(%rip), %rdi      # 0x75c2
movl %r14d, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4574
movl 0x1890(%rbx), %eax
addl $0x2, %eax
cmpl %eax, %r14d
setg %cl
cmpl %eax, %r15d
setg %al
testb %al, %cl
jne 0x2398
movl $0x1, 0x1894(%rbx)
cmpl %r14d, %r15d
jge 0x23c6
testb $0x40, 0x1040(%rbx)
je 0x23b4
leaq 0x5225(%rip), %rdi      # 0x75d2
xorl %eax, %eax
callq 0x4574
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2173
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/divide_ants_to_paths.c
// Function: divide_to_paths
void		divide_to_paths(t_info *info, int i, int tab, int cmp)
{
	int		antnb;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %r14
pushq $-0x1
popq %r12
cmpl $0x0, 0x30(%rbx)
jle 0x24ae
cmpl $0x1, 0x1060(%rbx)
je 0x2454
movq 0x1898(%rbx), %rax
movq 0x18a8(%rbx), %rcx
movslq %r15d, %rdx
movq (%rax,%rdx,8), %rsi
movq 0x8(%rax,%rdx,8), %rdi
movslq (%rsi), %rdx
movq (%rcx,%rdx,8), %rdx
movl 0x3c(%rdx), %edx
movslq (%rdi), %rsi
movq (%rcx,%rsi,8), %rsi
cmpl 0x3c(%rsi), %edx
jle 0x2439
incl %r15d
jmp 0x2454
jne 0x2454
movl %r12d, %r15d
movq (%rax), %rsi
movslq (%rsi), %rsi
movq (%rcx,%rsi,8), %rsi
incl %r15d
addq $0x8, %rax
cmpl %edx, 0x3c(%rsi)
jg 0x243e
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x24b7
incl %r14d
movl 0x1060(%rbx), %eax
decl %eax
cmpl %eax, %r15d
je 0x24a6
movq 0x1898(%rbx), %rax
movq 0x18a8(%rbx), %rcx
movslq %r15d, %rdx
movq (%rax,%rdx,8), %rsi
movq 0x8(%rax,%rdx,8), %rax
movslq (%rsi), %rdx
movq (%rcx,%rdx,8), %rdx
movl 0x3c(%rdx), %edx
movslq (%rax), %rax
movq (%rcx,%rax,8), %rax
cmpl 0x3c(%rax), %edx
jge 0x23f1
xorl %r15d, %r15d
jmp 0x23f1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1898(%rdi), %rax
movq 0x18a8(%rdi), %rcx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rdx
movslq (%rdx), %rax
movq (%rcx,%rax,8), %r8
movslq 0x30(%r8), %rax
movq 0x20(%r8), %r8
movl %esi, (%r8,%rax,4)
movslq (%rdx), %rsi
movq (%rcx,%rsi,8), %rsi
incl 0x30(%rsi)
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
incl 0x3c(%rcx)
decl 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/free_memory.c
// Function: free_2d_array
void			free_2d_array(char **arr)
{
	int			i;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x18a8(%rbx), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x296b
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x4270
movq %r14, %rdx
testl %eax, %eax
jne 0x2952
movq 0x18a8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x4270
movq %r15, %rdx
testl %eax, %eax
je 0x2966
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2828
incl %r13d
cmpl $0x2, %r13d
je 0x2988
incq %r12
jmp 0x2911
leaq 0x4d83(%rip), %rdi      # 0x76f5
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31ab
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/parsing_helpers.c
// Function: room_error_check
void	room_error_check(t_info *info, char **room_data)
{
	if (ft_strchr(room_data[0], '-'))
		exit_error(ERR_ROOM_NAME_DASH, info);
	if (room_data[3] != NULL)
		exit_error(ERR_ROOM_ARGS_MANY, info);
	if (room_data[1] == NULL || room_data[2] == NULL)
		exit_error(ERR_ROOM_ARGS_FEW, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
pushq $0x2d
popq %rsi
callq 0x41bc
testq %rax, %rax
je 0x29c3
leaq 0x4d4e(%rip), %rdi      # 0x7709
movq %rbx, %rsi
callq 0x31ab
cmpq $0x0, 0x18(%r14)
je 0x29d9
leaq 0x4d57(%rip), %rdi      # 0x7728
movq %rbx, %rsi
callq 0x31ab
cmpq $0x0, 0x8(%r14)
je 0x29ec
cmpq $0x0, 0x10(%r14)
je 0x29ec
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4d54(%rip), %rdi      # 0x7747
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x31ab
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: init_room_info
void	init_room_info(t_info *info, int i)
{
	info->rooms[i]->visited = 0;
	info->rooms[i]->ants = 0;
	info->rooms[i]->ants_2 = 0;
	info->rooms[i]->path = -1;
	info->rooms[i]->path_2 = -1;
	info->rooms[i]->flow = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18a8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
andl $0x0, 0x5c(%rax)
andq $0x0, 0x30(%rax)
orq $-0x1, 0x50(%rax)
andl $0x0, 0x38(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/source/parsing_helpers.c
// Function: validate_command
int		validate_command(t_info *info, char *line)
{
	int		start_end;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x2a56
leaq 0x4d25(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x4428
testq %rax, %rax
je 0x2a56
leaq 0x4d19(%rip), %rdi      # 0x776d
jmp 0x2a77
cmpq $0x0, (%r14)
je 0x2a7f
leaq 0x4d28(%rip), %rsi      # 0x778b
movq %rbx, %rdi
callq 0x4428
testq %rax, %rax
je 0x2a7f
leaq 0x4d1a(%rip), %rdi      # 0x7791
movq %r14, %rsi
callq 0x31ab
leaq 0x4cdf(%rip), %rsi      # 0x7765
movq %rbx, %rdi
callq 0x4428
xorl %ecx, %ecx
cmpq $0x1, %rax
adcl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 $-0x1
popq %rax
testq %rsi, %rsi
je 0x2b5e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl 0x1074(%rdi), %r12d
decl %r12d
pushq $0x2
popq %rcx
movl %r12d, %eax
cltd
idivl %ecx
movl %eax, %r13d
movl $0x0, -0x2c(%rbp)
cmpl %r12d, -0x2c(%rbp)
jg 0x2b48
movq 0x18a8(%r15), %rax
movslq %r13d, %rbx
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x41e0
testl %eax, %eax
je 0x2b4d
movq 0x18a8(%r15), %rax
movq (%rax,%rbx,8), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x41e0
testl %eax, %eax
jle 0x2b2e
leal -0x1(%r13), %r12d
movl %r13d, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r13d
jmp 0x2add
leal 0x1(%r13), %ecx
movl %r12d, %eax
movl %ecx, -0x2c(%rbp)
subl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
addl %eax, %r13d
incl %r13d
jmp 0x2add
pushq $-0x1
popq %rax
jmp 0x2b50
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq