LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/execve.c
// Function: main
int main() {
  libforks_ServerConn conn;
  assert(libforks_start(&conn) == libforks_OK);

  int exit_fd;

  assert(libforks_fork(
    conn,
    NULL, // pid_ptr
    NULL, // socket_fd_ptr
    &exit_fd, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  libforks_ExitEvent ee;
  assert(read(exit_fd, &ee, sizeof ee) == sizeof ee);

  assert(libforks_stop(conn) == libforks_OK);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1ab0
cmpl $0x0, %eax
jne 0x131f
jmp 0x133e
leaq 0x2cde(%rip), %rdi      # 0x4004
leaq 0x2cfc(%rip), %rsi      # 0x4029
movl $0x1b, %edx
leaq 0x2d02(%rip), %rcx      # 0x403b
callq 0x10b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x14(%rbp), %rcx
leaq 0x9f(%rip), %r8         # 0x13f0
movq %rdx, %rsi
callq 0x2280
cmpl $0x0, %eax
jne 0x1360
jmp 0x137f
leaq 0x2cdf(%rip), %rdi      # 0x4046
leaq 0x2cbb(%rip), %rsi      # 0x4029
movl $0x25, %edx
leaq 0x2cc1(%rip), %rcx      # 0x403b
callq 0x10b0
movl -0x14(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x8, %edx
callq 0x1100
cmpq $0x8, %rax
jne 0x1398
jmp 0x13b7
leaq 0x2cee(%rip), %rdi      # 0x408d
leaq 0x2c83(%rip), %rsi      # 0x4029
movl $0x28, %edx
leaq 0x2c89(%rip), %rcx      # 0x403b
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x2510
cmpl $0x0, %eax
jne 0x13c7
jmp 0x13e6
leaq 0x2cea(%rip), %rdi      # 0x40b8
leaq 0x2c54(%rip), %rsi      # 0x4029
movl $0x2a, %edx
leaq 0x2c5a(%rip), %rcx      # 0x403b
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/execve.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  assert(socket_fd == -1);

  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  char * const argv[] = {
    "echo",
    "hello, world!",
    NULL
  };
  execve("/bin/echo", argv, environ);
  perror("execve");
  abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x1407
jmp 0x1426
leaq 0x2ccd(%rip), %rdi      # 0x40db
leaq 0x2c14(%rip), %rsi      # 0x4029
movl $0xa, %edx
leaq 0x2cca(%rip), %rcx      # 0x40eb
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x2580
cmpl $0x0, %eax
jne 0x1436
jmp 0x1455
leaq 0x2cd8(%rip), %rdi      # 0x4115
leaq 0x2be5(%rip), %rsi      # 0x4029
movl $0xd, %edx
leaq 0x2c9b(%rip), %rcx      # 0x40eb
callq 0x10b0
movq 0x5974(%rip), %rax      # 0x6dd0
movq %rax, -0x30(%rbp)
movq 0x5971(%rip), %rax      # 0x6dd8
movq %rax, -0x28(%rbp)
movq 0x596e(%rip), %rax      # 0x6de0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rsi
movq 0x5b5f(%rip), %rax      # 0x6fe0
movq (%rax), %rdx
leaq 0x2cc0(%rip), %rdi      # 0x414b
callq 0x1110
leaq 0x2cbe(%rip), %rdi      # 0x4155
callq 0x11c0
callq 0x1040
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/main.c
// Function: main
int	main(int argc, char *argv[])
{
	t_game	game;
	int		w;

	ft_bzero(&game, sizeof(t_game));
	if (argc == 2)
	{
		if (check_map(argv[1], &game))
			game_config(&game);
		else
			return (check_error(INVALID_MAP));
		game_init(&game);
	}
	else
		return (check_error(INVALID_PARAM_NB));
	return (SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x170(%rbp), %rdi
movl $0x160, %esi            # imm = 0x160
callq 0x66f0
cmpl $0x2, -0x8(%rbp)
jne 0x65c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x170(%rbp), %rsi
callq 0x7400
cmpl $0x0, %eax
je 0x65a7
leaq -0x170(%rbp), %rdi
callq 0x7a20
jmp 0x65b6
movl $0x1, %edi
callq 0x7700
movl %eax, -0x4(%rbp)
jmp 0x65da
leaq -0x170(%rbp), %rdi
callq 0x8650
jmp 0x65d3
movl $0x2, %edi
callq 0x7700
movl %eax, -0x4(%rbp)
jmp 0x65da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_calloc.c
// Function: ft_calloc
void	*ft_calloc(size_t nmemb, size_t size)
{
	void	*r;
	int		index;

	index = 0;
	if (nmemb * size > INT_MAX)
	{
		errno = 12;
		return (0);
	}
	r = malloc(nmemb * size);
	if (r)
	{
		while (index < nmemb * size)
		{
			((char *)r)[index] = 0;
			index++;
		}
		return (r);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jbe 0x662d
callq 0x62a0
movl $0xc, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x6683
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0x6130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x667b
jmp 0x6648
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x6671
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6648
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6683
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_strlen.c
// Function: ft_strlen
int	ft_strlen(const char *s)
{
	size_t	index;

	index = 0;
	while (s[index] && s[index] != '\n')
		index++;
	return (index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x66cb
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x66d4
jmp 0x66e2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x66a0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/get_next_line.c
// Function: get_line_size
size_t	get_line_size(char	*data)
{
	size_t	size;

	size = 0;
	while (data[size] && data[size] != '\n')
		size++;
	if (data[size] == '\n')
		size++;
	return (size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x676b
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6774
jmp 0x6782
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6740
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x679f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/get_next_line.c
// Function: append_line
int	append_line(char *line, char *data)
{
	int		index;
	int		sub_index;

	sub_index = 0;
	index = 0;
	while (line[index])
		index++;
	while (data[sub_index])
	{
		line[index + sub_index] = data[sub_index];
		if (data[sub_index] == '\n')
			return (sub_index + 1);
		sub_index++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x67e3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x67ca
jmp 0x67e5
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x6835
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x682a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x683c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x67e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/get_next_line.c
// Function: get_line
void	get_line(t_buffer *buffer)
{
	size_t	size;
	char	*tmp;
	int		desloc;

	desloc = buffer->desloc;
	size = get_line_size(&buffer->data[desloc]);
	if (buffer->line)
		size += get_line_size(buffer->line);
	tmp = (char *) ft_calloc(size + 1, sizeof(char));
	if (buffer->line)
	{
		append_line(tmp, buffer->line);
		free(buffer->line);
	}
	desloc = append_line(tmp, &buffer->data[desloc]);
	buffer->line = tmp;
	if (desloc == -1)
	{
		ft_bzero(buffer->data, BUFFER_SIZE);
		buffer->desloc = 0;
		if ((read(buffer->fd, buffer->data, BUFFER_SIZE)) > 0)
			get_line(buffer);
	}
	else
		buffer->desloc += desloc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x6730
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x689e
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x6730
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x65f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x68dd
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
callq 0x67b0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x61a0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
callq 0x67b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
cmpl $-0x1, -0x1c(%rbp)
jne 0x6950
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x64, %esi
callq 0x66f0
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl $0x64, %edx
callq 0x6110
cmpq $0x0, %rax
jle 0x694e
movq -0x8(%rbp), %rdi
callq 0x6850
jmp 0x695d
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x6c(%rax), %ecx
movl %ecx, 0x6c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/get_next_line.c
// Function: get_next_line
char	*get_next_line(int fd)
{
	static t_buffer	list[255];
	t_buffer		*buffer;

	if (fd < 0 || fd > 255)
		return (0);
	buffer = &list[fd];
	buffer->fd = fd;
	buffer->line = 0;
	if (*buffer->data == 0)
	{
		if ((read(fd, buffer->data, BUFFER_SIZE)) <= 0)
			return (0);
	}
	get_line(buffer);
	if (*buffer->line == 0)
	{
		free(buffer->line);
		return (0);
	}
	return (buffer->line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x698a
cmpl $0xff, -0xc(%rbp)
jle 0x6997
movq $0x0, -0x8(%rbp)
jmp 0x6a32
movslq -0xc(%rbp), %rcx
leaq 0xd90e(%rip), %rax      # 0x142b0
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x69f6
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movl $0x64, %edx
callq 0x6110
cmpq $0x0, %rax
jg 0x69f4
movq $0x0, -0x8(%rbp)
jmp 0x6a32
jmp 0x69f6
movq -0x18(%rbp), %rdi
callq 0x6850
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6a26
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x61a0
movq $0x0, -0x8(%rbp)
jmp 0x6a32
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/is_in.c
// Function: is_in
int	is_in(char *str, char c)
{
	while (*str)
	{
		if (*str == c)
			return (1);
		str++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6a7d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6a6f
movl $0x1, -0x4(%rbp)
jmp 0x6a84
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6a4e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*string;
	size_t	size;
	size_t	index;

	index = 0;
	if (!s)
		return (0);
	if (start > ft_strlen(s))
		size = 0;
	else
	{
		size = ft_strlen(&s[start]);
		if (len < size)
			size = len;
	}
	string = (char *) ft_calloc(size + 1, sizeof(char));
	if (!string)
		return (0);
	while (index < size)
	{
		string[index] = s[start + index];
		index++;
	}
	string[index] = '\0';
	return (string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6abf
movq $0x0, -0x8(%rbp)
jmp 0x6b78
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6690
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jbe 0x6ae1
movq $0x0, -0x30(%rbp)
jmp 0x6b0a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
callq 0x6690
cltq
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x6b08
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6b0a
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x65f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6b31
movq $0x0, -0x8(%rbp)
jmp 0x6b78
jmp 0x6b33
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x6b64
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x6b33
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/pixel_manipulation.c
// Function: copy_img_from
void	copy_img_from(t_data *dest, t_data *src, int info[4])
{
	int	pixel;
	int	x;
	int	y;
	int	holder;

	x = 0;
	y = 0;
	holder = info[1];
	while (x < info[2])
	{
		while (y < info[3])
		{
			pixel = my_mlx_get_pixel(src, info[0], info[1]);
			if (pixel != 0 && pixel != -16777216)
				my_mlx_pixel_put(dest, x, y, pixel);
			y++;
			info[1]++;
		}
		y = 0;
		info[1] = holder;
		info[0]++;
		x++;
	}
	free(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6d06
jmp 0x6c7e
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6cdc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x6bf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6cc4
cmpl $0xff000000, -0x1c(%rbp) # imm = 0xFF000000
je 0x6cc4
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x6b90
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x6c7e
movl $0x0, -0x24(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6c6c
movq -0x18(%rbp), %rdi
callq 0x61a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/pixel_manipulation.c
// Function: copy_img_to
void	copy_img_to(t_data *dest, t_data *src, int info[4])
{
	int	pixel;
	int	x;
	int	y;
	int	holder;

	x = 0;
	y = 0;
	holder = info[1];
	while (x < info[2])
	{
		while (y < info[3])
		{
			pixel = my_mlx_get_pixel(src, x, y);
			if (pixel != 0 && pixel != -16777216)
				my_mlx_pixel_put(dest, info[0], info[1], pixel);
			y++;
			info[1]++;
		}
		y = 0;
		info[1] = holder;
		info[0]++;
		x++;
	}
	free(info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6de6
jmp 0x6d5e
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6dbc
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x6bf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6da4
cmpl $0xff000000, -0x1c(%rbp) # imm = 0xFF000000
je 0x6da4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movl -0x1c(%rbp), %ecx
callq 0x6b90
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x6d5e
movl $0x0, -0x24(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6d4c
movq -0x18(%rbp), %rdi
callq 0x61a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/pixel_manipulation.c
// Function: to_array
int	*to_array(int x, int y, int w, int h)
{
	int	*array;

	array = (int *)malloc(sizeof(int) * 4);
	array[0] = x;
	array[1] = y;
	array[2] = w;
	array[3] = h;
	return (array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x10, %edi
callq 0x6130
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_strcat.c
// Function: ft_strcat
void	ft_strcat(char *dest, char *src)
{
	while (*dest)
		dest++;
	while (*src && *src != '\n')
	{	
		*dest = *src;
		dest++;
		src++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6f73
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6f5c
jmp 0x6f75
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x6f96
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6f9f
jmp 0x6fc5
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6f75
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_itoa.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	size_t			size;
	unsigned int	number;
	int				is_negative;

	is_negative = 0;
	if (n < 0)
	{
		number = n * -1;
		is_negative = 1;
	}
	else
		number = n;
	size = get_size(number);
	if (number == 0)
		size = 1;
	return (set_string(number, size, is_negative));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6ff8
imull $-0x1, -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x6ffe
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x7030
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x7018
movq $0x1, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x7070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_itoa.c
// Function: get_size
static size_t	get_size(int n)
{
	size_t	index;

	index = 0;
	while (n)
	{
		n = n / 10;
		index++;
	}
	return (index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x7061
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x703f
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/utils/ft_itoa.c
// Function: set_string
static char	*set_string(unsigned int n, size_t size, int is_negative)
{
	char	*string;

	if (is_negative)
		size++;
	string = (char *) ft_calloc(size + 1, sizeof(char));
	if (!string)
		return (0);
	while (size > 0)
	{
		string[size - 1] = (n % 10) + 48;
		n = n / 10;
		size--;
	}
	if (is_negative)
		string[0] = '-';
	return (string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7094
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x65f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x70bb
movq $0x0, -0x8(%rbp)
jmp 0x7114
jmp 0x70bd
cmpq $0x0, -0x18(%rbp)
jbe 0x70ff
movl -0xc(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x70bd
cmpl $0x0, -0x1c(%rbp)
je 0x710c
movq -0x28(%rbp), %rax
movb $0x2d, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map.c
// Function: get_all_content
int	get_all_content(int fd, t_game *game)
{
	int		x;
	int		y;
	char	*line;
	char	*all_content;

	x = -1;
	y = 0;
	all_content = 0;
	line = get_next_line(fd);
	while (line)
	{
		if (check_format(line) && (x == -1 || x == ft_strlen(line)))
		{
			if (x == -1)
				x = ft_strlen(line);
			append(&all_content, line);
		}
		else
			return (0);
		y++;
		line = get_next_line(fd);
	}
	make_layout(game, x, y, all_content);
	free(all_content);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x8(%rbp), %edi
callq 0x6970
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x71c5
movq -0x20(%rbp), %rdi
callq 0x7200
cmpl $0x0, %eax
je 0x71a5
cmpl $-0x1, -0x14(%rbp)
je 0x7184
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6690
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x71a5
cmpl $-0x1, -0x14(%rbp)
jne 0x7196
movq -0x20(%rbp), %rdi
callq 0x6690
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7280
jmp 0x71ae
movl $0x0, -0x4(%rbp)
jmp 0x71e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x6970
movq %rax, -0x20(%rbp)
jmp 0x7151
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x7350
movq -0x28(%rbp), %rdi
callq 0x61a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map.c
// Function: check_format
static int	check_format(char	*line)
{
	while (*line && *line != '\n')
	{
		if (!is_in(OBJECTS, *line))
			return (0);
		line++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x722d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7236
jmp 0x7265
movq -0x10(%rbp), %rax
leaq 0x4dc3(%rip), %rdi      # 0xc004
movsbl (%rax), %esi
callq 0x6a40
cmpl $0x0, %eax
jne 0x7257
movl $0x0, -0x4(%rbp)
jmp 0x726c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x720c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map.c
// Function: append
static void	append(char **dest, char *src)
{
	char	*holder;
	int		index;

	index = 0;
	if (*dest == 0)
		*dest = (char *) ft_calloc(ft_strlen(src) + 1, sizeof(char));
	else
	{
		holder = *dest;
		*dest = (char *) ft_calloc(ft_strlen(*dest) + ft_strlen(src) + 1, 1);
		ft_strcat(*dest, holder);
		free(holder);
	}
	ft_strcat(*dest, src);
	free(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x72c6
movq -0x10(%rbp), %rdi
callq 0x6690
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7323
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6690
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6690
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f50
movq -0x18(%rbp), %rdi
callq 0x61a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6f50
movq -0x10(%rbp), %rdi
callq 0x61a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map.c
// Function: make_layout
static void	make_layout(t_game *game, int x, int y, char *content)
{
	int	index;

	index = 0;
	game->map.layout = ft_calloc(y, sizeof(char *));
	while (index < y)
	{
		game->map.layout[index] = ft_substr(content, 0, x);
		content += x;
		index++;
	}
	game->map.w = x;
	game->map.h = y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x65f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x73d2
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x6a90
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7389
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x128(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x12c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map.c
// Function: check_map
int	check_map(char	*map_path, t_game *game)
{
	int		fd;
	int		x;
	int		y;

	if (!(check_ex(map_path)))
		return (0);
	fd = open(map_path, O_RDONLY);
	if (fd == -1)
		return (0);
	if (!(get_all_content(fd, game)))
	{
		close(fd);
		return (0);
	}
	close(fd);
	if (!(check_surround_wall(game)))
		return (0);
	if (!(check_structure(game)))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7740
cmpl $0x0, %eax
jne 0x7427
movl $0x0, -0x4(%rbp)
jmp 0x74a5
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6400
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x7446
movl $0x0, -0x4(%rbp)
jmp 0x74a5
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x7120
cmpl $0x0, %eax
jne 0x7468
movl -0x1c(%rbp), %edi
callq 0x6070
movl $0x0, -0x4(%rbp)
jmp 0x74a5
movl -0x1c(%rbp), %edi
callq 0x6070
movq -0x18(%rbp), %rdi
callq 0x7800
cmpl $0x0, %eax
jne 0x7487
movl $0x0, -0x4(%rbp)
jmp 0x74a5
movq -0x18(%rbp), %rdi
callq 0x7900
cmpl $0x0, %eax
jne 0x749e
movl $0x0, -0x4(%rbp)
jmp 0x74a5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_movs.c
// Function: check_mov
int	check_mov(t_game *game, int x, int y)
{
	y += game->player.y + game->map.y;
	x += game->player.x + game->map.x;
	if (game->map.layout[y][x] != '1')
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x124(%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x120(%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x751b
movl $0x1, -0x4(%rbp)
jmp 0x7522
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_exit.c
// Function: check_exit
void	check_exit(t_game *game)
{
	static int	open;
	int			x;
	int			y;

	if (!game->items && !open)
	{
		open = 1;
		open_exits(game);
	}
	if (!game->items)
	{
		x = game->player.x + game->map.x;
		y = game->player.y + game->map.y;
		if (game->map.layout[y][x] == 'E')
			game->win = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jne 0x7566
cmpl $0x0, 0x144e7(%rip)     # 0x1ba38
jne 0x7566
movl $0x1, 0x144db(%rip)     # 0x1ba38
movq -0x8(%rbp), %rdi
callq 0x75e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jne 0x75d2
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x120(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x124(%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x45, %eax
jne 0x75d0
movq -0x8(%rbp), %rax
movl $0x1, 0x158(%rax)
jmp 0x75d2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_exit.c
// Function: open_exits
static void	open_exits(t_game *game)
{
	int			x;
	int			x_holder;
	int			y;

	x = game->map.w;
	x_holder = x;
	y = game->map.h;
	while (y--)
	{
		while (x--)
		{
			if (game->map.layout[y][x] == 'E')
				draw_open_exit(x, y, game);
		}
		x = x_holder;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x7667
jmp 0x761e
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x765f
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x45, %eax
jne 0x765d
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x7670
jmp 0x761e
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x760c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_exit.c
// Function: draw_open_exit
static void	draw_open_exit(int x, int y, t_game *game)
{
	t_data	img;

	img.w = BLOCK_SIZE;
	img.h = BLOCK_SIZE;
	x *= BLOCK_SIZE;
	y *= BLOCK_SIZE;
	load_img(&img, "./imgs/exit2.xpm", game);
	copy_img_to(&game->map.full_map, &img,
		to_array(x, y, img.w, img.h));
	free(img.img);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x40, -0x1c(%rbp)
movl $0x40, -0x18(%rbp)
movl -0x4(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x4959(%rip), %rsi      # 0xc00a
callq 0x6e60
movq -0x10(%rbp), %rax
addq $0xc8, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x6e00
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq -0x38(%rbp), %rsi
callq 0x6d20
movq -0x38(%rbp), %rdi
callq 0x61a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_error.c
// Function: check_error
int	check_error(int error)
{
    if (error == INVALID_MAP)
        printf("The given map is invalid!\n");
    if (error == INVALID_PARAM_NB)
        printf("Parameter's number must be 1\n");
    return (error);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x771f
leaq 0x4903(%rip), %rdi      # 0xc01b
movb $0x0, %al
callq 0x6040
cmpl $0x2, -0x4(%rbp)
jne 0x7733
leaq 0x490a(%rip), %rdi      # 0xc036
movb $0x0, %al
callq 0x6040
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_ex
int check_ex(char *file)
{
    int index;

    index = ft_strlen(file);
    if (index-- < 4)
        return (0);
    if (file[index--] != 'r' || file[index--] != 'e' || file[index--] != 'b')
        return (0);
    if (file[index] != '.')
        return (0);
    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6690
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x4, %eax
jge 0x7771
movl $0x0, -0x4(%rbp)
jmp 0x77ec
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x72, %eax
jne 0x77c2
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
jne 0x77c2
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x62, %eax
je 0x77cb
movl $0x0, -0x4(%rbp)
jmp 0x77ec
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x77e5
movl $0x0, -0x4(%rbp)
jmp 0x77ec
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_surround_wall
int check_surround_wall(t_game *game)
{
    char    **layout;
    int     x;
    int     y;

    x = game->map.w;
    y = game->map.h;
    layout = game->map.layout;
    while (x--)
    {
        if (layout[0][x] != '1')
            return (0);
        if (layout[y - 1][x] != '1')
            return (0);
    }
    x = game->map.w - 1;
    while (y--)
    {
        if (layout[y][0] != '1')
            return (0);
        if (layout[y][x] != '1')
            return (0);
    }
    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x12c(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x788a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x7861
movl $0x0, -0x4(%rbp)
jmp 0x78f2
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x7888
movl $0x0, -0x4(%rbp)
jmp 0x78f2
jmp 0x7831
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0x78eb
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
je 0x78c7
movl $0x0, -0x4(%rbp)
jmp 0x78f2
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x78e9
movl $0x0, -0x4(%rbp)
jmp 0x78f2
jmp 0x789a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_structure
int check_structure(t_game *game)
{
	int	x;
	int	x_hold;
	int	y;
	int	check[3];

	x = game->map.w;
	x_hold = game->map.w;
	y = game->map.h;
	check[0] = 0;
	check[1] = 0;
	check[2] = 0;
	while (y--)
	{
		while (x--)
		{
			if (game->map.layout[y][x] == 'C')
				check[0] = 1;
			if (game->map.layout[y][x] == 'P')
				check[1] = 1;
			if (game->map.layout[y][x] == 'E')
				check[2] = 1;
		}
		x = x_hold;
	}
	return (check[0] && check[1] && check[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x79ef
jmp 0x795a
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x79e4
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0x7991
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x50, %eax
jne 0x79b8
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x45, %eax
jne 0x79df
movl $0x1, -0x18(%rbp)
jmp 0x795a
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7944
xorl %eax, %eax
cmpl $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x7a0f
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
je 0x7a0f
cmpl $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/game_config.c
// Function: game_config
void	game_config(t_game *game)
{
	game->vars.mlx = mlx_init();
	map_config(game);
	player_config(game);
	enemy_config(game);
	if (game->map.w > 14)
		game->width = 14;
	else
		game->width = game->map.w;
	if (game->map.h > 10)
		game->height = 10;
	else
		game->height = game->map.h;
	game->vars.win = mlx_new_window(game->vars.mlx, game->width * BLOCK_SIZE,
			game->height * BLOCK_SIZE, "Dungeon Zone");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x96a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7bd0
movq -0x8(%rbp), %rdi
callq 0x7e60
movq -0x8(%rbp), %rdi
callq 0x8200
movq -0x8(%rbp), %rax
cmpl $0xe, 0x128(%rax)
jle 0x7a75
movq -0x8(%rbp), %rax
movl $0xe, 0x148(%rax)
jmp 0x7a89
movq -0x8(%rbp), %rax
movl 0x128(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x148(%rax)
movq -0x8(%rbp), %rax
cmpl $0xa, 0x12c(%rax)
jle 0x7aa6
movq -0x8(%rbp), %rax
movl $0xa, 0x14c(%rax)
jmp 0x7aba
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x148(%rax), %esi
shll $0x6, %esi
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %edx
shll $0x6, %edx
leaq 0x4572(%rip), %rcx      # 0xc054
callq 0x97f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/map_config.c
// Function: get_active_map
void	get_active_map(t_game *game)
{
	int	w;
	int	h;
	int	x;
	int	y;

	w = game->width * BLOCK_SIZE;
	h = game->height * BLOCK_SIZE;
	if (!game->map.map.img)
	{
		create_img(&game->map.map, w, h, game);
		fix_cam(game);
	}
	x = game->map.x * BLOCK_SIZE;
	y = game->map.y * BLOCK_SIZE;
	copy_img_from(&game->map.map, &game->map.full_map, to_array(x, y, w, h));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x148(%rax), %eax
shll $0x6, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %eax
shll $0x6, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x7b61
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x6ee0
movq -0x8(%rbp), %rdi
callq 0x8370
movq -0x8(%rbp), %rax
movl 0x120(%rax), %eax
shll $0x6, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0xc8, %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0xc8, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x6e00
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x6c40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/map_config.c
// Function: map_config
void	map_config(t_game *game)
{
	int		x;
	int		x_holder;
	int		y;

	x = game->map.w;
	x_holder = x;
	y = game->map.h;
	game->map.x = 0;
	game->map.y = 0;
	game->map.map.img = 0;
	create_img(&game->map.full_map, x * BLOCK_SIZE, y * BLOCK_SIZE, game);
	while (y--)
	{
		while (x--)
			draw_block(game, x, y);
		x = x_holder;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x124(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
shll $0x6, %esi
movl -0x14(%rbp), %edx
shll $0x6, %edx
movq -0x8(%rbp), %rcx
callq 0x6ee0
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x7c86
jmp 0x7c5d
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x7c7e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x7c90
jmp 0x7c5d
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7c4b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/map_config.c
// Function: draw_block
static void	draw_block(t_game *game, int x, int y)
{
	t_data	sprite;
	char	block;
	int		real_x;
	int		real_y;

	block = game->map.layout[y][x];
	real_x = x * BLOCK_SIZE;
	real_y = y * BLOCK_SIZE;
	if (block == 'P')
	{
		game->player.x = x;
		game->player.y = y;
	}
	if (block == 'C')
		new_item(game, x, y);
	set_tile('0', game, real_x, real_y);
	set_tile(block, game, real_x, real_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movl -0xc(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x40(%rbp)
movl -0x10(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x44(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x50, %eax
jne 0x7cf4
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb4(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb8(%rax)
movsbl -0x39(%rbp), %eax
cmpl $0x43, %eax
jne 0x7d0c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x7f70
movq -0x8(%rbp), %rsi
movl -0x40(%rbp), %edx
movl -0x44(%rbp), %ecx
movl $0x30, %edi
callq 0x7d40
movb -0x39(%rbp), %al
movq -0x8(%rbp), %rsi
movl -0x40(%rbp), %edx
movl -0x44(%rbp), %ecx
movsbl %al, %edi
callq 0x7d40
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/map_config.c
// Function: set_tile
static void	set_tile(char c, t_game *game, int x, int y)
{
	t_data			tile;
	char			*path;
	static size_t	i;
	int				size;

	size = BLOCK_SIZE;
	if (c == '1')
		path = "./imgs/wall3.xpm";
	if (c == 'E')
		path = "./imgs/exit_lock.xpm";
	if (c == 'C' || c == 'P' || c == '0')
	{
		if (i % 18 == 0)
			path = "./imgs/floor4.xpm";
		else if (i % 28 == 0)
			path = "./imgs/floor5.xpm";
		else
			path = "./imgs/floor3.xpm";
		i++;
	}
	load_img(&tile, path, game);
	copy_img_to(&game->map.full_map, &tile, to_array(x, y, size, size));
	free(tile.img);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x40, -0x4c(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x31, %eax
jne 0x7d73
leaq 0x42f2(%rip), %rax      # 0xc061
movq %rax, -0x48(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x45, %eax
jne 0x7d87
leaq 0x42ef(%rip), %rax      # 0xc072
movq %rax, -0x48(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x43, %eax
je 0x7da2
movsbl -0x1(%rbp), %eax
cmpl $0x50, %eax
je 0x7da2
movsbl -0x1(%rbp), %eax
cmpl $0x30, %eax
jne 0x7e09
movq 0x13c97(%rip), %rax     # 0x1ba40
movl $0x12, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x7dc6
leaq 0x42c7(%rip), %rax      # 0xc087
movq %rax, -0x48(%rbp)
jmp 0x7df7
movq 0x13c73(%rip), %rax     # 0x1ba40
movl $0x1c, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x7dea
leaq 0x42b5(%rip), %rax      # 0xc099
movq %rax, -0x48(%rbp)
jmp 0x7df5
leaq 0x42ba(%rip), %rax      # 0xc0ab
movq %rax, -0x48(%rbp)
jmp 0x7df7
movq 0x13c42(%rip), %rax     # 0x1ba40
addq $0x1, %rax
movq %rax, 0x13c37(%rip)     # 0x1ba40
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6e60
movq -0x10(%rbp), %rax
addq $0xc8, %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x4c(%rbp), %edx
movl -0x4c(%rbp), %ecx
callq 0x6e00
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq -0x40(%rbp), %rsi
callq 0x6d20
movq -0x40(%rbp), %rdi
callq 0x61a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)