LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: my_inet_ntoa[abi:cxx11](in_addr)
static std::string		my_inet_ntoa(struct in_addr in)
{
	std::stringstream ss;
	unsigned char *bytes = reinterpret_cast<unsigned char *>(&in);
	ss << static_cast<int>(bytes[0]) << "." << static_cast<int>(bytes[1]) << "." << static_cast<int>(bytes[2]) << "." << static_cast<int>(bytes[3]);
	return (ss.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x9490
leaq -0xc(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x188(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movzbl (%rax), %esi
callq 0x9ad0
movq %rax, -0x1b8(%rbp)
jmp 0x1c689
movq -0x1b8(%rbp), %rdi
leaq 0x51359(%rip), %rsi     # 0x6d9f0
callq 0x9670
movq %rax, -0x1d0(%rbp)
jmp 0x1c6a5
movq -0x1d0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x9ad0
movq %rax, -0x1d8(%rbp)
jmp 0x1c6c5
movq -0x1d8(%rbp), %rdi
leaq 0x5131d(%rip), %rsi     # 0x6d9f0
callq 0x9670
movq %rax, -0x1e0(%rbp)
jmp 0x1c6e1
movq -0x1e0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movzbl 0x2(%rax), %esi
callq 0x9ad0
movq %rax, -0x1e8(%rbp)
jmp 0x1c701
movq -0x1e8(%rbp), %rdi
leaq 0x512e1(%rip), %rsi     # 0x6d9f0
callq 0x9670
movq %rax, -0x1f0(%rbp)
jmp 0x1c71d
movq -0x1f0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movzbl 0x3(%rax), %esi
callq 0x9ad0
jmp 0x1c736
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9660
jmp 0x1c74b
leaq -0x198(%rbp), %rdi
callq 0x94e0
movq -0x1c0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x94e0
movq -0x1a8(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool					Socket::Connect(std::string const &host, int const port)
{
	if (!this->Success())
		return (false);
	this->m_addr_in.sin_family = AF_INET;
	if (!my_inet_aton(host.c_str(), &this->m_addr_in.sin_addr))
		return (false);
	this->m_addr_in.sin_port = htons(port);
	if (connect(this->m_sockfd, reinterpret_cast<sockaddr*>(&this->m_addr_in), sizeof(this->m_addr_in)) != 0)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1c410
testb $0x1, %al
jne 0x1c7ca
movb $0x0, -0x1(%rbp)
jmp 0x1c82f
movq -0x28(%rbp), %rax
movw $0x2, 0x2c(%rax)
movq -0x18(%rbp), %rdi
callq 0x92b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x2c, %rsi
addq $0x4, %rsi
callq 0x1c840
cmpl $0x0, %eax
jne 0x1c7fc
movb $0x0, -0x1(%rbp)
jmp 0x1c82f
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x9090
movq -0x28(%rbp), %rsi
movw %ax, 0x2e(%rsi)
movl 0x28(%rsi), %edi
addq $0x2c, %rsi
movl $0x10, %edx
callq 0x9570
cmpl $0x0, %eax
je 0x1c82b
movb $0x0, -0x1(%rbp)
jmp 0x1c82f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Listen() const
bool					Socket::Listen(void) const
{
	if (!this->Success())
		return (false);
	if (listen(this->m_sockfd, MAX_CONNECTIONS) == -1)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1c410
testb $0x1, %al
jne 0x1cb13
movb $0x0, -0x1(%rbp)
jmp 0x1cb33
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x9740
cmpl $-0x1, %eax
jne 0x1cb2f
movb $0x0, -0x1(%rbp)
jmp 0x1cb33
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Accept(Socket&)
bool					Socket::Accept(Socket &connection)
{
	int	addr_length = sizeof(this->m_addr_in);
	connection.m_sockfd = accept(this->m_sockfd, reinterpret_cast<sockaddr *>(&this->m_addr_in), reinterpret_cast<socklen_t*>(&addr_length));
	if (connection.m_sockfd <= 0)
		return (false);
	connection.m_ipaddr = my_inet_ntoa(this->m_addr_in.sin_addr);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movl $0x10, -0x1c(%rbp)
movl 0x28(%rsi), %edi
addq $0x2c, %rsi
leaq -0x1c(%rbp), %rdx
callq 0x9210
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jg 0x1cb88
movb $0x0, -0x1(%rbp)
jmp 0x1cbbc
movq -0x50(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x1c630
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x97e0
leaq -0x40(%rbp), %rdi
callq 0x9c98
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Recieve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int						Socket::Recieve(std::string &str) const
{
	char	buff[MAX_RECIEVE + 1];

	str = "";
	ft::bzero(buff, MAX_RECIEVE + 1);
	int ret = recv(this->m_sockfd, buff, MAX_RECIEVE, 0);
	switch (ret)
	{
	case -1:
		return (Logger::print("Error in Socket::Recieve", 0, ERROR, NORMAL));
	case 0:
		return (0);
	default:
		str = buff;
		return (ret);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10080, %rsp          # imm = 0x10080
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10070(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4e117(%rip), %rsi     # 0x6ad70
callq 0x98a0
leaq -0x10020(%rbp), %rdi
movq %rdi, -0x10068(%rbp)
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x32900
movq -0x10070(%rbp), %rax
movq -0x10068(%rbp), %rsi
movl 0x28(%rax), %edi
movl $0xfffe, %edx           # imm = 0xFFFE
xorl %ecx, %ecx
callq 0x9220
movl %eax, -0x10024(%rbp)
movl -0x10024(%rbp), %eax
movl %eax, -0x10060(%rbp)
subl $-0x1, %eax
je 0x1ccbf
jmp 0x1ccac
movl -0x10060(%rbp), %eax
testl %eax, %eax
je 0x1cd71
jmp 0x1cd7a
leaq -0x10049(%rbp), %rdi
movq %rdi, -0x10078(%rbp)
callq 0x9b10
movq -0x10078(%rbp), %rdx
leaq 0x4dd04(%rip), %rsi     # 0x6a9e4
leaq -0x10048(%rbp), %rdi
callq 0xa780
jmp 0x1ccee
leaq -0x10048(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x1cdd0
movl %eax, -0x1007c(%rbp)
jmp 0x1cd0e
movl -0x1007c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x10048(%rbp), %rdi
callq 0x9c98
leaq -0x10049(%rbp), %rdi
callq 0x9700
jmp 0x1cd93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10058(%rbp)
movl %eax, -0x1005c(%rbp)
jmp 0x1cd63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10058(%rbp)
movl %eax, -0x1005c(%rbp)
leaq -0x10048(%rbp), %rdi
callq 0x9c98
leaq -0x10049(%rbp), %rdi
callq 0x9700
jmp 0x1cd9f
movl $0x0, -0x4(%rbp)
jmp 0x1cd93
leaq -0x10020(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x98a0
movl -0x10024(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10080, %rsp          # imm = 0x10080
popq %rbp
retq
movq -0x10058(%rbp), %rdi
callq 0x9af0
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Credentials()
Credentials::Credentials()
{
	try
	{
		for (std::list<VirtualHost>::iterator it = g_webserv.vhosts.begin(); it != g_webserv.vhosts.end(); it++)
		{
			const std::string	&path = it->getConfig().getParam("auth_basic_user_file").front();
			if (!path.empty() && !Is_Cache_Uptodate(path))
				Parse_user_file(path);
		}
	}
	catch (std::exception& e) {}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x23940
leaq 0x6c61d(%rip), %rdi     # 0x8f720
addq $0xa8, %rdi
callq 0x23960
movq %rax, -0x10(%rbp)
leaq 0x6c606(%rip), %rdi     # 0x8f720
addq $0xa8, %rdi
callq 0x239c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23990
testb $0x1, %al
jne 0x23140
jmp 0x2327e
leaq -0x10(%rbp), %rdi
callq 0x239f0
movq %rax, %rdi
callq 0x66920
movq %rax, -0x78(%rbp)
jmp 0x23157
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9b10
movq -0x80(%rbp), %rdx
leaq 0x47b9a(%rip), %rsi     # 0x6ad09
leaq -0x50(%rbp), %rdi
callq 0xa780
jmp 0x2317a
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4c710
movq %rax, -0x88(%rbp)
jmp 0x23190
movq -0x88(%rbp), %rdi
callq 0x14310
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9c98
leaq -0x51(%rbp), %rdi
callq 0x9700
movq -0x90(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a50
testb $0x1, %al
jne 0x23268
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x232a0
movb %al, -0x91(%rbp)
jmp 0x231e6
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x23268
jmp 0x231f2
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x233a0
jmp 0x23201
jmp 0x23268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2323d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x23234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9c98
leaq -0x51(%rbp), %rdi
callq 0x9700
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2328c
movq -0x28(%rbp), %rdi
callq 0x92a0
movq %rax, -0x68(%rbp)
callq 0x9a40
jmp 0x2325d
jmp 0x2325f
addq $0xa0, %rsp
popq %rbp
retq
jmp 0x2326a
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x23a20
movq %rax, -0x60(%rbp)
jmp 0x23113
jmp 0x2325f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x70(%rbp), %rdi
callq 0x23a50
movq -0x28(%rbp), %rdi
callq 0x9af0
nop
// File: mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Is_Cache_Uptodate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool						Credentials::Is_Cache_Uptodate(const std::string &path) const
{
	struct stat 			stats;
	if (lstat(path.c_str(), &stats) < 0)
		return (false);
	for (std::list<Authentication_file>::const_iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (path == it->file_path && it->last_modified == stats.st_mtime)
			return (true);
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92b0
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9c10
cmpl $0x0, %eax
jge 0x232e4
movb $0x0, -0x1(%rbp)
jmp 0x2338b
movq -0xc8(%rbp), %rdi
callq 0x23cc0
movq %rax, -0xb0(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x23d20
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x23cf0
testb $0x1, %al
jne 0x23323
jmp 0x23387
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23d50
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x144e0
testb $0x1, %al
jne 0x2334f
jmp 0x2336b
leaq -0xb0(%rbp), %rdi
callq 0x23d50
movq 0x38(%rax), %rax
cmpq -0x50(%rbp), %rax
jne 0x2336b
movb $0x1, -0x1(%rbp)
jmp 0x2338b
jmp 0x2336d
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x23d70
movq %rax, -0xc0(%rbp)
jmp 0x232f7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Update_user_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void						Credentials::Update_user_file(const std::string &path)
{
	for (std::list<Authentication_file>::iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (it->file_path == path)
			it = m_credentials.erase(it);
	Parse_user_file(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x23b70
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rdi
callq 0x23bd0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23ba0
testb $0x1, %al
jne 0x23701
jmp 0x23755
leaq -0x18(%rbp), %rdi
callq 0x23c00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x144e0
testb $0x1, %al
jne 0x2371c
jmp 0x23742
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23c70
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x23c20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x23744
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x23c90
movq %rax, -0x38(%rbp)
jmp 0x236e1
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x233a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Is_Cached(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool						Credentials::Is_Cached(const std::string &path) const
{
	for (std::list<Authentication_file>::const_iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (path == it->file_path)
			return (true);
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x23cc0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x23d20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23cf0
testb $0x1, %al
jne 0x237b1
jmp 0x237ed
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x23d50
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x144e0
testb $0x1, %al
jne 0x237d4
jmp 0x237da
movb $0x1, -0x1(%rbp)
jmp 0x237f1
jmp 0x237dc
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x23d70
movq %rax, -0x30(%rbp)
jmp 0x23791
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Check_Credentials(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&)
bool						Credentials::Check_Credentials(const std::string &path, const std::string &credentials)
{
	if (!Is_Cache_Uptodate(path))
		Update_user_file(path);
	for (std::list<Authentication_file>::iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
	{
		if (path == it->file_path)
			for (std::vector<std::string>::iterator ita = it->content.begin(); ita != it->content.end(); ita++)
			{
				if (credentials == *ita)
					return (true);
			}
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rsi
callq 0x232a0
testb $0x1, %al
jne 0x23836
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x236c0
movq -0x58(%rbp), %rdi
callq 0x23b70
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
callq 0x23bd0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23ba0
testb $0x1, %al
jne 0x23866
jmp 0x23925
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23c00
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x144e0
testb $0x1, %al
jne 0x2388c
jmp 0x2390f
leaq -0x28(%rbp), %rdi
callq 0x23c00
movq %rax, %rdi
addq $0x20, %rdi
callq 0x22460
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23c00
movq %rax, %rdi
addq $0x20, %rdi
callq 0x222e0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23da0
testb $0x1, %al
jne 0x238d1
jmp 0x2390d
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x22bd0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x144e0
testb $0x1, %al
jne 0x238f4
jmp 0x238fa
movb $0x1, -0x1(%rbp)
jmp 0x23929
jmp 0x238fc
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x23de0
movq %rax, -0x48(%rbp)
jmp 0x238a5
jmp 0x2390f
jmp 0x23911
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x23c90
movq %rax, -0x50(%rbp)
jmp 0x23843
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::HashTable(unsigned int)
HashTable::HashTable(unsigned int size) : m_size(size), m_hashdepth(4)
{
	if (!m_size)//Y U DO DIS
		this->m_size = 1;
	this->m_table = new t_hnode*[m_size];
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		this->m_table[i] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x4, 0xc(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x25e35
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x25e97
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25e6e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::HashTable(unsigned int, unsigned int)
HashTable::HashTable(unsigned int size, unsigned int hashdepth) : m_size(size), m_hashdepth(hashdepth)
{
	if (!m_size)
		m_size = 1;
	if (!m_hashdepth)
		m_hashdepth = 4;
	this->m_table = new t_hnode*[m_size];
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		this->m_table[i] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x25ed7
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x25eec
movq -0x20(%rbp), %rax
movl $0x4, 0xc(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x25f4e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25f25
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::~HashTable()
HashTable::~HashTable()
{
	t_hnode *node;
	t_hnode *tmp;
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		node = this->m_table[i];
		while (node != NULL)
		{
			tmp = node;
			node = node->next;
			delete tmp;
		}
	}
	delete [] this->m_table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x25fe8
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25fdb
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x25fd9
movq -0x30(%rbp), %rdi
callq 0x26540
movq -0x30(%rbp), %rdi
movl $0x48, %esi
callq 0x9690
jmp 0x25f99
jmp 0x25fdd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x25f7b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x26002
movq -0x38(%rbp), %rdi
callq 0x9840
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint32_t				HashTable::Hash(std::string const &str) const
{
	uint32_t					hash = 0;
	unsigned int				j = this->m_hashdepth;
	std::string::const_iterator	it = str.begin();

	while (it != str.end() && j)// one_at_a_time hash
	{
		hash += *it++;
		hash += hash << 10;
		hash ^= hash >> 6;
		j--;
	}
	hash += hash << 3;
	hash ^= hash >> 11;
	hash += hash << 15;
	return (hash % this->m_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9640
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9bd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16ee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x2606a
jmp 0x26074
cmpl $0x0, -0x18(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2607d
jmp 0x260c1
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x26570
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x172a0
movsbl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0xa, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26042
movq -0x38(%rbp), %rcx
movl -0x14(%rbp), %eax
shll $0x3, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0xb, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0xf, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Insert(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&)
bool					HashTable::Insert(std::string const &key, std::string const &value)
{
	if (key.empty() || value.empty() || this->GetNode(key))
		return (false);
	t_hnode 		*newnode;
	unsigned int	index = this->Hash(key);

	newnode = new t_hnode;
	newnode->key = key;
	newnode->value = value;
	newnode->next = this->m_table[index];
	this->m_table[index] = newnode;
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9a50
testb $0x1, %al
jne 0x26149
movq -0x20(%rbp), %rdi
callq 0x9a50
testb $0x1, %al
jne 0x26149
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x261d0
cmpq $0x0, %rax
je 0x2614f
movb $0x0, -0x1(%rbp)
jmp 0x261c3
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26010
movl %eax, -0x2c(%rbp)
movl $0x48, %edi
callq 0x9680
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x265b0
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x9070
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x9070
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movl -0x2c(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, 0x40(%rcx)
movq -0x28(%rbp), %rdx
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::GetNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
t_hnode*				HashTable::GetNode(std::string const &key) const
{
	t_hnode *node = this->m_table[this->Hash(key)];
	while (node != NULL && node->key != key)
		node = node->next;
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26010
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x26220
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ab80
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x26229
jmp 0x26237
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x26204
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool					HashTable::Delete(std::string const &key)
{
	unsigned int index = this->Hash(key);
	t_hnode *node = this->m_table[index];
	t_hnode *prevnode = NULL;

	while (node != NULL && node->key != key)
	{
		prevnode = node;
		node = prevnode->next;
	}
	if (node != NULL && node->key == key)
	{
		if (prevnode == NULL)
		{
			prevnode = node;
			this->m_table[index] = node->next;
			delete prevnode;
		}
		else
		{
			prevnode->next = node->next;
			delete node;
		}
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26010
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
je 0x262ac
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ab80
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x262b5
jmp 0x262cb
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x26290
cmpq $0x0, -0x20(%rbp)
je 0x26371
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x144e0
testb $0x1, %al
jne 0x262ec
jmp 0x26371
cmpq $0x0, -0x28(%rbp)
jne 0x26338
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x26336
movq -0x40(%rbp), %rdi
callq 0x26540
movq -0x40(%rbp), %rdi
movl $0x48, %esi
callq 0x9690
jmp 0x2636f
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x2636d
movq -0x48(%rbp), %rdi
callq 0x26540
movq -0x48(%rbp), %rdi
movl $0x48, %esi
callq 0x9690
jmp 0x2636f
jmp 0x26371
xorl %eax, %eax
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Print() const
void					HashTable::Print(void) const
{
	t_hnode *node;
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		node = this->m_table[i];
		if (node != NULL)
			std::cout << i << ":\n\t";
		while (node != NULL)
		{
			std::cout << node->key << "=" << node->value << " ";
			node = node->next;
		}
		if (!node)
			std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x26461
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x263e2
movl -0x14(%rbp), %esi
movq 0x68bda(%rip), %rdi     # 0x8efa8
callq 0x9870
movq %rax, %rdi
leaq 0x44941(%rip), %rsi     # 0x6ad1e
callq 0x9670
jmp 0x263e4
cmpq $0x0, -0x10(%rbp)
je 0x26437
movq -0x10(%rbp), %rsi
movq 0x68bb2(%rip), %rdi     # 0x8efa8
callq 0x95d0
movq %rax, %rdi
leaq 0x44656(%rip), %rsi     # 0x6aa5b
callq 0x9670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x95d0
movq %rax, %rdi
leaq 0x475b0(%rip), %rsi     # 0x6d9d4
callq 0x9670
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x263e4
cmpq $0x0, -0x10(%rbp)
jne 0x26451
movq 0x68b63(%rip), %rdi     # 0x8efa8
movq 0x68b34(%rip), %rsi     # 0x8ef80
callq 0x96d0
jmp 0x26453
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2639b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string &		HashTable::Lookup(std::string const &key) const
{
	t_hnode *node = this->m_table[this->Hash(key)];
	while (node != NULL && node->key != key)
		node = node->next;
	if (node == NULL)
		throw HashTable::HashTableException();
	return (node->value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26010
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
je 0x264c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ab80
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x264c9
jmp 0x264d7
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x264a4
cmpq $0x0, -0x18(%rbp)
jne 0x26527
movl $0x28, %edi
callq 0x9340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x265e0
jmp 0x264f9
movq -0x40(%rbp), %rdi
leaq 0x686c4(%rip), %rsi     # 0x8ebc8
leaq 0x165(%rip), %rdx       # 0x26670
callq 0x9aa0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x94c0
jmp 0x26535
movq -0x18(%rbp), %rax
addq $0x20, %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9af0
nop
// File: mbourand[P]webserv/srcs/Utils/Sighandler.cpp
// Function: sig_int(int)
static void	sig_int(int sig)
{
	(void)sig;
	signal(SIGINT, SIG_IGN);
	std:: cout << "\b\b" << std::flush;
	Logger::print("Interrupt signal was caught.", NULL, WARNING, SILENT);
	g_webserv.run = false;
	signal(SIGINT, &sig_int);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x97b0
movq 0x687b7(%rip), %rdi     # 0x8efa8
leaq 0x44576(%rip), %rsi     # 0x6ad6e
callq 0x9670
movq %rax, %rdi
movq 0x687a9(%rip), %rsi     # 0x8efb0
callq 0x96d0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9b10
movq -0x48(%rbp), %rdx
leaq 0x4454d(%rip), %rsi     # 0x6ad71
leaq -0x28(%rbp), %rdi
callq 0xa780
jmp 0x2682f
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x138a0
jmp 0x26845
leaq -0x28(%rbp), %rdi
callq 0x9c98
leaq -0x29(%rbp), %rdi
callq 0x9700
leaq 0x68ec2(%rip), %rax     # 0x8f720
movb $0x0, (%rax)
movl $0x2, %edi
leaq -0x9d(%rip), %rsi       # 0x267d0
callq 0x97b0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2689b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9c98
leaq -0x29(%rbp), %rdi
callq 0x9700
movq -0x38(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::Threadpool(unsigned int)
Threadpool::Threadpool(unsigned int numworkers) : m_numworkers(numworkers), m_maxqueuedjobs(100)
{
	if (!m_numworkers)
		return;
	Logger::print("Populating Threadpool with workers...", NULL, INFO, SILENT);
	m_workers.reserve(m_numworkers);
	pthread_mutex_init(&m_jobsmutex, NULL);
	for (unsigned int it = 0; it < m_numworkers; it++)
	{
		pthread_t *new_thread = new pthread_t;
		pthread_create(new_thread, NULL, worker_entry, this);
		pthread_detach(*new_thread);
		m_workers.push_back(new_thread);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x26f90
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0x26fb0
jmp 0x268e9
movq -0x68(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x70(%rbp)
callq 0x26fd0
movq -0x68(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x80(%rax)
movq $0x64, 0xb0(%rax)
cmpl $0x0, 0x80(%rax)
jne 0x26931
jmp 0x26a4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x26a6a
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x9b10
movq -0x78(%rbp), %rdx
leaq 0x44445(%rip), %rsi     # 0x6ad8e
leaq -0x40(%rbp), %rdi
callq 0xa780
jmp 0x26954
xorl %edx, %edx
movl %edx, %esi
leaq -0x40(%rbp), %rdi
movl $0x2, %ecx
callq 0x138a0
jmp 0x26968
leaq -0x40(%rbp), %rdi
callq 0x9c98
leaq -0x41(%rbp), %rdi
callq 0x9700
movq -0x68(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, %esi
callq 0x26ff0
jmp 0x2698d
movq -0x68(%rbp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9950
movl $0x0, -0x48(%rbp)
movq -0x68(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl 0x80(%rcx), %eax
jae 0x26a4f
movl $0x8, %edi
callq 0x9680
movq %rax, -0x80(%rbp)
jmp 0x269cb
movq -0x68(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x70e(%rip), %rdx       # 0x270f0
xorl %eax, %eax
movl %eax, %esi
callq 0x9b60
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x94b0
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x27110
jmp 0x26a06
jmp 0x26a08
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x269a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x26a36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9c98
leaq -0x41(%rbp), %rdi
callq 0x9700
jmp 0x26a58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x26a58
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x27180
movq -0x58(%rbp), %rdi
callq 0x271a0
movq -0x60(%rbp), %rdi
callq 0x27210
movq -0x18(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::~Threadpool()
Threadpool::~Threadpool()
{
	if (!m_numworkers)
		return;
	while (m_currentjobs.size())
		usleep(1);
	for (unsigned int it = 0; it < m_numworkers; it++)
		delete m_workers[it];
	Client *job;
	while (m_jobs.size() && (job = m_jobs.back()))
	{
		delete job->req;
		delete job;
		m_jobs.pop_back();
	}
	pthread_mutex_destroy(&m_jobsmutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x80(%rax)
jne 0x26aa9
movl $0x1, -0xc(%rbp)
jmp 0x26bbd
jmp 0x26aab
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x27270
cmpq $0x0, %rax
je 0x26acc
movl $0x1, %edi
callq 0x98d0
jmp 0x26aca
jmp 0x26aab
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x80(%rcx), %eax
jae 0x26b18
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x272a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26b0b
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x9690
jmp 0x26b0d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26ad3
jmp 0x26b1a
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x272c0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x26b53
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x272f0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x26b5c
jmp 0x26ba6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x26b78
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x26b94
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0x9690
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x27330
jmp 0x26b1a
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x9790
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x27180
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x271a0
movq -0x20(%rbp), %rdi
callq 0x27210
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xaa90
nop
// File: mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::operator=(Threadpool const&)
Threadpool &				Threadpool::operator=(Threadpool const &rhs)
{
	if ( this != &rhs )
	{
		this->m_numworkers = rhs.m_numworkers;
		this->m_workers = rhs.m_workers;
		this->m_jobs = rhs.m_jobs;
		this->m_jobsmutex = rhs.m_jobsmutex;
		this->m_maxqueuedjobs = rhs.m_maxqueuedjobs;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x26c76
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, 0x80(%rdi)
movq -0x10(%rbp), %rsi
callq 0x27390
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x275e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x88, %rsi
addq $0x88, %rdi
movl $0x28, %edx
callq 0x9560
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xb0(%rcx), %rcx
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::AddJob(Client&)
bool					Threadpool::AddJob(Client &client)
{
	if (!m_numworkers || (m_jobs.size() > m_maxqueuedjobs))
		return(handle_server_response(client));
	Client *threaded_client = new Client;
	threaded_client->sckt = client.sckt;
	Lock();
	threaded_client->req = client.req;
	client.req = new Request(client.sckt->getServerPort());
	m_jobs.push_front(threaded_client);
	Unlock();
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x80(%rax)
je 0x26d3b
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x272c0
movq -0x38(%rbp), %rcx
cmpq 0xb0(%rcx), %rax
jbe 0x26d4e
movq -0x18(%rbp), %rdi
callq 0x57460
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x26df8
movl $0x10, %edi
callq 0x9680
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
callq 0x26c80
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x9680
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1c160
movl %eax, -0x3c(%rbp)
jmp 0x26da2
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdi
callq 0x5da30
jmp 0x26db0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27790
movq -0x38(%rbp), %rdi
callq 0x26cc0
movb $0x0, -0x1(%rbp)
jmp 0x26df8
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x1a0, %esi            # imm = 0x1A0
callq 0x9690
jmp 0x26e03
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::WaitForWork(void*)
void					*Threadpool::WaitForWork(void *)
{
	while (g_webserv.run)
	{
		Lock();
		if (!g_webserv.run)
			return NULL;
		if (m_jobs.size())
		{
			Client *job = m_jobs.back();
			m_jobs.pop_back();
			m_currentjobs.push_back(job);
			Unlock();
			handle_server_response(*job);
			Lock();
			m_currentjobs.remove(job);
			delete job->req;
			delete job;
			Unlock();
		}
		else
		{
			Unlock();
			usleep(100 * m_numworkers);
		}
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x688f1(%rip), %rax     # 0x8f720
testb $0x1, (%rax)
je 0x26f30
movq -0x28(%rbp), %rdi
callq 0x26c80
leaq 0x688d8(%rip), %rax     # 0x8f720
testb $0x1, (%rax)
jne 0x26e5a
movq $0x0, -0x8(%rbp)
jmp 0x26f38
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x272c0
cmpq $0x0, %rax
je 0x26f12
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x272f0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x27330
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
leaq -0x20(%rbp), %rsi
callq 0x277f0
movq -0x28(%rbp), %rdi
callq 0x26cc0
movq -0x20(%rbp), %rdi
callq 0x57460
movq -0x28(%rbp), %rdi
callq 0x26c80
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27830
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x26eeb
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x26f07
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x9690
movq -0x28(%rbp), %rdi
callq 0x26cc0
jmp 0x26f2b
movq -0x28(%rbp), %rdi
callq 0x26cc0
movq -0x28(%rbp), %rax
imull $0x64, 0x80(%rax), %edi
callq 0x98d0
jmp 0x26e28
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::operator=(URL const&)
URL& URL::operator=(const URL& other)
{
	_scheme = other._scheme;
	_userinfo = other._userinfo;
	_host = other._host;
	_port = other._port;
	_path = other._path;
	_query = other._query;
	_fragment = other._fragment;
	_is_directory = other._is_directory;
	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), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x88, %rsi
addq $0x88, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa8, %rsi
addq $0xa8, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
addq $0xc8, %rdi
callq 0x9070
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0xe8(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xe8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::parse_userinfo(unsigned long&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void URL::parse_userinfo(size_t& i, const std::string& url)
{
	std::string authority = url.substr(i, std::min(url.find('/', i), url.size()) - i);

	if (authority.find('@') == 0)
		throw std::invalid_argument("@ delimiter is present but no user info was given in uri");
	if (!ft::contains(authority, '@'))
	{
		_userinfo = "";
		return;
	}
	_userinfo = authority.substr(0, authority.find('@'));
	i += _userinfo.size() + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x2f, %esi
callq 0x9860
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x22650
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq (%rax), %rcx
movq -0x10(%rbp), %rax
subq (%rax), %rcx
leaq -0x38(%rbp), %rdi
callq 0x96b0
leaq -0x38(%rbp), %rdi
movl $0x40, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9860
cmpq $0x0, %rax
jne 0x2f1a9
movl $0x10, %edi
callq 0x9340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0x3bceb(%rip), %rsi     # 0x6ae40
callq 0x9be0
jmp 0x2f15c
movq -0xa0(%rbp), %rdi
movq 0x5fe5e(%rip), %rsi     # 0x8efc8
movq 0x5fe47(%rip), %rdx     # 0x8efb8
callq 0x9aa0
jmp 0x2f29a
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x94c0
jmp 0x2f288
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2f288
movb $0x40, -0x55(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x55(%rbp), %rsi
callq 0x143d0
movb %al, -0xa1(%rbp)
jmp 0x2f1c2
movb -0xa1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f1d0
jmp 0x2f1f5
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
leaq 0x3bb8e(%rip), %rsi     # 0x6ad70
callq 0x98a0
jmp 0x2f1e9
movl $0x1, -0x5c(%rbp)
jmp 0x2f276
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x40, %esi
callq 0x9860
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq %rax, %rcx
leaq -0x80(%rbp), %rdi
callq 0x96b0
jmp 0x2f231
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
leaq -0x80(%rbp), %rsi
callq 0x97e0
leaq -0x80(%rbp), %rdi
callq 0x9c98
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
callq 0x9480
movq %rax, %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c98
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x9c98
movq -0x50(%rbp), %rdi
callq 0x9af0
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::toInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int ft::toInt(const std::string& str)
{
	for (size_t i = 0; i < str.size(); ++i)
		if (!std::isdigit(str[i]))
			throw std::invalid_argument("String is not an integer");

	std::istringstream iss(str);
	int ret = 0;
	iss >> ret;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x1b0(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f367
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9720
movsbl (%rax), %edi
callq 0x95e0
cmpl $0x0, %eax
jne 0x2f354
movl $0x10, %edi
callq 0x9340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
leaq 0x3c29e(%rip), %rsi     # 0x6b5b4
callq 0x9be0
jmp 0x2f31d
movq -0x1b8(%rbp), %rdi
movq 0x5fc9d(%rip), %rsi     # 0x8efc8
movq 0x5fc86(%rip), %rdx     # 0x8efb8
callq 0x9aa0
movq -0x1b8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x94c0
jmp 0x2f3e1
jmp 0x2f356
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f2b7
movq -0x8(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movl $0x8, %edx
callq 0x9a60
movq -0x1c0(%rbp), %rdi
movl $0x0, -0x1a4(%rbp)
leaq -0x1a4(%rbp), %rsi
callq 0x9440
jmp 0x2f3a2
movl -0x1a4(%rbp), %eax
movl %eax, -0x1c4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x9310
movl -0x1c4(%rbp), %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x9310
movq -0x18(%rbp), %rdi
callq 0x9af0
nopw (%rax,%rax)
// File: mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::hexToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int			ft::hexToInt(const std::string& str)
{
	unsigned int out;
    std::stringstream ss;
    ss << std::hex << str;
    ss >> out;
	return (static_cast<int>(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x9490
leaq -0x188(%rbp), %rdi
leaq 0x3527(%rip), %rsi      # 0x32db0
callq 0x9240
movq %rax, -0x1b0(%rbp)
jmp 0x2f897
movq -0x1b0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x95d0
jmp 0x2f8a9
leaq -0x198(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x90d0
jmp 0x2f8bb
movl -0xc(%rbp), %eax
movl %eax, -0x1b4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x94e0
movl -0x1b4(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x94e0
movq -0x1a0(%rbp), %rdi
callq 0x9af0
nopl (%rax)