LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
cmpl $-0x1, %esi
jne 0x1437
callq 0x2423
testl %eax, %eax
jne 0x1456
movq 0x39e1(%rip), %rax      # 0x4de0
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
movaps 0x39c3(%rip), %xmm0     # 0x4dd0
movaps %xmm0, (%rsi)
movq 0x3bc9(%rip), %rax      # 0x4fe0
movq (%rax), %rdx
leaq 0x1d2a(%rip), %rdi      # 0x314b
callq 0x1100
leaq 0x1d28(%rip), %rdi      # 0x3155
callq 0x11b0
callq 0x1040
leaq 0x1c9d(%rip), %rdi      # 0x30db
leaq 0x1be4(%rip), %rsi      # 0x3029
leaq 0x1c9f(%rip), %rcx      # 0x30eb
movl $0xa, %edx
callq 0x10b0
leaq 0x1cb8(%rip), %rdi      # 0x3115
leaq 0x1bc5(%rip), %rsi      # 0x3029
leaq 0x1c80(%rip), %rcx      # 0x30eb
movl $0xd, %edx
callq 0x10b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movl $0x160, %esi            # imm = 0x160
callq 0x6600
cmpl $0x2, %ebp
jne 0x6589
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6d5e
testl %eax, %eax
je 0x6590
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7088
movq %rbx, %rdi
callq 0x7838
xorl %eax, %eax
jmp 0x659a
movl $0x2, %edi
jmp 0x6595
movl $0x1, %edi
callq 0x6f54
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
imulq %rsi, %rbx
testq $-0x80000000, %rbx      # imm = 0x80000000
je 0x65c2
callq 0x6290
movl $0xc, (%rax)
jmp 0x65e2
movq %rbx, %rdi
callq 0x6120
testq %rax, %rax
je 0x65e2
testq %rbx, %rbx
je 0x65e4
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x6040
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
testl %ecx, %ecx
je 0x65fc
cmpl $0xa, %ecx
je 0x65fc
incq %rax
jmp 0x65ea
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
testl %edx, %edx
je 0x6624
cmpl $0xa, %edx
je 0x6624
incq %rcx
jmp 0x6612
xorl %eax, %eax
cmpb $0xa, %dl
sete %al
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdi, %rax
incl %edx
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x6638
movb (%rsi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x666d
movl %edx, %edx
addq %rdx, %rdi
movl $0x1, %edx
movb %cl, -0x1(%rdi,%rdx)
cmpb $0xa, -0x1(%rsi,%rdx)
je 0x666e
movb (%rsi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x6658
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5(%rdi), %r12
leaq 0x4(%rdi), %r14
movslq 0x6c(%rbx), %r13
leaq (%rbx,%r13), %rbp
addq $0x4, %rbp
xorl %eax, %eax
movzbl (%rbp,%rax), %ecx
testl %ecx, %ecx
je 0x66a8
cmpl $0xa, %ecx
je 0x66a8
incq %rax
jmp 0x6695
xorl %edi, %edi
cmpb $0xa, %cl
sete %dil
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0x66dd
addq %rax, %rdi
movq %rdi, %rax
movzbl (%rcx), %edx
testl %edx, %edx
je 0x66d4
cmpl $0xa, %edx
je 0x66d4
incq %rax
incq %rcx
jmp 0x66c0
xorl %edi, %edi
cmpb $0xa, %dl
sete %dil
addq %rax, %rdi
incq %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %r15
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x6736
movq $-0x1, %rdx
cmpb $0x0, 0x1(%r15,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x6700
movb (%rax), %cl
testb %cl, %cl
je 0x672d
movl %edx, %edx
addq %r15, %rdx
xorl %esi, %esi
movb %cl, (%rdx,%rsi)
cmpb $0xa, (%rax,%rsi)
je 0x672d
movb 0x1(%rax,%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x6719
movq 0x70(%rbx), %rdi
callq 0x6190
movq $-0x1, %rdx
cmpb $0x0, 0x1(%r15,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x673d
movb (%rbp), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x677f
movl %edx, %esi
movq %r15, %rdx
addq %rsi, %rdx
addq %r12, %r13
xorl %esi, %esi
movb %cl, (%rdx,%rsi)
cmpb $0xa, -0x1(%r13,%rsi)
je 0x677b
movb (%r13,%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x6762
jmp 0x677f
incl %esi
movl %esi, %eax
movq %r15, 0x70(%rbx)
cmpl $-0x1, %eax
jne 0x67b6
movl $0x64, %esi
movq %r14, %rdi
callq 0x6600
movl $0x0, 0x6c(%rbx)
movl (%rbx), %edi
movl $0x64, %edx
movq %r14, %rsi
callq 0x6100
testq %rax, %rax
jg 0x6687
jmp 0x67b9
addl %eax, 0x6c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0xff, %edi
jbe 0x67d3
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %eax
imulq $0x78, %rax, %r14
leaq 0xcaac(%rip), %rbx      # 0x13290
movl %edi, (%r14,%rbx)
movq $0x0, 0x70(%r14,%rbx)
cmpb $0x0, 0x4(%r14,%rbx)
jne 0x6810
leaq (%r14,%rbx), %rsi
addq $0x4, %rsi
movl $0x64, %edx
callq 0x6100
testq %rax, %rax
jle 0x682c
addq %r14, %rbx
movq %rbx, %rdi
callq 0x6671
movq 0x70(%rbx), %rax
cmpb $0x0, (%rax)
jne 0x682e
movq %rax, %rdi
callq 0x6190
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x6876
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x65e8
cmpl %ebp, %eax
jae 0x6879
xorl %ebx, %ebx
jmp 0x688c
xorl %eax, %eax
retq
movl %ebp, %edi
addq %r14, %rdi
callq 0x65e8
cltq
cmpq %rbx, %rax
cmovbq %rax, %rbx
leaq 0x1(%rbx), %rdi
movl $0x1, %esi
callq 0x65a4
testq %rax, %rax
je 0x68bc
testq %rbx, %rbx
je 0x68c0
movl %ebp, %ecx
addq %rcx, %r14
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rbx
jne 0x68ab
jmp 0x68c2
xorl %eax, %eax
jmp 0x68c6
xorl %ebx, %ebx
movb $0x0, (%rax,%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x8(%rdx)
jle 0x69b0
pushq %rbp
pushq %rbx
movl 0x4(%rdx), %eax
xorl %ecx, %ecx
cmpl $0x0, 0xc(%rdx)
jle 0x699e
movq 0x8(%rsi), %r8
xorl %r9d, %r9d
movl 0x10(%rsi), %r10d
movl 0x14(%rsi), %r11d
leal 0x7(%r10), %ebx
testl %r10d, %r10d
cmovnsl %r10d, %ebx
sarl $0x3, %ebx
imull 0x4(%rdx), %r11d
imull (%rdx), %ebx
addl %r11d, %ebx
movslq %ebx, %r10
movl (%r8,%r10), %r10d
cmpl $0xff000000, %r10d      # imm = 0xFF000000
je 0x6992
testl %r10d, %r10d
je 0x6992
movl 0x10(%rdi), %r11d
leal 0x7(%r11), %ebx
testl %r11d, %r11d
cmovnsl %r11d, %ebx
sarl $0x3, %ebx
movq 0x8(%rdi), %r11
movl 0x14(%rdi), %ebp
imull %r9d, %ebp
imull %ecx, %ebx
addl %ebp, %ebx
movslq %ebx, %rbx
movl %r10d, (%r11,%rbx)
incl 0x4(%rdx)
incl %r9d
cmpl 0xc(%rdx), %r9d
jl 0x6933
movl %eax, 0x4(%rdx)
incl (%rdx)
incl %ecx
cmpl 0x8(%rdx), %ecx
jl 0x6926
popq %rbx
popq %rbp
movq %rdx, %rdi
jmp 0x6190
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x8(%rdx)
jle 0x6a59
pushq %r14
pushq %rbx
movl 0x4(%rdx), %eax
xorl %ecx, %ecx
cmpl $0x0, 0xc(%rdx)
jle 0x6a46
movq 0x8(%rsi), %r8
xorl %r9d, %r9d
movl 0x10(%rsi), %r10d
leal 0x7(%r10), %r11d
testl %r10d, %r10d
cmovnsl %r10d, %r11d
sarl $0x3, %r11d
movl 0x14(%rsi), %r10d
imull %r9d, %r10d
imull %ecx, %r11d
addl %r10d, %r11d
movslq %r11d, %r10
movl (%r8,%r10), %r10d
cmpl $0xff000000, %r10d      # imm = 0xFF000000
je 0x6a3a
testl %r10d, %r10d
je 0x6a3a
movl 0x10(%rdi), %r11d
leal 0x7(%r11), %ebx
testl %r11d, %r11d
cmovnsl %r11d, %ebx
sarl $0x3, %ebx
movl 0x14(%rdi), %r11d
imull 0x4(%rdx), %r11d
imull (%rdx), %ebx
movq 0x8(%rdi), %r14
addl %r11d, %ebx
movslq %ebx, %r11
movl %r10d, (%r14,%r11)
incl 0x4(%rdx)
incl %r9d
cmpl 0xc(%rdx), %r9d
jl 0x69d7
movl %eax, 0x4(%rdx)
incl (%rdx)
incl %ecx
cmpl 0x8(%rdx), %ecx
jl 0x69ca
popq %rbx
popq %r14
movq %rdx, %rdi
jmp 0x6190
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl $0x10, %edi
callq 0x6120
movl %r15d, (%rax)
movl %r14d, 0x4(%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x6af0
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0x6b11
cmpl $0xa, %ecx
je 0x6b11
movb %cl, -0x1(%rdi,%rax)
incq %rax
jmp 0x6afb
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %ebp
negl %ebp
cmovsl %edi, %ebp
jae 0x6b46
xorl %r14d, %r14d
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
movl %ebp, %ecx
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x23, %rdx
incq %r14
cmpl $0x9, %ecx
movl %edx, %ecx
ja 0x6b30
jmp 0x6b4c
movl $0x1, %r14d
movl %ebx, %r15d
shrl $0x1f, %r15d
leaq (%r14,%r15), %rdi
incq %rdi
movl $0x1, %esi
callq 0x65a4
testq %rax, %rax
je 0x6b9e
addq %r15, %r14
je 0x6b95
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %ebp, %edx
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %ebp
orb $0x30, %bpl
movb %bpl, -0x1(%rax,%r14)
movl %edx, %ebp
decq %r14
jne 0x6b73
testl %ebx, %ebx
jns 0x6ba0
movb $0x2d, (%rax)
jmp 0x6ba0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x67c8
testq %rax, %rax
je 0x6cd2
movq %rax, %r15
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
xorl %ebp, %ebp
leaq 0x4422(%rip), %r12      # 0xb004
movq $0x0, 0x8(%rsp)
movl %r14d, 0x14(%rsp)
movq %r15, %r13
movzbl (%r13), %eax
testl %eax, %eax
je 0x6c18
cmpl $0xa, %eax
je 0x6c18
movsbl %al, %esi
movq %r12, %rdi
callq 0x6838
incq %r13
testl %eax, %eax
jne 0x6bf3
jmp 0x6cce
movq %r15, %rdi
callq 0x65e8
movl 0x4(%rsp), %ecx
cmpl $-0x1, %ecx
je 0x6c32
cmpl %eax, %ecx
je 0x6c34
jmp 0x6cce
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c87
movq %rdi, %r14
callq 0x65e8
movl %eax, %r13d
movq %r15, %rdi
callq 0x65e8
addl %r13d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x6af0
movq %r14, %rdi
movl 0x14(%rsp), %r14d
callq 0x6190
movq %r13, %rdi
jmp 0x6ca1
movq %r15, %rdi
callq 0x65e8
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
callq 0x6af0
movq %r15, %rdi
callq 0x6190
incl %ebp
movl %r14d, %edi
callq 0x67c8
movq %rax, %r15
testq %rax, %rax
jne 0x6bf0
jmp 0x6ce5
xorl %eax, %eax
jmp 0x6d4f
movq $0x0, 0x8(%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movl %ebp, %r15d
movl $0x8, %esi
movq %r15, %rdi
callq 0x65a4
movq %rax, 0xc8(%rbx)
testl %ebp, %ebp
je 0x6d30
movslq 0x4(%rsp), %r12
xorl %r14d, %r14d
movq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x6858
movq 0xc8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
addq %r12, %r13
incq %r14
cmpq %r14, %r15
jne 0x6d0d
movl 0x4(%rsp), %eax
movl %eax, 0x128(%rbx)
movl %ebp, 0x12c(%rbx)
movq 0x8(%rsp), %rdi
callq 0x6190
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x6f7c
xorl %ebx, %ebx
testl %eax, %eax
je 0x6dbd
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x63f0
cmpl $-0x1, %eax
je 0x6dbd
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x6bac
movl %eax, %r15d
movl %ebp, %edi
callq 0x6060
testl %r15d, %r15d
je 0x6dbd
movq %r14, %rdi
callq 0x6fb1
testl %eax, %eax
je 0x6dbd
movq %r14, %rdi
callq 0x7010
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x130(%rdi)
jne 0x6efc
testb $0x1, 0x13bf2(%rip)     # 0x1aa18
jne 0x6efc
movb $0x1, 0x13be5(%rip)     # 0x1aa18
movslq 0x12c(%rbx), %r15
testq %r15, %r15
je 0x6efc
movslq 0x128(%rbx), %rcx
leaq 0xd0(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %rcx, %rax
movq %rcx, 0x10(%rsp)
shll $0x6, %eax
addl $-0x40, %eax
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %r12
decq %r15
cmpl $0x0, 0x10(%rsp)
je 0x6ef3
movl %r15d, %ebp
shll $0x6, %ebp
movl 0xc(%rsp), %r13d
movq 0x10(%rsp), %r14
movq 0xc8(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x45, -0x1(%rax,%r14)
jne 0x6ee7
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x3c(%rsp)
movq %r12, %rdi
leaq 0x4157(%rip), %rsi      # 0xb00a
movq %rbx, %rdx
callq 0x6a94
movl 0x3c(%rsp), %edx
movl 0x40(%rsp), %ecx
movl %r13d, %edi
movl %ebp, %esi
callq 0x6a61
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x69b8
movq 0x20(%rsp), %rdi
callq 0x6190
decq %r14
addl $-0x40, %r13d
testq %r14, %r14
jne 0x6e87
testq %r15, %r15
jne 0x6e6d
cmpq $0x0, 0x130(%rbx)
jne 0x6f43
movslq 0xb4(%rbx), %rax
movslq 0x120(%rbx), %rcx
addq %rax, %rcx
movslq 0xb8(%rbx), %rax
movslq 0x124(%rbx), %rdx
addq %rax, %rdx
movq 0xc8(%rbx), %rax
movq (%rax,%rdx,8), %rax
cmpb $0x45, (%rax,%rcx)
jne 0x6f43
movl $0x1, 0x158(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x65e8
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
jl 0x6faf
movl %ecx, %ecx
cmpb $0x72, -0x1(%rbx,%rcx)
jne 0x6faf
cmpb $0x65, -0x2(%rbx,%rcx)
jne 0x6faf
cmpb $0x62, -0x3(%rbx,%rcx)
jne 0x6faf
xorl %eax, %eax
cmpb $0x2e, -0x4(%rbx,%rcx)
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0x128(%rdi), %rcx
movslq 0x12c(%rdi), %rdx
movq 0xc8(%rdi), %rsi
movq %rcx, %rdi
movq %rcx, %r8
xorl %eax, %eax
subq $0x1, %r8
jb 0x6ff1
movq (%rsi), %r9
cmpb $0x31, -0x1(%r9,%rdi)
jne 0x7009
movq -0x8(%rsi,%rdx,8), %r9
cmpb $0x31, -0x1(%r9,%rdi)
movq %r8, %rdi
je 0x6fce
jmp 0x7009
xorl %eax, %eax
subq $0x1, %rdx
jb 0x700a
movq (%rsi,%rdx,8), %rdi
cmpb $0x31, (%rdi)
jne 0x7009
cmpb $0x31, -0x1(%rdi,%rcx)
je 0x6ff3
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0x12c(%rdi), %rax
testq %rax, %rax
je 0x7083
pushq %rbx
movslq 0x128(%rdi), %rsi
xorl %edx, %edx
movl $0x1, %r9d
xorl %r8d, %r8d
xorl %ecx, %ecx
decq %rax
testl %esi, %esi
je 0x7065
movq 0xc8(%rdi), %r10
movq (%r10,%rax,8), %r10
movq %rsi, %r11
movb -0x1(%r10,%r11), %bl
cmpb $0x43, %bl
cmovel %r9d, %edx
cmpb $0x50, %bl
cmovel %r9d, %r8d
cmpb $0x45, %bl
cmovel %r9d, %ecx
decq %r11
jne 0x7046
testq %rax, %rax
jne 0x7031
testl %edx, %edx
setne %al
testl %r8d, %r8d
setne %dl
andb %al, %dl
testl %ecx, %ecx
setne %al
andb %dl, %al
movzbl %al, %eax
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x8270
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x717a
movq %rbx, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x75b2
movl 0x128(%rbx), %eax
cmpl $0xe, %eax
movl $0xe, %esi
cmovll %eax, %esi
movl %esi, 0x148(%rbx)
movl 0x12c(%rbx), %eax
cmpl $0xa, %eax
movl $0xa, %edx
cmovll %eax, %edx
movl %edx, 0x14c(%rbx)
movq (%rbx), %rdi
shll $0x6, %esi
shll $0x6, %edx
leaq 0x3f66(%rip), %rcx      # 0xb052
callq 0x83c0
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x148(%rdi), %ebp
movl 0x14c(%rdi), %r14d
shll $0x6, %ebp
shll $0x6, %r14d
leaq 0xf8(%rdi), %r15
cmpq $0x0, 0xf8(%rdi)
jne 0x713f
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x6ac5
movq %rbx, %rdi
callq 0x76c8
movl 0x120(%rbx), %edi
movl 0x124(%rbx), %esi
shll $0x6, %edi
shll $0x6, %esi
addq $0xd0, %rbx
movl %ebp, %edx
movl %r14d, %ecx
callq 0x6a61
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6915
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x128(%rdi), %rcx
movslq 0x12c(%rdi), %r14
xorl %eax, %eax
movq %rax, 0x120(%rdi)
movq %rax, 0xf8(%rdi)
addq $0xd0, %rdi
movq %rcx, (%rsp)
movl %ecx, %esi
shll $0x6, %esi
movl %r14d, %edx
shll $0x6, %edx
movq %rbx, %rcx
callq 0x6ac5
testq %r14, %r14
je 0x7289
movq %r14, %rdx
movq (%rsp), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rsp)
shll $0x6, %eax
addl $-0x40, %eax
movl %eax, 0x8(%rsp)
decq %rdx
cmpl $0x0, (%rsp)
je 0x7280
movl %edx, %ebp
shll $0x6, %ebp
movl 0x8(%rsp), %r15d
movl 0xc(%rsp), %r12d
movq (%rsp), %r13
movq %rdx, 0x10(%rsp)
movq 0xc8(%rbx), %rax
movq (%rax,%rdx,8), %rax
movzbl -0x1(%rax,%r13), %r14d
cmpl $0x43, %r14d
je 0x723e
cmpl $0x50, %r14d
jne 0x7249
movl %r12d, 0xb4(%rbx)
movq 0x10(%rsp), %rax
movl %eax, 0xb8(%rbx)
jmp 0x7249
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7444
decq %r13
movl $0x30, %edi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x7298
movsbl %r14b, %edi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x7298
decl %r12d
addl $-0x40, %r15d
testq %r13, %r13
movq 0x10(%rsp), %rdx
jne 0x720d
testq %rdx, %rdx
jne 0x71e8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
cmpb $0x45, %dil
leaq 0x3dbb(%rip), %rax      # 0xb070
leaq 0x3da3(%rip), %rsi      # 0xb05f
cmoveq %rax, %rsi
addl $-0x30, %edi
cmpl $0x20, %edi
ja 0x7343
movabsq $0x100080001, %rax      # imm = 0x100080001
btq %rdi, %rax
jae 0x7343
movq 0x13741(%rip), %rax     # 0x1aa20
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
rorq %rcx
movabsq $0xe38e38e38e38e39, %rdx # imm = 0xE38E38E38E38E39
cmpq %rdx, %rcx
jb 0x7332
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
rorq $0x2, %rcx
movabsq $0x924924924924925, %rdx # imm = 0x924924924924925
cmpq %rdx, %rcx
leaq 0x3d72(%rip), %rcx      # 0xb097
leaq 0x3d7d(%rip), %rsi      # 0xb0a9
cmovbq %rcx, %rsi
jmp 0x7339
leaq 0x3d4c(%rip), %rsi      # 0xb085
incq %rax
movq %rax, 0x136dd(%rip)     # 0x1aa20
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6a94
addq $0xd0, %rbx
movl %r14d, %edi
movl %ebp, %esi
movl $0x40, %edx
movl $0x40, %ecx
callq 0x6a61
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69b8
movq (%r15), %rdi
callq 0x6190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/player_config.c
// Function: player_config
void	player_config(t_game *game)
{
	t_data		full_sprite;
	t_player	*player;
	int			i;

	i = 0;
	player = &game->player;
	player->steps = 0;
	full_sprite.w = 144;
	full_sprite.h = 256;
	player->w = 48;
	player->h = 64;
	player->frame = 2;
	load_img(&full_sprite, "./imgs/male.xpm", game);
	while (i < 4)
	{
		create_img(&player->sprites[i], player->w, player->h, game);
		copy_img_from(&player->sprites[i], &full_sprite,
			to_array(0, player->h * i, player->w, player->h));
		i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movl $0x0, 0xbc(%rdi)
movabsq $0x10000000090, %rax    # imm = 0x10000000090
movq %rsp, %r15
movq %rax, 0x1c(%r15)
movabsq $0x4000000030, %rax     # imm = 0x4000000030
movq %rax, 0xc0(%rdi)
movl $0x2, 0xb0(%rdi)
leaq 0x3cdc(%rip), %rsi      # 0xb0bb
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6a94
xorl %r12d, %r12d
movl 0xc0(%rbx), %esi
movl 0xc4(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x6ac5
movl 0xc0(%rbx), %edx
movl 0xc4(%rbx), %ecx
movl %r12d, %esi
imull %ecx, %esi
xorl %edi, %edi
callq 0x6a61
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x6915
incq %r12
addq $0x28, %r14
cmpq $0x4, %r12
jne 0x73ed
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/new_item.c
// Function: new_item
void	new_item(t_game *game, int x, int y)
{
	t_item	*begin;
	t_item	*new_item;

	new_item = (t_item *) ft_calloc(1, sizeof(t_item));
	new_item->x = x;
	new_item->y = y;
	new_item->sprite.w = BLOCK_SIZE;
	new_item->sprite.h = BLOCK_SIZE;
	load_img(&new_item->sprite, "./imgs/item.xpm", game);
	begin = game->items;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_item;
	else
		game->items = new_item;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x1c(%r14)
leaq 0x3c4a(%rip), %rsi      # 0xb0cb
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6a94
movq 0x130(%rbx), %rcx
addq $0x130, %rbx            # imm = 0x130
testq %rcx, %rcx
je 0x74b2
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x749a
addq $0x38, %rax
movq %rax, %rbx
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/enemy_config.c
// Function: new_enemy
void	new_enemy(t_game *game, int x, int y)
{
	t_enemy	*begin;
	t_enemy	*new_enemy;

	new_enemy = (t_enemy *) ft_calloc(1, sizeof(t_enemy));
	new_enemy->x = x;
	new_enemy->y = y;
	new_enemy->sprites[0].w = 80;
	new_enemy->sprites[0].h = 96;
	new_enemy->sprites[1].w = 122;
	new_enemy->sprites[1].h = 103;
	new_enemy->sprites[2].w = 86;
	new_enemy->sprites[2].h = 110;
	load_img(&new_enemy->sprites[0], "./imgs/enemy.xpm", game);
	load_img(&new_enemy->sprites[1], "./imgs/enemy2.xpm", game);
	load_img(&new_enemy->sprites[2], "./imgs/enemy3.xpm", game);
	begin = game->enemies;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_enemy;
	else
		game->enemies = new_enemy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x98, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x80(%rax)
movl %ebp, 0x84(%rax)
movabsq $0x6000000050, %rax     # imm = 0x6000000050
movq %rax, 0x1c(%r14)
leaq 0x28(%r14), %r15
movabsq $0x670000007a, %rax     # imm = 0x670000007A
movq %rax, 0x44(%r14)
leaq 0x50(%r14), %r12
movabsq $0x6e00000056, %rax     # imm = 0x6E00000056
movq %rax, 0x6c(%r14)
leaq 0x3b8f(%rip), %rsi      # 0xb0db
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6a94
leaq 0x3b8e(%rip), %rsi      # 0xb0ec
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6a94
leaq 0x3b8e(%rip), %rsi      # 0xb0fe
movq %r12, %rdi
movq %rbx, %rdx
callq 0x6a94
movq 0x138(%rbx), %rcx
addq $0x138, %rbx            # imm = 0x138
testq %rcx, %rcx
je 0x75a6
movq %rcx, %rax
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0x7589
addq $0x90, %rax
movq %rax, %rbx
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/enemy_config.c
// Function: enemy_config
void	enemy_config(t_game *game)
{
	int		y;
	int		x;
	int		x_holder;
	int		number;

	number = 0;
	y = game->map.h;
	x = game->map.w;
	x_holder = x;
	while (y--)
	{
		while (x--)
		{
			if (check_surround(y, x, game) && number < 10)
			{
				new_enemy(game, x, y);
				number++;
			}
		}
		x = x_holder;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x12c(%rdi), %r14
testq %r14, %r14
je 0x763b
movq %rdi, %rbx
movslq 0x128(%rdi), %r12
leal -0x1(%r12), %eax
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
decq %r14
testl %r12d, %r12d
je 0x7636
movl 0x4(%rsp), %ebp
movq %r12, %r15
movq 0xc8(%rbx), %rax
movq (%rax,%r14,8), %rax
cmpb $0x30, -0x1(%rax,%r15)
jne 0x760c
cmpb $0x43, -0x2(%rax,%r15)
sete %al
jmp 0x760e
xorl %eax, %eax
cmpl $0xa, %r13d
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x762c
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x74e4
incl %r13d
decq %r15
decl %ebp
testq %r15, %r15
jne 0x75ee
testq %r14, %r14
jne 0x75df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/fireball_config.c
// Function: new_fireball
void	new_fireball(t_game *game, int x, int y)
{
	t_fireball	*begin;
	t_fireball	*new_item;

	new_item = (t_fireball *) ft_calloc(1, sizeof(t_fireball));
	new_item->x = x;
	new_item->y = y;
	new_item->sprite.w = 64;
	new_item->sprite.h = 64;
	load_img(&new_item->sprite, "./imgs/fireball/1.xpm", game);
	begin = game->fireballs;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_item;
	else
		game->fireballs = new_item;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x1c(%r14)
leaq 0x3a87(%rip), %rsi      # 0xb110
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6a94
movq 0x140(%rbx), %rcx
addq $0x140, %rbx            # imm = 0x140
testq %rcx, %rcx
je 0x76ba
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x76a2
addq $0x38, %rax
movq %rax, %rbx
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/config/fix_cam.c
// Function: fix_cam
int	fix_cam(t_game *game)
{
	int	x;
	int	y;

	x = 0;
	y = 0;
	while (y + game->height <= game->map.h)
	{
		while (x + game->width <= game->map.w)
		{
			if (player_on_screen(x, y, game))
			{
				game->map.x = x;
				game->map.y = y;
				game->player.x -= x;
				game->player.y -= y;
				return (0);
			}
			x++;
		}
		x = 0;
		y++;
	}
	return (0);
}

// Assembly:
movslq 0x14c(%rdi), %rax
movl 0x12c(%rdi), %ecx
cmpl %ecx, %eax
jg 0x7773
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x148(%rdi), %rsi
movslq 0x128(%rdi), %r8
movq %r8, %r9
subq %rsi, %r9
xorl %edx, %edx
cmpl %r8d, %esi
jle 0x770d
incq %rdx
leal (%rdx,%rax), %r10d
cmpl %ecx, %r10d
jle 0x76fa
jmp 0x776c
leaq (%rdx,%rax), %r11
xorl %r10d, %r10d
testl %eax, %eax
jle 0x7748
leaq (%r10,%rsi), %rbx
movq %rdx, %r14
testl %esi, %esi
jle 0x7740
movq 0xc8(%rdi), %r15
movq (%r15,%r14,8), %r15
movq %r10, %r12
cmpb $0x50, (%r15,%r12)
je 0x7752
incq %r12
cmpq %rbx, %r12
jl 0x7731
incq %r14
cmpq %r11, %r14
jb 0x771f
incq %r10
cmpq %r9, %r10
jle 0x7714
jmp 0x76ff
movl %r10d, 0x120(%rdi)
movl %edx, 0x124(%rdi)
subl %r10d, 0xb4(%rdi)
subl %edx, 0xb8(%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/player_action.c
// Function: player_action
void	player_action(int keycode, t_game *game)
{
	if (keycode == W)
		up(game);
	if (keycode == A)
		left(game);
	if (keycode == S)
		down(game);
	if (keycode == D)
		right(game);
}

// Assembly:
cmpl $0x72, %edi
jg 0x778f
cmpl $0x61, %edi
je 0x77a2
cmpl $0x64, %edi
jne 0x77a1
movq %rsi, %rdi
jmp 0x7c31
cmpl $0x73, %edi
je 0x77aa
cmpl $0x77, %edi
jne 0x77a1
movq %rsi, %rdi
jmp 0x7b24
retq
movq %rsi, %rdi
jmp 0x7bda
movq %rsi, %rdi
jmp 0x7b7b
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/player_action.c
// Function: render_user
void	render_user(t_game *game)
{	
	t_data	*sprite;
	int		x;
	int		y;

	x = game->player.x * BLOCK_SIZE;
	y = game->player.y * BLOCK_SIZE;
	sprite = &game->player.sprites[game->player.frame];
	copy_img_to(&game->map.map, sprite,
		to_array(x, y, game->player.w, game->player.h));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0xb4(%rdi), %eax
movl 0xb8(%rdi), %esi
shll $0x6, %eax
shll $0x6, %esi
movslq 0xb0(%rdi), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rdi,%rcx,8), %rbx
addq $0x10, %rbx
leaq 0xf8(%rdi), %r14
movl 0xc0(%rdi), %edx
movl 0xc4(%rdi), %ecx
movl %eax, %edi
callq 0x6a61
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69b8
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/game_init.c
// Function: game_init
void	game_init(t_game *game)
{
	mlx_loop_hook(game->vars.mlx, frame_update, game);
	mlx_hook(game->vars.win, DestroyNotify, StructureNotifyMask, close_game, game);
	mlx_hook(game->vars.win, KeyPress, KeyPressMask, key_hook, game);
	mlx_loop(game->vars.mlx);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x4b(%rip), %rsi        # 0x7891
movq %rbx, %rdx
callq 0x86c0
movq 0x8(%rbx), %rdi
leaq 0x112(%rip), %rcx       # 0x796b
movl $0x11, %esi
movl $0x20000, %edx          # imm = 0x20000
movq %rbx, %r8
callq 0xa0f0
movq 0x8(%rbx), %rdi
leaq 0x10c(%rip), %rcx       # 0x7982
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0xa0f0
movq (%rbx), %rdi
popq %rbx
jmp 0x8550
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/game_init.c
// Function: frame_update
static int	frame_update(t_game *game)
{
	static int	screen;
	char		*count;

	if (game->game_over)
	{
		if (!screen)
			print_over(game);
		screen = 1;
		return (1);
	}
	if (game->win)
	{
		if (!screen)
			print_screen(game);
		screen = 1;
		return (1);
	}
	get_active_map(game);
	render_user(game);
	render_enemies(game);
	render_items(game);
	render_fireball(game);
	check_exit(game);
	mlx_put_image_to_window(game->vars.mlx, game->vars.win,
		game->map.map.img, 0, 0);
	count = ft_itoa(game->player.steps);
	mlx_string_put(game->vars.mlx, game->vars.win, (game->width * BLOCK_SIZE) - 20\
		, 20, 0xF35C00, count
	);
	free(count);
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x154(%rdi)
je 0x78b4
cmpb $0x0, 0x13180(%rip)     # 0x1aa28
jne 0x78ce
movq %rbx, %rdi
callq 0x7f48
jmp 0x78ce
cmpl $0x0, 0x158(%rbx)
je 0x78e2
cmpb $0x0, 0x13164(%rip)     # 0x1aa28
jne 0x78ce
movq %rbx, %rdi
callq 0x7fd5
movb $0x1, 0x13153(%rip)     # 0x1aa28
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x70f8
movq %rbx, %rdi
callq 0x77b2
movq %rbx, %rdi
callq 0x7cc2
movq %rbx, %rdi
callq 0x79cc
movq %rbx, %rdi
callq 0x7e60
movq %rbx, %rdi
callq 0x6e00
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8d90
movl 0xbc(%rbx), %edi
callq 0x6b14
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movl 0x148(%rbx), %edx
shll $0x6, %edx
addl $-0x14, %edx
movl $0x14, %ecx
movl $0xf35c00, %r8d         # imm = 0xF35C00
movq %rax, %r9
callq 0x88a0
movq %r14, %rdi
callq 0x6190
jmp 0x78d5
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/game_init.c
// Function: key_hook
static int	key_hook(int keycode, t_game *game)
{
	if (game->game_over || game->win)
		return (1);
	player_action(keycode, game);
	if (keycode == ESC)
		close_game(game);
	return (1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x154(%rsi)
jne 0x79ac
movq %rsi, %rbx
cmpl $0x0, 0x158(%rsi)
jne 0x79ac
movl %edi, %ebp
movq %rbx, %rsi
callq 0x7778
cmpl $0xff1b, %ebp           # imm = 0xFF1B
je 0x79b8
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x9e00
xorl %edi, %edi
callq 0x60c0
nop
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/item_action.c
// Function: render_items
void	render_items(t_game *game)
{
	t_item	*item;
	t_item	*last_one;
	int		x;
	int		y;

	item = game->items;
	last_one = 0;
	while (item)
	{
		if (is_on_map(item->x, item->y, game))
		{
			x = (item->x - game->map.x) * BLOCK_SIZE;
			y = (item->y - game->map.y) * BLOCK_SIZE;
			if (item_collision(item->x, item->y, game))
			{
				free_item(last_one, item, game);
				if (!last_one)
					last_one = game->items;
				if (!last_one)
					break ;
				item = last_one->next;
				continue ;
			}	
			copy_img_to(&game->map.map, &item->sprite,
				to_array(x, y + item->frame, BLOCK_SIZE, BLOCK_SIZE));
			item_animation(item);
		}
		last_one = item;
		item = item->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x130(%rdi), %r15
testq %r15, %r15
je 0x7b17
movq %rdi, %rbx
leaq 0x130(%rdi), %r12
leaq 0xf8(%rdi), %r14
xorl %r13d, %r13d
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7c90
testl %eax, %eax
je 0x7b07
movl 0x28(%r15), %edi
movl 0x2c(%r15), %eax
movl 0x120(%rbx), %ecx
movl 0x124(%rbx), %edx
movl 0xb4(%rbx), %esi
addl %ecx, %esi
cmpl %edi, %esi
jne 0x7a79
movl 0xb8(%rbx), %esi
addl %edx, %esi
cmpl %eax, %esi
jne 0x7a79
leaq 0x38(%r13), %rax
testq %r13, %r13
movq 0x38(%r15), %rcx
cmoveq %r12, %rax
movq %rcx, (%rax)
movq (%r15), %rdi
callq 0x6190
movq %r15, %rdi
callq 0x6190
testq %r13, %r13
jne 0x7a68
movq (%r12), %r13
movq %r13, %r15
testq %r13, %r13
jne 0x7b07
jmp 0x7b17
subl %edx, %eax
shll $0x6, %eax
subl %ecx, %edi
shll $0x6, %edi
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss 0x30(%r15), %xmm0
cvttss2si %xmm0, %esi
movl $0x40, %edx
movl $0x40, %ecx
callq 0x6a61
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69b8
cmpl $0x0, 0x34(%r15)
movss 0x30(%r15), %xmm0
je 0x7ad4
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7ae7
cvtss2sd %xmm0, %xmm0
addsd 0x3656(%rip), %xmm0     # 0xb128
jmp 0x7afd
ucomiss 0x365d(%rip), %xmm0     # 0xb138
jbe 0x7af1
movl $0x1, 0x34(%r15)
jmp 0x7b07
movl $0x0, 0x34(%r15)
jmp 0x7b07
cvtss2sd %xmm0, %xmm0
addsd 0x3633(%rip), %xmm0     # 0xb130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%r15)
movq %r15, %r13
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x79f9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/moviments.c
// Function: up
void	up(t_game *game)
{
	if (check_mov(game, 0, -1))
	{
		if (game->map.y > 0 && game->player.y < (game->height) / 2)
			game->map.y -= 1;
		else
			game->player.y -= 1;
		game->player.steps += 1;
	}
	game->player.frame = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6dcc
testl %eax, %eax
je 0x7b6f
movl 0x124(%rbx), %eax
testl %eax, %eax
jle 0x7b63
movl 0x14c(%rbx), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, 0xb8(%rbx)
jge 0x7b63
decl %eax
movl %eax, 0x124(%rbx)
jmp 0x7b69
decl 0xb8(%rbx)
incl 0xbc(%rbx)
movl $0x0, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/moviments.c
// Function: down
void	down(t_game *game)
{
	if (check_mov(game, 0, 1))
	{
		if (game->map.y < game->map.h - game->height \
			&& game->player.y > game->height / 2)
			game->map.y += 1;
		else
			game->player.y += 1;
		game->player.steps += 1;
	}
	game->player.frame = 2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x1, %edx
callq 0x6dcc
testl %eax, %eax
je 0x7bce
movl 0x124(%rbx), %eax
movl 0x12c(%rbx), %edx
movl 0x14c(%rbx), %ecx
subl %ecx, %edx
cmpl %edx, %eax
jge 0x7bc2
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, 0xb8(%rbx)
jle 0x7bc2
incl %eax
movl %eax, 0x124(%rbx)
jmp 0x7bc8
incl 0xb8(%rbx)
incl 0xbc(%rbx)
movl $0x2, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/moviments.c
// Function: left
void	left(t_game *game)
{
	if (check_mov(game, -1, 0))
	{
		if (game->map.x > 0 && game->player.x < (game->width) / 2)
			game->map.x -= 1;
		else
			game->player.x -= 1;
		game->player.steps += 1;
	}
	game->player.frame = 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6dcc
testl %eax, %eax
je 0x7c25
movl 0x120(%rbx), %eax
testl %eax, %eax
jle 0x7c19
movl 0x148(%rbx), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, 0xb4(%rbx)
jge 0x7c19
decl %eax
movl %eax, 0x120(%rbx)
jmp 0x7c1f
decl 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x3, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/moviments.c
// Function: right
void	right(t_game *game)
{
	if (check_mov(game, 1, 0))
	{
		if ((game->map.x < game->map.w - game->width) \
			&& game->player.x > game->width / 2
		)
			game->map.x += 1;
		else
			game->player.x += 1;
		game->player.steps += 1;
	}
	game->player.frame = 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x6dcc
testl %eax, %eax
je 0x7c84
movl 0x120(%rbx), %eax
movl 0x128(%rbx), %edx
movl 0x148(%rbx), %ecx
subl %ecx, %edx
cmpl %edx, %eax
jge 0x7c78
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, 0xb4(%rbx)
jle 0x7c78
incl %eax
movl %eax, 0x120(%rbx)
jmp 0x7c7e
incl 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x1, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/alsmd[P]so_long/src/actions/enemy_action.c
// Function: render_enemies
void	render_enemies(t_game *game)
{
	t_enemy	*enemy;

	enemy = game->enemies;
	while (enemy)
	{
		if (is_on_map(enemy->x, enemy->y, game))
		{
			draw_enemy(enemy, game);
		}
		enemy_animation(game, enemy);
		enemy = enemy->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x138(%rdi), %r12
testq %r12, %r12
je 0x7e55
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
xorl %ebp, %ebp
movl 0x80(%r12), %eax
movl 0x120(%rbx), %ecx
movl %eax, %edi
subl %ecx, %edi
jl 0x7d0c
movl 0x148(%rbx), %edx
addl %ecx, %edx
movl $0x1, %r8d
cmpl %eax, %edx
jg 0x7d0f
xorl %r8d, %r8d
movl 0x84(%r12), %edx
movl 0x124(%rbx), %esi
cmpl %esi, %edx
jl 0x7d30
movl 0x14c(%rbx), %r9d
addl %esi, %r9d
cmpl %edx, %r9d
jg 0x7d33
xorl %r8d, %r8d
testl %r8d, %r8d
je 0x7db5
incl %eax
cmpl %eax, %ecx
jg 0x7d4e
addl 0x148(%rbx), %ecx
movl $0x1, %r8d
cmpl %eax, %ecx
jg 0x7d51
xorl %r8d, %r8d
movl %edx, %eax
subl %esi, %eax
jl 0x7d61
addl 0x14c(%rbx), %esi
cmpl %edx, %esi
jg 0x7d64
xorl %r8d, %r8d
movslq 0x7c(%r12), %rcx
testl %r8d, %r8d
je 0x7d79
leaq (%rcx,%rcx,4), %rdx
movl 0x1c(%r12,%rdx,8), %edx
jmp 0x7d7e
movl $0x40, %edx
shll $0x6, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
subss 0x78(%r12), %xmm0
cvttss2si %xmm0, %esi
shll $0x6, %edi
leaq (%rcx,%rcx,4), %rax
leaq (%r12,%rax,8), %r15
movl 0x20(%r15), %ecx
callq 0x6a61
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69b8
cmpl $0x0, 0x88(%r12)
movss 0x78(%r12), %xmm0
je 0x7ddd
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7df4
cvtss2sd %xmm0, %xmm0
addsd 0x334d(%rip), %xmm0     # 0xb128
jmp 0x7e39
ucomiss 0x3354(%rip), %xmm0     # 0xb138
jbe 0x7e2d
movl $0x1, 0x88(%r12)
jmp 0x7e44
movl 0x7c(%r12), %eax
movl 0x80(%r12), %esi
leal 0x1(%rax), %ecx
cmpl $0x2, %eax
cmovgel %ebp, %ecx
movl %ecx, 0x7c(%r12)
movl 0x84(%r12), %edx
movq %rbx, %rdi
callq 0x764c
movl $0x0, 0x88(%r12)
jmp 0x7e44
cvtss2sd %xmm0, %xmm0
addsd 0x32f7(%rip), %xmm0     # 0xb130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x78(%r12)
movq 0x90(%r12), %r12
testq %r12, %r12
jne 0x7ce6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop