LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: parse_command
noreturn void parse_command(struct command *commands, const char *help,
                            int argc, char **argv)
{
   set_progname(*argv);
   set_help(help);

   if (argc == 1)
      display_help();

   const char *arg = argv[1];
   for (struct command *cmd = commands; cmd->name; cmd++) {
      if (!strcmp(cmd->name, arg)) {
         cmd->func(argc - 2, argv + 2);
         exit(EXIT_SUCCESS);
      }
   }
   if (*arg == '-') {
      arg++;
      if (*arg == '-') {
         arg++;
         if (!strcmp(arg, help_option.name))
            display_help();
      } else if (*arg == help_option.letter && !arg[1]) {
         display_help();
      }
   }
   die("unknown command: '%s'", argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4040
movq -0x10(%rbp), %rdi
callq 0x40a0
cmpl $0x1, -0x14(%rbp)
jne 0x3f57
callq 0x40d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3fb9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x3fa9
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %edi
subl $0x2, %edi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq *%rax
xorl %edi, %edi
callq 0x2240
jmp 0x3fab
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x3f6b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4027
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4005
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x117164(%rip), %rsi    # 0x11b158
callq 0x2190
cmpl $0x0, %eax
jne 0x4003
callq 0x40d0
jmp 0x4025
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x11713e(%rip), %eax    # 0x11b150
jne 0x4023
movq -0x28(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x4023
callq 0x40d0
jmp 0x4025
jmp 0x4027
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xf19b(%rip), %rdi      # 0x131d1
movb $0x0, %al
callq 0x3d00
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: set_progname
static void set_progname(const char *name)
{
   const char *slash = strrchr(name, '/');

   if (slash && slash[1])
      g_progname = slash + 1;
   else
      g_progname = name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4083
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x4083
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x1170c7(%rip)    # 0x11b148
jmp 0x408e
movq -0x8(%rbp), %rax
movq %rax, 0x1170ba(%rip)    # 0x11b148
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: short_option
static struct option *short_option(struct option *options, int letter)
{
   assert(letter);

   while (options->name) {
      if (options->letter == letter)
         return options;
      options++;
   }
   if (letter == help_option.letter)
      return &help_option;

   die("unknown option: -%c", letter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4477
jmp 0x4496
leaq 0xeebd(%rip), %rdi      # 0x1333b
leaq 0xed6b(%rip), %rsi      # 0x131f0
movl $0x48, %edx
leaq 0xeeb1(%rip), %rcx      # 0x13342
callq 0x2130
jmp 0x4498
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x44c6
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x44b8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44ef
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x4498
movl -0x14(%rbp), %eax
cmpl 0x116c81(%rip), %eax    # 0x11b150
jne 0x44de
leaq 0x116c78(%rip), %rax    # 0x11b150
movq %rax, -0x8(%rbp)
jmp 0x44ef
movl -0x14(%rbp), %esi
leaq 0xee8c(%rip), %rdi      # 0x13374
movb $0x0, %al
callq 0x3d00
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: handle_option
static void handle_option(struct option *opt, const char *arg)
{
   bool legit = true;

   switch (opt->type) {
   case OPT_STR:
      *opt->s = arg;
      break;
   case OPT_BOOL:
      *opt->b = true;
      break;
   case OPT_FUNC:
      opt->f();
      break;
   case OPT_DOUBLE: {
      char *end;
      errno = 0;
      *opt->d = strtod(arg, &end);
      if (errno || *end)
         legit = false;
      break;
   }
   case OPT_SIZE_T:
      if (!strcmp(arg, "inf")) {
         *opt->z = SIZE_MAX;
      } else {
         char *end;
         errno = 0;
         long long num = strtoll(arg, &end, 10);
         if (errno || *end || num < 0 || (uintmax_t)num > SIZE_MAX)
            legit = false;
         else
            *opt->z = num;
      }
      break;
   default:       // NUM_OPTS handled in switch.
      break;
   }

   if (!legit)
      die("invalid argument '%s' for option --%s", arg, opt->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x4634
movq -0x38(%rbp), %rax
leaq 0xec7c(%rip), %rcx      # 0x131b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
jmp 0x4636
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, (%rax)
jmp 0x4636
movq -0x8(%rbp), %rax
callq *0x18(%rax)
jmp 0x4636
callq 0x2060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movsd %xmm0, (%rax)
callq 0x2060
cmpl $0x0, (%rax)
jne 0x45a7
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x45ab
movb $0x0, -0x11(%rbp)
jmp 0x4636
movq -0x10(%rbp), %rdi
leaq 0xedcd(%rip), %rsi      # 0x13388
callq 0x2190
cmpl $0x0, %eax
jne 0x45d6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq $-0x1, (%rax)
jmp 0x4632
callq 0x2060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x21b0
movq %rax, -0x30(%rbp)
callq 0x2060
cmpl $0x0, (%rax)
jne 0x461b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x461b
cmpq $0x0, -0x30(%rbp)
jl 0x461b
cmpq $-0x1, -0x30(%rbp)
jbe 0x4621
movb $0x0, -0x11(%rbp)
jmp 0x4630
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
jmp 0x4632
jmp 0x4636
jmp 0x4636
testb $0x1, -0x11(%rbp)
jne 0x4656
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xed3d(%rip), %rdi      # 0x1338c
movb $0x0, %al
callq 0x3d00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: long_option
static struct option *long_option(struct option *options, const char *name)
{
   while (options->name) {
      if (!strcmp(options->name, name))
         return options;
      options++;
   }
   if (!strcmp(name, help_option.name))
      return &help_option;

   die("unknown option: --%s", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x46a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x469b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46dd
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x4670
movq -0x18(%rbp), %rdi
movq 0x116aa4(%rip), %rsi    # 0x11b158
callq 0x2190
cmpl $0x0, %eax
jne 0x46cb
leaq 0x116a8b(%rip), %rax    # 0x11b150
movq %rax, -0x8(%rbp)
jmp 0x46dd
movq -0x18(%rbp), %rsi
leaq 0xecdc(%rip), %rdi      # 0x133b2
movb $0x0, %al
callq 0x3d00
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/cmd/cmd.c
// Function: check_help
static void check_help(const char *help)
{
   assert(help);
   bool legit = false;

   for (;;) {
      help = strchr(help, '%');
      if (!help)
         break;
      switch (*++help) {
      case 's':
         if (legit) {
            legit = false;
            goto fini;
         }
         legit = true;
         break;
      case '%':
         help++;
         break;
      default:
         legit = false;
         goto fini;
      }
   }

fini:
   if (!legit)
      die("invalid help screen");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4705
jmp 0x4724
leaq 0xebf8(%rip), %rdi      # 0x13304
leaq 0xeadd(%rip), %rsi      # 0x131f0
movl $0x96, %edx
leaq 0xebea(%rip), %rcx      # 0x13309
callq 0x2130
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x25, %esi
callq 0x20f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4743
jmp 0x4791
movq -0x8(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x8(%rbp)
movsbl 0x1(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x25, %eax
je 0x477b
jmp 0x475f
movl -0x10(%rbp), %eax
subl $0x73, %eax
jne 0x4789
jmp 0x4769
testb $0x1, -0x9(%rbp)
je 0x4775
movb $0x0, -0x9(%rbp)
jmp 0x4793
movb $0x1, -0x9(%rbp)
jmp 0x478f
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x478f
movb $0x0, -0x9(%rbp)
jmp 0x4793
jmp 0x4728
jmp 0x4793
testb $0x1, -0x9(%rbp)
jne 0x47a7
leaq 0xeb87(%rip), %rdi      # 0x13327
movb $0x0, %al
callq 0x3d00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a98
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b14
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5300
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x53a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b04
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2150
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x2370
cmpl $0x0, %eax
je 0x4b02
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq 0xe95b(%rip), %rdi      # 0x13454
movb $0x0, %al
callq 0x2100
jmp 0x4ad0
jmp 0x4aa9
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x100000, 0x10(%rsp)   # imm = 0x100000
movl $0x0, 0xc(%rsp)
movl 0x14(%rsp), %esi
leaq 0x86d(%rip), %rdi       # 0x2120
movb $0x0, %al
callq 0x10a0
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rsp)
cmpl 0x14(%rsp), %eax
jge 0x19ed
jmp 0x18d3
movl $0x100000, %edi         # imm = 0x100000
callq 0x10e0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x19c1
movq 0x2706(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x73c(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x10d0
movq 0x26ee(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x72a(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x10d0
movq 0x26d6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x80d(%rip), %rsi       # 0x2139
movb $0x0, %al
callq 0x10d0
movq 0x26be(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x721(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x10d0
movq 0x26a6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x70c(%rip), %rsi       # 0x2068
leaq 0x7e9(%rip), %rdx       # 0x214c
movb $0x0, %al
callq 0x10d0
movq 0x2687(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x709(%rip), %rsi       # 0x2084
movl $0x16, %edx
movb $0x0, %al
callq 0x10d0
movq 0x266a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6ce(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x10d0
movq 0x2652(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6e1(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1110
jmp 0x19c3
movq (%rsp), %rdi
movl $0xa, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x10b0
movl 0xc(%rsp), %esi
leaq 0x775(%rip), %rdi       # 0x2156
movb $0x0, %al
callq 0x10a0
jmp 0x18ba
leaq 0x771(%rip), %rdi       # 0x2165
movb $0x0, %al
callq 0x10a0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0xe0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
leaq 0xe21(%rip), %rsi       # 0x202a
callq 0x1070
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
leaq 0xe01(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10a0
xorl %eax, %eax
movl %eax, %edi
leaq 0xde3(%rip), %rsi       # 0x202a
callq 0x1070
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1212
movl -0x18(%rbp), %esi
leaq 0xde6(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
movl %eax, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/ant_flow.c
// Function: ant_flow
void			ant_flow(t_info *info)
{
	int		i;
	int		y;

	i = -1;
	y = -1;
	while (info->valid_indexes[++y][0] != EMPTY)
	{
		while (info->valid_indexes[y][++i] != EMPTY)
			info->rooms[info->valid_indexes[y][i]]->visited = 0;
		i = -1;
	}
	info->ants_at_start = info->ants;
	divide_to_paths(info, 0, 0, 0);
	info->ants_at_start = info->ants;
	print_turns(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
je 0x1230
jmp 0x11cc
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x1224
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 $0x0, 0x5c(%rax)
jmp 0x11cc
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x11aa
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x3600
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x1270
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/ant_flow.c
// Function: print_turns
static void		print_turns(t_info *info)
{
	int		i;

	i = 0;
	while (info->ants_at_end < info->ants)
	{
		move_path(info, i);
		i++;
		if (info->ants_at_end == info->ants)
		{
			if (i != 0)
				ft_putchar('\n');
			return ;
		}
		if (i == info->path_n_1)
		{
			i = 0;
			info->lines++;
			ft_putchar('\n');
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x12ff
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1310
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x12ca
cmpl $0x0, -0xc(%rbp)
je 0x12c8
movl $0xa, %edi
callq 0x6cf0
jmp 0x12ff
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1060(%rcx), %eax
jne 0x12fd
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1054(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1054(%rax)
movl $0xa, %edi
callq 0x6cf0
jmp 0x1283
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x1800
movq -0x8(%rbp), %rax
cmpl $0x0, 0x107c(%rax)
jl 0x1800
movq -0x8(%rbp), %rdi
callq 0x4fb0
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1050(%rax)
movq -0x8(%rbp), %rdi
callq 0x1810
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movslq %eax, %rdx
xorl %eax, %eax
cmpl $-0x1, 0x34(%rcx,%rdx,4)
movb %al, -0x19(%rbp)
je 0x1857
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1068(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1863
jmp 0x194c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rcx
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x1a(%rbp)
je 0x18b2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1068(%rax)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x18bb
jmp 0x1924
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4310
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x190e
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x51c0
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
jne 0x191f
jmp 0x1924
jmp 0x1872
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x182a
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movslq 0x838(%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1ac9
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movslq 0x838(%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4310
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movslq 0x838(%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x54(%rax)
jge 0x1abb
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x1abb
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x838(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x197d
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movslq 0x838(%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x2, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl 0x1050(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1050(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, 0x838(%rax,%rcx,4)
je 0x1b84
movq -0x8(%rbp), %rax
movl $0x2, 0x1050(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1960
movq -0x8(%rbp), %rdi
callq 0x1810
movq -0x8(%rbp), %rdi
callq 0x2360
movq -0x8(%rbp), %rax
cmpl $0x0, 0x188c(%rax)
jne 0x1b74
jmp 0x1b84
movq -0x8(%rbp), %rax
movl $0x0, 0x1068(%rax)
jmp 0x1b1f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0x0, 0x1040(%rax)
xorl %eax, %eax
cmpl $0x1, -0x4(%rbp)
movb %al, -0x1d(%rbp)
jle 0x1d1b
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x1d(%rbp)
je 0x1d1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1d27
jmp 0x1dad
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
je 0x1d6e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xa7b1(%rip), %rdi      # 0xc510
callq 0x6e80
cmpq $0x0, %rax
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x1d77
jmp 0x1d9c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %esi
callq 0x1de0
jmp 0x1d2e
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1cec
movq -0x18(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1dd5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6a20
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/flag_management.c
// Function: save_flag
static void		save_flag(t_info *info, char flag)
{
	if (flag == 'a')
		info->flag_storage = info->flag_storage | ANTS;
	else if (flag == 'e')
		info->flag_storage = info->flag_storage | ERROR;
	else if (flag == 'h')
		info->flag_storage = info->flag_storage | HELP;
	else if (flag == 'l')
		info->flag_storage = info->flag_storage | LINES;
	else if (flag == 'p')
		info->flag_storage = info->flag_storage | PATHS;
	else if (flag == 'v')
		info->flag_storage = info->flag_storage | VERBOSE;
	else if (flag == 'x')
		info->flag_storage = info->flag_storage | LEAKS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x61, %eax
jne 0x1e13
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1eef
movsbl -0x9(%rbp), %eax
cmpl $0x65, %eax
jne 0x1e38
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1eed
movsbl -0x9(%rbp), %eax
cmpl $0x68, %eax
jne 0x1e5d
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x4, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1eeb
movsbl -0x9(%rbp), %eax
cmpl $0x6c, %eax
jne 0x1e7f
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x10, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1ee9
movsbl -0x9(%rbp), %eax
cmpl $0x70, %eax
jne 0x1ea1
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x20, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1ee7
movsbl -0x9(%rbp), %eax
cmpl $0x76, %eax
jne 0x1ec3
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x40, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1ee5
movsbl -0x9(%rbp), %eax
cmpl $0x78, %eax
jne 0x1ee3
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %ecx
orl $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1040(%rax)
jmp 0x1ee5
jmp 0x1ee7
jmp 0x1ee9
jmp 0x1eeb
jmp 0x1eed
jmp 0x1eef
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x21(%rbp)
je 0x1f53
cmpl $0x0, -0x20(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1f5f
jmp 0x2020
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4310
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x4c(%rcx), %eax
jle 0x1fd1
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x4c(%rax)
jne 0x1feb
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x1feb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2012
movq -0x8(%rbp), %rax
cmpl $0x2, 0x106c(%rax)
jne 0x2010
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x2010
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2012
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f22
cmpl $0x0, -0x20(%rbp)
je 0x20b3
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
je 0x2054
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2031
jmp 0x2056
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x20b1
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2056
jmp 0x20b3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/handle_paths.c
// Function: last_on_path
int		last_on_path(int *path)
{
	int		i;

	i = 0;
	while (path[i + 1] != EMPTY)
		i++;
	return (path[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x20ed
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20cf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
jne 0x2153
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x38(%rax)
jne 0x2153
jmp 0x226e
jmp 0x2155
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
je 0x226e
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20c0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x106c(%rax)
jne 0x21c2
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x50(%rax)
jge 0x21c2
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x21f4
movq -0x8(%rbp), %rax
cmpl $0x2, 0x106c(%rax)
jne 0x2269
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x54(%rax)
jge 0x2269
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x2269
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x1f00
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x222d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2205
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
jne 0x2267
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x4b90
jmp 0x226e
jmp 0x2155
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/parse_ants.c
// Function: ft_isint
int			ft_isint(char *str)
{
	while (ft_isdigit(*str))
	{
		str++;
		if (*str == '\0')
			return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x6bc0
cmpl $0x0, %eax
je 0x22c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22be
movl $0x1, -0x4(%rbp)
jmp 0x22c7
jmp 0x228c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2280
cmpl $0x0, %eax
je 0x2344
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2334
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6a20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jge 0x2332
movq -0x8(%rbp), %rsi
leaq 0xa1eb(%rip), %rdi      # 0xc518
callq 0x4f60
jmp 0x2334
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x2354
movq -0x8(%rbp), %rsi
leaq 0xa1c9(%rip), %rdi      # 0xc518
callq 0x4f60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/reset_paths.c
// Function: reset_tmp_stacks
void	reset_tmp_stacks(t_info *info)
{
	int		i;
	int		y;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x201, -0xc(%rbp)      # imm = 0x201
jge 0x23ad
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x107c(%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x34(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2376
movl $0x0, -0xc(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1058(%rcx), %eax
jge 0x2409
jmp 0x23c5
cmpl $0x201, -0xc(%rbp)      # imm = 0x201
jge 0x23f7
movq -0x8(%rbp), %rax
movq 0x1048(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23c5
movl $0x0, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23b4
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x106c(%rcx)
movb %al, -0x1d(%rbp)
jne 0x245f
movq -0x10(%rbp), %rax
movq 0x1898(%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x2468
jmp 0x24c8
jmp 0x246a
movq -0x10(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x24bc
movq -0x10(%rbp), %rax
movq 0x1898(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x24ba
movl $0x1, -0x4(%rbp)
jmp 0x256d
jmp 0x246a
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x2429
jmp 0x24ca
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2, 0x106c(%rcx)
movb %al, -0x1e(%rbp)
jne 0x2500
movq -0x10(%rbp), %rax
movq 0x18a0(%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x2509
jmp 0x2566
jmp 0x250b
movq -0x10(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x255a
movq -0x10(%rbp), %rax
movq 0x18a0(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x2558
movl $0x1, -0x4(%rbp)
jmp 0x256d
jmp 0x250b
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x24ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x1050(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2618
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2410
cmpl $0x0, %eax
je 0x25f3
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x103c(%rcx), %eax
je 0x25f3
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x2, 0x5c(%rax)
jmp 0x260d
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 0x25a1
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: get_required_lines
void		get_required_lines(t_info *info, char *line)
{
	int		i;

	i = 0;
	while (!(ft_isdigit(line[i])))
		i++;
	info->required = ft_atoi(&(line[i]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6bc0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2656
jmp 0x2661
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2637
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0x6a20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1890(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x1070(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x1894(%rcx)
movb %al, -0xd(%rbp)
jne 0x26cd
movq -0x8(%rbp), %rax
cmpl $0x5, 0x1070(%rax)
setl %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x26d9
jmp 0x280d
movq -0x8(%rbp), %rdi
callq 0x2820
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2360
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 0x27ab
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1070(%rax)
jle 0x2758
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x54(%rax), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x5c(%rax)
jmp 0x2772
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, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
jmp 0x26ee
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x63a0
movq -0x8(%rbp), %rdi
callq 0x2880
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1b10
movq -0x8(%rbp), %rax
movl 0x1040(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x27ec
movq -0x8(%rbp), %rdi
callq 0x5a90
movq -0x8(%rbp), %rdi
callq 0x3500
movq -0x8(%rbp), %rax
movl 0x1070(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1070(%rax)
jmp 0x26aa
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: reset_values
static int	reset_values(t_info *info)
{
	info->phase = 2;
	info->level = 1;
	info->path_n_2 = 0;
	info->path_saved = 0;
	info->last_found_used_2 = 1;
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%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
movl $0x0, 0x1068(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x188c(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/run_second_and_third_round.c
// Function: save_first_level_rooms
static void	save_first_level_rooms(t_info *info)
{
	int		i;

	i = -1;
	while (++i < 513)
	{
		info->lvl_1_rooms[i] = info->check_rooms[i];
		info->check_rooms[i] = EMPTY;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x201, %eax            # imm = 0x201
jge 0x28cc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x838(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x34(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x288f
popq %rbp
retq
nop