LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::list<std::string> ft::split(const std::string& str, const std::string& charset)
{
	std::list<std::string> ret;

	size_t i = str.find_first_not_of(charset, 0);
	while (i < str.size())
	{
		size_t word_start = i;
		i = str.find_first_of(charset, i);
		size_t word_end = i;
		i = str.find_first_not_of(charset, i);
		ret.push_back(str.substr(word_start, word_end - word_start));
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x13880
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x9580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fa07
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x95f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9580
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
subq %rdx, %rcx
leaq -0x58(%rbp), %rdi
callq 0x96b0
jmp 0x2f9c5
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13930
jmp 0x2f9d4
leaq -0x58(%rbp), %rdi
callq 0x9c98
jmp 0x2f950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2fa27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c98
jmp 0x2fa27
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2fa1a
movq -0x78(%rbp), %rdi
callq 0xceb0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xceb0
movq -0x60(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const&)
std::list<std::string> ft::split(const std::string& str, const char &needle)
{
	std::list<std::string> ret;

	size_t i = str.find_first_not_of(needle, 0);
	while (i < str.size())
	{
		size_t word_start = i;
		i = str.find_first_of(needle, i);
		size_t word_end = i;
		i = str.find_first_not_of(needle, i);
		ret.push_back(str.substr(word_start, word_end - word_start));
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x13880
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x9600
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fb40
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x9450
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x9600
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
subq %rdx, %rcx
leaq -0x58(%rbp), %rdi
callq 0x96b0
jmp 0x2fafe
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13930
jmp 0x2fb0d
leaq -0x58(%rbp), %rdi
callq 0x9c98
jmp 0x2fa83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2fb60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c98
jmp 0x2fb60
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2fb53
movq -0x78(%rbp), %rdi
callq 0xceb0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xceb0
movq -0x60(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_directory(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return S_ISDIR(st.st_mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x9c70
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x31e9f
leaq -0x100(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x31f00
movq -0x120(%rbp), %rsi
leaq 0x38c5c(%rip), %rdx     # 0x6aa58
leaq -0xe0(%rbp), %rdi
callq 0x13970
jmp 0x31e0a
movq -0x118(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x14140
jmp 0x31e26
movq -0x118(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x97e0
leaq -0xc0(%rbp), %rdi
callq 0x9c98
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x31e9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x31e91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x31eeb
movq -0x118(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x9c10
cmpl $0x0, %eax
jge 0x31ec5
movb $0x0, -0x1(%rbp)
jmp 0x31edd
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x9af0
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::get_cwd[abi:cxx11]()
std::string ft::get_cwd()
{
	std::string cwd;
	char *buf = getcwd(NULL, 0);
	if (buf == NULL)
		return "";
	cwd += buf;
	free(buf);
	return cwd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x98c0
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x9380
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x31f83
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x9b10
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x38e1d(%rip), %rsi     # 0x6ad70
callq 0xa780
jmp 0x31f5a
leaq -0x31(%rbp), %rdi
callq 0x9700
movl $0x1, -0x48(%rbp)
jmp 0x31fbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x9700
jmp 0x31fd2
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9650
jmp 0x31f92
movq -0x30(%rbp), %rdi
callq 0x97c0
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9410
movl $0x1, -0x48(%rbp)
jmp 0x31fbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x31fd2
leaq -0x28(%rbp), %rdi
callq 0x9c98
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x9c98
movq -0x40(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_regular_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_regular_file(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return S_ISREG(st.st_mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x9c70
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x320df
leaq -0x100(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x31f00
movq -0x120(%rbp), %rsi
leaq 0x38a1c(%rip), %rdx     # 0x6aa58
leaq -0xe0(%rbp), %rdi
callq 0x13970
jmp 0x3204a
movq -0x118(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x14140
jmp 0x32066
movq -0x118(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x97e0
leaq -0xc0(%rbp), %rdi
callq 0x9c98
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x320df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x320d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x3212b
movq -0x118(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x9c10
cmpl $0x0, %eax
jge 0x32105
movb $0x0, -0x1(%rbp)
jmp 0x3211d
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x9af0
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_executable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_executable(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return st.st_mode & S_IXUSR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x9c70
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x3222f
leaq -0x100(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x31f00
movq -0x120(%rbp), %rsi
leaq 0x388cc(%rip), %rdx     # 0x6aa58
leaq -0xe0(%rbp), %rdi
callq 0x13970
jmp 0x3219a
movq -0x118(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x14140
jmp 0x321b6
movq -0x118(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x97e0
leaq -0xc0(%rbp), %rdi
callq 0x9c98
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x3222f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x32221
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x9c98
leaq -0x100(%rbp), %rdi
callq 0x9c98
jmp 0x32277
movq -0x118(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x9c10
cmpl $0x0, %eax
jge 0x32255
movb $0x0, -0x1(%rbp)
jmp 0x32269
movl -0x88(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::strncpy(char*, char const*, unsigned long)
char	*ft::strncpy(char *dest, const char *src, size_t n)
{
	size_t i;

	for (i = 0; i < n && src[i] != '\0'; i++)
		dest[i] = src[i];
	for ( ; i < n; i++)
		dest[i] = '\0';
	return (dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x3284c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x32855
jmp 0x32879
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32828
jmp 0x3287b
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3289f
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3287b
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::memset(void*, int, unsigned long)
void	*ft::memset(void *s, int c, size_t n)
{
	unsigned char	*start;

	start = (unsigned char*)s;
	while (n > 0)
	{
		*start++ = c;
		n--;
	}
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x328f2
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x328c7
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::~Factory()
virtual ~Factory()
		{
			if (_elements.empty())
				return;
			for (typename std::list<value_type>::iterator it = _elements.begin(); it != _elements.end(); it++)
				delete *it;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x4927d(%rip), %rax     # 0x8ec68
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x46920
testb $0x1, %al
jne 0x45a01
jmp 0x45a0a
movl $0x1, -0xc(%rbp)
jmp 0x45a79
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x46940
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x469a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x46970
testb $0x1, %al
jne 0x45a3f
jmp 0x45a72
leaq -0x18(%rbp), %rdi
callq 0x469d0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x45a5f
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x45a61
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x46a00
movq %rax, -0x28(%rbp)
jmp 0x45a1b
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x46a30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/incs/Utils/Utils.hpp
// Function: bool ft::is_integer<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool						is_integer(const std::string& str)
	{
		if (str.size() == 0)
			return false;

		size_t res = 0;
		for (size_t i = (str[0] == '-' || str[0] == '+'); i < str.size(); i++)
		{
			if (!std::isdigit(str[i]))
				return false;
			res = res * 10 + (str[i] - '0');
			if ((str[0] != '-' && res > static_cast<unsigned int>(std::numeric_limits<IntegralType>::max())) ||
				(str[0] == '-' && res > static_cast<unsigned int>(std::numeric_limits<IntegralType>::min() * -1)))
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
cmpq $0x0, %rax
jne 0x45b94
movb $0x0, -0x1(%rbp)
jmp 0x45cca
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9720
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x21(%rbp)
je 0x45bcf
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x2b, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x45cc6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9720
movsbl (%rax), %edi
callq 0x95e0
cmpl $0x0, %eax
jne 0x45c1f
movb $0x0, -0x1(%rbp)
jmp 0x45cca
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9720
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsbl (%rcx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x45c7b
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x46cb0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
ja 0x45cad
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x45cb3
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x46cc0
movl %eax, %ecx
movq -0x48(%rbp), %rax
imull $-0x1, %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x45cb3
movb $0x0, -0x1(%rbp)
jmp 0x45cca
jmp 0x45cb5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x45bdb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::operator=(ConfigContext const&)
ConfigContext& ConfigContext::operator=(const ConfigContext& other)
{
	_params = other._params;
	_error_pages = other._error_pages;
	_autoIndex = other._autoIndex;
	_directive_names = other._directive_names;
	_childs = other._childs;
	_names = other._names;
	_acceptedMethods = other._acceptedMethods;
	_cgi_exts = other._cgi_exts;
	_uploads_exts = other._uploads_exts;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x4d600
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x4d630
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x110(%rax), %al
andb $0x1, %al
movb %al, 0x110(%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x4d660
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rdi
callq 0x4d6c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x98, %rsi
addq $0x98, %rdi
callq 0x4d660
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xb0, %rsi
addq $0xb0, %rdi
callq 0x4d720
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
addq $0xc8, %rdi
callq 0x4d780
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xf8, %rsi
addq $0xf8, %rdi
callq 0x4d660
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::handle_parent_and_directives(ConfigContext const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::handle_parent_and_directives(const ConfigContext* parent, const std::string& name)
{
	if (parent != NULL)
	{
		_params = parent->_params;
		_error_pages = parent->_error_pages;
		_autoIndex = parent->_autoIndex;
		_acceptedMethods = parent->_acceptedMethods;
		_cgi_exts = parent->_cgi_exts;
		_uploads_exts = parent->_uploads_exts;
		_names.push_back(name);
	}
	else
	{
		// Directives réservées aux contexts server{}
		add_server_directives();
		for (std::list<IMethod*>::const_iterator it = g_webserv.methods.getRegistered().begin(); it != g_webserv.methods.getRegistered().end(); it++)
			_acceptedMethods.push_back(*it);
	}
	add_location_directives();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4899d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x4d600
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x4d630
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x110(%rax), %al
andb $0x1, %al
movb %al, 0x110(%rdi)
movq -0x10(%rbp), %rsi
addq $0xb0, %rsi
addq $0xb0, %rdi
callq 0x4d720
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
addq $0xc8, %rdi
callq 0x4d780
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xf8, %rsi
addq $0xf8, %rdi
callq 0x4d660
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x4db90
jmp 0x48a27
movq -0x38(%rbp), %rdi
callq 0x4bca0
leaq 0x46d73(%rip), %rdi     # 0x8f720
addq $0x68, %rdi
callq 0x4dbd0
movq %rax, %rdi
callq 0x4dbf0
movq %rax, -0x20(%rbp)
leaq 0x46d57(%rip), %rdi     # 0x8f720
addq $0x68, %rdi
callq 0x4dbd0
movq %rax, %rdi
callq 0x4dc50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4dc20
testb $0x1, %al
jne 0x489f1
jmp 0x48a25
movq -0x38(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4dcc0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4dc80
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4dcf0
movq %rax, -0x30(%rbp)
jmp 0x489c2
jmp 0x48a27
movq -0x38(%rbp), %rdi
callq 0x4be80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::find_closing_bracket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
size_t ConfigContext::find_closing_bracket(const std::string& str, size_t start) const
{
	size_t nesting = 1;

	for (size_t i = start; i < str.size(); i++)
	{
		if (str[i] == '{')
			nesting++;
		if (str[i] == '}')
			nesting--;
		if (nesting == 0)
			return i;
	}
	return size_t(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x48ae4
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x48aa2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x48ac3
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x48ad4
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48aec
jmp 0x48ad6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x48a64
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_server_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_server_name(const std::string& directive_value)
{
	for (size_t j = 0; j < directive_value.size();)
	{
		std::string name = directive_value.substr(j, directive_value.find_first_of(" \t\n", j) - j);
		j = directive_value.find_first_of(" \t\n", j);
		_names.push_back(name);

		// Si on est arrivé au dernier mot de la directive, on arrête
		if (j >= directive_value.size() || directive_value[j] == '\n')
			break;
		j = directive_value.find_first_not_of(" \t\n", j);
		if (j >= directive_value.size())
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x48c64
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x18(%rbp), %rdx
movq %rdx, -0x70(%rbp)
leaq 0x2310c(%rip), %rsi     # 0x6bc67
movq %rsi, -0x68(%rbp)
callq 0x9360
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x96b0
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x9360
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, -0x18(%rbp)
addq $0x98, %rdi
callq 0x4db90
jmp 0x48bae
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x48be0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9720
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x48c00
movl $0x2, -0x48(%rbp)
jmp 0x48c4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c98
jmp 0x48c6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x23058(%rip), %rsi     # 0x6bc67
callq 0x93f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jb 0x48c44
movl $0x2, -0x48(%rbp)
jmp 0x48c4b
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c98
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x48c5f
jmp 0x48c5d
jmp 0x48c64
jmp 0x48b23
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_autoindex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_autoindex(const std::string& directive_value)
{
	std::list<std::string> words = ft::split(directive_value, " \t\n");
	std::string val = words.front();

	if (val != "on" && val != "off")
		throw std::invalid_argument("Bad value for autoindex in config");
	_autoIndex = (val == "on" ? true : false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x9b10
movq -0x88(%rbp), %rdx
leaq 0x22ba0(%rip), %rsi     # 0x6bc67
leaq -0x48(%rbp), %rdi
callq 0xa780
jmp 0x490d2
movq -0x90(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2f910
jmp 0x490e8
leaq -0x48(%rbp), %rdi
callq 0x9c98
leaq -0x49(%rbp), %rdi
callq 0x9700
leaq -0x28(%rbp), %rdi
callq 0xcd40
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x92c0
jmp 0x49111
leaq 0x2101f(%rip), %rsi     # 0x6a137
leaq -0x80(%rbp), %rdi
callq 0xce40
movb %al, -0x99(%rbp)
jmp 0x49129
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x49138
jmp 0x4920a
leaq 0x22b48(%rip), %rsi     # 0x6bc87
leaq -0x80(%rbp), %rdi
callq 0xce40
movb %al, -0x9a(%rbp)
jmp 0x49150
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0x4915f
jmp 0x4920a
movl $0x10, %edi
callq 0x9340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
leaq 0x241bd(%rip), %rsi     # 0x6d33a
callq 0x9be0
jmp 0x49184
movq -0xa8(%rbp), %rdi
movq 0x45e36(%rip), %rsi     # 0x8efc8
movq 0x45e1f(%rip), %rdx     # 0x8efb8
callq 0x9aa0
jmp 0x49273
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x491c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9c98
leaq -0x49(%rbp), %rdi
callq 0x9700
jmp 0x4926a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x49261
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x49258
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x94c0
jmp 0x49258
leaq 0x20f26(%rip), %rsi     # 0x6a137
leaq -0x80(%rbp), %rdi
callq 0xdf50
movb %al, -0xa9(%rbp)
jmp 0x49222
movq -0x98(%rbp), %rax
movb -0xa9(%rbp), %cl
andb $0x1, %cl
negb %cl
andb $0x1, %cl
movb %cl, 0x110(%rax)
leaq -0x80(%rbp), %rdi
callq 0x9c98
leaq -0x28(%rbp), %rdi
callq 0xceb0
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x9c98
leaq -0x28(%rbp), %rdi
callq 0xceb0
movq -0x58(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::getConfigPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const ConfigContext& ConfigContext::getConfigPath(const std::string& path) const
{
	for (std::list<ConfigContext>::const_iterator it = _childs.begin(); it != _childs.end(); it++)
	{
		if (it->getNames().front() == path.substr(0, std::min(path.size(), it->getNames().front().size())))
			return *it;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x50, %rdi
callq 0x4e370
movq %rax, -0x20(%rbp)
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
callq 0x4e3d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4e3a0
testb $0x1, %al
jne 0x4d34f
jmp 0x4d40e
leaq -0x20(%rbp), %rdi
callq 0x4e400
movq %rax, %rdi
callq 0x4c690
movq %rax, %rdi
callq 0x14310
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4e400
movq %rax, %rdi
callq 0x4c690
movq %rax, %rdi
callq 0x14310
movq %rax, %rdi
callq 0x9480
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22650
movq -0x80(%rbp), %rsi
movq (%rax), %rcx
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x96b0
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x144e0
movb %al, -0x69(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9c98
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4d3e9
jmp 0x4d3f8
leaq -0x20(%rbp), %rdi
callq 0x4e430
movq %rax, -0x8(%rbp)
jmp 0x4d416
jmp 0x4d3fa
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4e450
movq %rax, -0x60(%rbp)
jmp 0x4d328
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::can_be_uploaded(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool	ConfigContext::can_be_uploaded(const std::string& extension) const
{
	if (_uploads_exts.empty())
		return false;
	if (_uploads_exts.front() == "all")
		return true;
	if (ft::contains(_uploads_exts, extension))
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xf8, %rdi
callq 0xcc10
testb $0x1, %al
jne 0x4d45a
jmp 0x4d460
movb $0x0, -0x1(%rbp)
jmp 0x4d4af
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
callq 0x14310
movq %rax, %rdi
leaq 0x1fd0f(%rip), %rsi     # 0x6d189
callq 0xdf50
testb $0x1, %al
jne 0x4d485
jmp 0x4d48b
movb $0x1, -0x1(%rbp)
jmp 0x4d4af
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
movq -0x18(%rbp), %rsi
callq 0x4d7b0
testb $0x1, %al
jne 0x4d4a5
jmp 0x4d4ab
movb $0x1, -0x1(%rbp)
jmp 0x4d4af
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<IMethod*>::getByType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
value_type getByType(const std::string& type) const
		{
			for (typename std::list<value_type>::const_iterator it = _elements.begin(); it != _elements.end(); it++)
				if ((*it)->getType() == type)
					return *it;
			return NULL;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
callq 0x4dbf0
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x4dc50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4dc20
testb $0x1, %al
jne 0x4df49
jmp 0x4dfa9
leaq -0x20(%rbp), %rdi
callq 0x4dcc0
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x10(%rax)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x144e0
movb %al, -0x59(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9c98
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x4df81
jmp 0x4df93
leaq -0x20(%rbp), %rdi
callq 0x4dcc0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4dfb1
jmp 0x4df95
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4dcf0
movq %rax, -0x50(%rbp)
jmp 0x4df25
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/tcp-server.cpp
// Function: string_to_hex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string string_to_hex(const std::string& input)
{
    static const char hex_digits[] = "0123456789ABCDEF";

    std::string output;
    output.reserve(input.length() * 2);
	for(std::string::size_type i = 0; i < input.size(); ++i)
    {
        output.push_back(hex_digits[input[i] >> 4]);
        output.push_back(hex_digits[input[i] & 15]);
		output.push_back(' ');
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x98c0
movq -0x10(%rbp), %rdi
callq 0x9960
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x99b0
jmp 0x56aee
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x56ba5
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movq -0x38(%rbp), %rdi
movsbl (%rax), %eax
sarl $0x4, %eax
cltq
leaq 0x169a9(%rip), %rcx     # 0x6d4e0
movsbl (%rax,%rcx), %esi
callq 0x95a0
jmp 0x56b42
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movq -0x38(%rbp), %rdi
movzbl (%rax), %eax
andl $0xf, %eax
leaq 0x16980(%rip), %rcx     # 0x6d4e0
movsbl (%rax,%rcx), %esi
callq 0x95a0
jmp 0x56b6b
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x95a0
jmp 0x56b7b
jmp 0x56b7d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x56af6
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9c98
jmp 0x56bc2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x56bb8
movq -0x38(%rbp), %rdi
callq 0x9c98
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9af0
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/tcp-server.cpp
// Function: string_strip_undisplayable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string string_strip_undisplayable(const std::string& input)
{
    std::string output;
    output.reserve(input.length());
	for(std::string::size_type i = 0; i < input.size(); ++i)
    {
        if (std::isprint(input[i]))
			output.push_back(input[i]);
		else
			output.push_back(' ');
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x98c0
movq -0x10(%rbp), %rdi
callq 0x9960
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x99b0
jmp 0x56c0b
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x56ca3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movsbl (%rax), %edi
callq 0x9b00
cmpl $0x0, %eax
je 0x56c7e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9720
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x95a0
jmp 0x56c65
jmp 0x56c90
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9c98
jmp 0x56cc0
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x95a0
jmp 0x56c8e
jmp 0x56c90
jmp 0x56c92
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x56c13
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x56cb6
movq -0x38(%rbp), %rdi
callq 0x9c98
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::append(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Request::append(const std::string& raw)
{
	if (_finished_parsing)
		return false;
	_raw += raw;
	parse();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x192(%rax)
je 0x5dc37
movb $0x0, -0x1(%rbp)
jmp 0x5dc55
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x9830
movq -0x20(%rbp), %rdi
callq 0x5dc60
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::parse_uri()
void Request::parse_uri()
{
	if (_raw.find(' ', _parse_start + 1) != std::string::npos)
	{
		std::string urlRaw = _raw.substr(_parse_start + 1, _raw.find(' ', _parse_start + 1) - (_parse_start + 1));;
		if (!is_valid_URI(urlRaw))
		{
			_error_code = 400;
			throw std::invalid_argument("Bad URI format in request.");
		}
		_url = URL(urlRaw);
		_parse_start = _raw.find(' ', _parse_start + 1);
		_url_finished = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movq 0x198(%rax), %rdx
addq $0x1, %rdx
movl $0x20, %esi
callq 0x9860
cmpq $-0x1, %rax
je 0x5f050
movq -0x130(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, -0x150(%rbp)
movq 0x198(%rax), %rdx
incq %rdx
movq %rdx, -0x148(%rbp)
movl $0x20, %esi
callq 0x9860
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rdx
movq -0x130(%rbp), %rcx
movq 0x198(%rcx), %rcx
notq %rcx
addq %rax, %rcx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x96b0
movq -0x130(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x60890
movb %al, -0x131(%rbp)
jmp 0x5ef1d
movb -0x131(%rbp), %al
testb $0x1, %al
jne 0x5efb0
jmp 0x5ef2d
movq -0x130(%rbp), %rax
movl $0x190, 0x188(%rax)     # imm = 0x190
movl $0x10, %edi
callq 0x9340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x158(%rbp)
leaq 0xebd6(%rip), %rsi      # 0x6db32
callq 0x9be0
jmp 0x5ef63
movq -0x158(%rbp), %rdi
movq 0x30057(%rip), %rsi     # 0x8efc8
movq 0x30040(%rip), %rdx     # 0x8efb8
callq 0x9aa0
jmp 0x5f062
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5f045
movq -0x158(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x94c0
jmp 0x5f045
leaq -0x128(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2e3a0
jmp 0x5efc2
movq -0x130(%rbp), %rdi
addq $0x30, %rdi
leaq -0x128(%rbp), %rsi
callq 0x2eef0
jmp 0x5efdb
leaq -0x128(%rbp), %rdi
callq 0x2efd0
movq -0x130(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x198(%rax), %rdx
addq $0x1, %rdx
movl $0x20, %esi
callq 0x9860
movq %rax, %rcx
movq -0x130(%rbp), %rax
movq %rcx, 0x198(%rax)
movb $0x1, 0x191(%rax)
leaq -0x28(%rbp), %rdi
callq 0x9c98
jmp 0x5f050
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x2efd0
leaq -0x28(%rbp), %rdi
callq 0x9c98
jmp 0x5f059
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::is_valid_URI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool Request::is_valid_URI(const std::string& uri) const
{
	if (uri.size() > 8000)
		return false;

	if (_method->allowAbsolutePath())
		if (uri[0] == '/')
			return true;

	if (_method->allowCompleteURL())
		if (uri.size() > 7 && uri.substr(0, 7) == "http://")
			return true;

	if (_method->allowAuthorityURI())
		return true;

	if (_method->allowAsteriskURI())
		if (uri == "*")
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
cmpq $0x1f40, %rax           # imm = 0x1F40
jbe 0x608c2
movb $0x0, -0x1(%rbp)
jmp 0x609fa
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x608d6
jmp 0x608f6
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9720
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x608f4
movb $0x1, -0x1(%rbp)
jmp 0x609fa
jmp 0x608f6
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x6090d
jmp 0x609aa
movq -0x18(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movb $0x0, -0x39(%rbp)
xorl %eax, %eax
cmpq $0x7, %rcx
movb %al, -0x59(%rbp)
jbe 0x60963
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x7, %ecx
callq 0x96b0
movq -0x68(%rbp), %rdi
movb $0x1, -0x39(%rbp)
leaq 0xa528(%rip), %rsi      # 0x6ae79
callq 0xdf50
movb %al, -0x5a(%rbp)
jmp 0x6095b
movb -0x5a(%rbp), %al
movb %al, -0x59(%rbp)
jmp 0x60963
movb -0x59(%rbp), %al
movb %al, -0x69(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x60971
jmp 0x6097a
leaq -0x38(%rbp), %rdi
callq 0x9c98
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x60983
jmp 0x609a8
movb $0x1, -0x1(%rbp)
jmp 0x609fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x6099d
jmp 0x609a6
leaq -0x38(%rbp), %rdi
callq 0x9c98
jmp 0x60a05
jmp 0x609aa
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x609be
jmp 0x609c4
movb $0x1, -0x1(%rbp)
jmp 0x609fa
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x609d8
jmp 0x609f6
movq -0x18(%rbp), %rdi
leaq 0x9df4(%rip), %rsi      # 0x6a7d7
callq 0xdf50
testb $0x1, %al
jne 0x609ee
jmp 0x609f4
movb $0x1, -0x1(%rbp)
jmp 0x609fa
jmp 0x609f6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9af0
nop
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::count_concurrent_occurences(unsigned long, char) const
size_t Request::count_concurrent_occurences(size_t index, char c) const
{
	size_t cnt = 0;
	while (_raw[index + cnt] == c)
		cnt++;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0x9720
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x60de3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x60db5
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::getHeaderValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string	Request::getHeaderValue(const std::string& name) const
{
	for (Request::HeadersVector::const_iterator header_it = _headers.begin(); header_it != _headers.end(); header_it++)
		if ((*header_it)->getType() == name)
		{
			return (*header_it)->getValue().substr(0, std::min((*header_it)->getValue().find(':'), (*header_it)->getValue().size()));
			break;
		}
	return ("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x14440
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x144b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14470
testb $0x1, %al
jne 0x60e5a
jmp 0x60f35
leaq -0x20(%rbp), %rdi
callq 0x14570
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x10(%rax)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x144e0
movb %al, -0x91(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9c98
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x60e9b
jmp 0x60f1f
leaq -0x20(%rbp), %rdi
callq 0x14570
movq (%rax), %rdi
callq 0xbf40
movq %rax, -0xa0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x14570
movq (%rax), %rdi
callq 0xbf40
movq %rax, %rdi
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9860
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x14570
movq (%rax), %rdi
callq 0xbf40
movq %rax, %rdi
callq 0x9480
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22650
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq (%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x96b0
jmp 0x60f83
jmp 0x60f21
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x14590
movq %rax, -0x60(%rbp)
jmp 0x60e30
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9b10
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x9e16(%rip), %rsi      # 0x6ad70
callq 0xa780
jmp 0x60f61
leaq -0x61(%rbp), %rdi
callq 0x9700
jmp 0x60f83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x9700
jmp 0x60f93
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Request.cpp
// Function: Request::operator=(Request const&)
Request& Request::operator=(const Request& other)
{
	_raw = other._raw;
	_method = other._method;
	_url = other._url;
	_protocolVersion = other._protocolVersion;
	_body = other._body;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rdi)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x2eef0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
addq $0x120, %rdi            # imm = 0x120
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x158, %rsi            # imm = 0x158
addq $0x158, %rdi            # imm = 0x158
callq 0x9070
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::createByType_ignore_case(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
value_type createByType_ignore_case(const std::string& type) const
		{
			for (typename std::list<value_type>::const_iterator it = _elements.begin(); it != _elements.end(); it++)
				if (compare_type_lowercase((*it)->getType(), type))
					return (*it)->clone();
			return NULL;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
callq 0x628d0
movq %rax, -0x20(%rbp)
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x62930
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x62900
testb $0x1, %al
jne 0x61715
jmp 0x617d3
leaq -0x20(%rbp), %rdi
callq 0x62a30
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x92c0
jmp 0x6173d
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x62960
movb %al, -0x89(%rbp)
jmp 0x61759
leaq -0x68(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x61777
jmp 0x617bd
leaq -0x20(%rbp), %rdi
callq 0x62a30
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, -0x8(%rbp)
jmp 0x617db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x617b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
jmp 0x617e8
jmp 0x617bf
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x62a60
movq %rax, -0x80(%rbp)
jmp 0x616eb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)