LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x12b46(%rip), %rsi     # 0x3b88b
leaq 0x12b42(%rip), %rdx     # 0x3b88e
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x1bf30
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28d7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rax
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x8a92
leaq 0x11394(%rip), %rsi     # 0x3a137
leaq 0x8(%rsp), %rdi
callq 0x7180
testl %eax, %eax
je 0x28dc6
leaq 0x12af3(%rip), %rsi     # 0x3b8ab
leaq 0x8(%rsp), %rdi
callq 0x7180
testl %eax, %eax
jne 0x28e0c
leaq 0x1136a(%rip), %rsi     # 0x3a137
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7180
testl %eax, %eax
sete 0x110(%rbx)
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x28df8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x28(%rsp), %rdi
callq 0x96b6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x1415d(%rip), %rsi     # 0x3cf7d
movq %rax, %rdi
callq 0x78c0
movq 0x25199(%rip), %rsi     # 0x4dfc8
movq 0x2517a(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
jmp 0x28e4e
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28e6a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x28e6a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x96b6
jmp 0x28e95
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28e95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x28e95
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_methods(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_methods(const std::string& directive_value)
{
	std::list<std::string> words = ft::split(directive_value, " \t\n");
	_acceptedMethods.assign(g_webserv.methods.getRegistered().begin(), g_webserv.methods.getRegistered().end());
	if (words.front() == "none")
		return;
	for (std::list<std::string>::const_iterator it = words.begin(); it != words.end(); it++)
	{
		if (g_webserv.methods.getByType(*it) == NULL)
			throw std::invalid_argument("Bad method name in method field in config.");
		_acceptedMethods.remove(g_webserv.methods.getByType(*it));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x129c8(%rip), %rsi     # 0x3b88b
leaq 0x129c4(%rip), %rdx     # 0x3b88e
movq %rsp, %rdi
callq 0x80f4
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1bf30
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x28efb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
addq $0xb0, %rbx
leaq 0x2565f(%rip), %r15     # 0x4e568
movq 0x70(%r15), %rsi
leaq 0x70(%r15), %rdx
movq %rbx, %rdi
callq 0x2dcc6
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x13ea7(%rip), %rsi     # 0x3cdd0
callq 0x7180
testl %eax, %eax
sete %al
movq 0x20(%rsp), %rbp
cmpq %r14, %rbp
sete %cl
orb %al, %cl
jne 0x28f80
addq $0x68, %r15
movq %rsp, %r12
leaq 0x10(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2bfde
testq %rax, %rax
je 0x28f99
movq %r15, %rdi
movq %r13, %rsi
callq 0x2bfde
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c07e
movq (%rbp), %rbp
cmpq %r14, %rbp
jne 0x28f49
leaq 0x20(%rsp), %rdi
callq 0x96b6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x13fa5(%rip), %rsi     # 0x3cf52
movq %rax, %rdi
callq 0x78c0
movq 0x2500c(%rip), %rsi     # 0x4dfc8
movq 0x24fed(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
jmp 0x28ffe
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2900b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x2900b
movq %rax, %rbx
jmp 0x2900b
jmp 0x28ffe
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x29001
jmp 0x28ffe
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x96b6
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_auth_basic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_auth_basic(const std::string& directive_value)
{
	std::list<std::string> words = ft::split(directive_value, " \t\n");
	if (words.size() == 1 && words.front() == "off")
	{
		_params["auth_basic"].assign(1, "");
		return;
	}
	_params["auth_basic"].assign(1, directive_value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x122a0(%rip), %rsi     # 0x3b88b
leaq 0x1229c(%rip), %rdx     # 0x3b88e
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x1bf30
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29625
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq $0x1, 0x58(%rsp)
jne 0x29646
movq 0x48(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1226e(%rip), %rsi     # 0x3b8ab
callq 0x7180
testl %eax, %eax
je 0x296ad
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x13734(%rip), %rsi     # 0x3cd89
leaq 0x13737(%rip), %rdx     # 0x3cd93
callq 0x80f4
addq $0x20, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2bf2c
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2d910
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29699
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x48(%rsp), %rdi
callq 0x96b6
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x136cd(%rip), %rsi     # 0x3cd89
leaq 0x136d0(%rip), %rdx     # 0x3cd93
callq 0x80f4
addq $0x20, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2bf2c
movq %rax, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x116af(%rip), %rdx     # 0x3ad9b
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x80f4
leaq 0x28(%rsp), %rdx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2d910
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x29682
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29682
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x29776
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29776
jmp 0x29773
jmp 0x29773
jmp 0x2974d
movq %rax, %rbx
jmp 0x2978d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29797
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29797
movq %rax, %rbx
jmp 0x29797
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2978d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x48(%rsp), %rdi
callq 0x96b6
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x50(%rdi), %rbx
leaq 0x8(%rsp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x2be6e
movq 0xa8(%r13), %rbp
movq 0x8(%r14), %rcx
movq 0x18(%rbp), %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x74d0
movq 0x18(%rbp), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x2be36
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x2be3f
movq 0x10(%rbp), %rdi
movq %r12, %rsi
callq 0x74c0
testl %eax, %eax
sete %bpl
jmp 0x2be42
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
jmp 0x2be42
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x2be5c
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x74b0
testb %bpl, %bpl
je 0x2bddd
addq $0x10, %r13
movq %r13, %rax
jmp 0x2be72
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xf8(%rdi), %rdi
addq $0xf8, %rbx
cmpq %rbx, %rdi
je 0x2bee9
movq %rsi, %r15
addq $0x10, %rdi
leaq 0x10f1d(%rip), %rsi     # 0x3cdcc
callq 0x7180
testl %eax, %eax
je 0x2beed
movq (%rbx), %r14
movq %r15, 0x8(%rsp)
movq %rbx, %rax
cmpq %rbx, %r14
je 0x2bef4
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d37a
testb %al, %al
jne 0x2bef1
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x2becd
movq %rbx, %rax
jmp 0x2bef4
xorl %eax, %eax
jmp 0x2befa
movb $0x1, %al
jmp 0x2befa
movq %r14, %rax
cmpq %rbx, %rax
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %r12
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x2c06c
movq 0x10(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x2c03b
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x2c044
movq (%r14), %rsi
movq %r13, %rdi
callq 0x74c0
testl %eax, %eax
sete %bpl
jmp 0x2c047
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
jmp 0x2c047
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x2c061
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x74b0
testb %bpl, %bpl
je 0x2bffe
movq 0x10(%r15), %rax
jmp 0x2c06e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq %rsi, %rsi
callq 0x7700
cmpq $0x0, 0x8(%r14)
je 0x2e0fc
xorl %r12d, %r12d
leaq 0xf06d(%rip), %r13      # 0x3d120
movq (%r14), %rax
movb (%rax,%r12), %al
sarb $0x4, %al
movsbq %al, %rax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x7420
movq (%r14), %rax
movzbl (%rax,%r12), %eax
andl $0xf, %eax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x7420
movq %rbx, %rdi
movl $0x20, %esi
callq 0x7420
incq %r12
cmpq 0x8(%r14), %r12
jb 0x2e0b3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2e10b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2e121
movq (%r15), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x7700
cmpq $0x0, 0x8(%r14)
je 0x2e18e
xorl %r12d, %r12d
movl $0x20, %r13d
movq (%r14), %rax
movsbl (%rax,%r12), %ebp
movl %ebp, %edi
callq 0x7820
testl %eax, %eax
cmovel %r13d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7420
incq %r12
cmpq 0x8(%r14), %r12
jb 0x2e166
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e1a2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2e1b8
movq (%r15), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/tcp-server.cpp
// Function: handle_client_request(Client&)
bool	handle_client_request(Client &client)
{
	std::string	data;
	try
	{
		*client.sckt >> data;
		if (g_webserv.debug && !client.req->_header_section_finished)
			hexdump_str(data, 24);
		client.req->append(data);
	}
	catch(ServerSocket::ServerSocketException &e)
	{
		return (Logger::print(e.what(), true, ERROR, NORMAL));
	}
	catch(std::invalid_argument &e)
	{
		// Si error_code est set on considère que ce n'est pas une erreur étant donné qu'on va pouvoir répondre avec _error_code de la request
		return (Logger::print(e.what(), (client.req->_error_code == 0), ERROR, NORMAL));
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1212e
cmpb $0x1, 0x1fe90(%rip)     # 0x4e569
jne 0x2e6f7
movq 0x8(%r14), %rax
cmpb $0x0, 0x190(%rax)
jne 0x2e6f7
leaq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x2e496
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3356e
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e71e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x2, %edx
jne 0x2e795
movq %rbx, %rdi
callq 0x7210
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xde66
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x32966
movl %eax, %ebx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e78b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x74b0
callq 0x7780
jmp 0x2e707
cmpl $0x1, %edx
jne 0x2e866
movq %rbx, %rdi
callq 0x7210
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xde66
movq 0x8(%r14), %rax
xorl %esi, %esi
cmpl $0x0, 0x188(%rax)
sete %sil
leaq 0x50(%rsp), %rdi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x32966
movl %eax, %ebx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e803
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x74b0
callq 0x7780
jmp 0x2e707
jmp 0x2e839
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e832
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x2e832
movq %rax, %rbx
callq 0x7780
jmp 0x2e866
movq %rax, %rbx
jmp 0x2e866
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e861
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x2e861
movq %rax, %rbx
callq 0x7780
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e87d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
movq %rax, %rdi
callq 0x96aa
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movb 0x192(%rdi), %bl
testb %bl, %bl
jne 0x3359a
movq %rdi, %r14
addq $0x8, %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x7190
movq %r14, %rdi
callq 0x335a8
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x198(%rdi), %rdx
incq %rdx
movq %r14, %rdi
movl $0x20, %esi
callq 0x75c0
cmpq $-0x1, %rax
je 0x3431a
movq 0x198(%rbx), %r15
incq %r15
movq %r14, %rdi
movl $0x20, %esi
movq %r15, %rdx
callq 0x75c0
movq 0x198(%rbx), %rcx
notq %rcx
addq %rax, %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x35894
testb %al, %al
je 0x34329
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1aede
leaq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b7ac
leaq 0x28(%rsp), %rdi
callq 0x1b836
movq 0x198(%rbx), %rdx
incq %rdx
movq %r14, %rdi
movl $0x20, %esi
callq 0x75c0
movq %rax, 0x198(%rbx)
movb $0x1, 0x191(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3431a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x190, 0x188(%rbx)     # imm = 0x190
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x942b(%rip), %rsi      # 0x3d772
movq %rax, %rdi
callq 0x78c0
movq 0x19c72(%rip), %rsi     # 0x4dfc8
movq 0x19c53(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x34386
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1b836
jmp 0x34386
jmp 0x34383
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x343a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x1f40, 0x8(%rsi)      # imm = 0x1F40
jbe 0x358b7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x358d6
movq (%rbx), %rax
movb $0x1, %bpl
cmpb $0x2f, (%rax)
je 0x358aa
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x35931
cmpq $0x8, 0x8(%rbx)
jb 0x35931
leaq 0x8(%rsp), %r15
movl $0x7, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x74d0
leaq 0x559b(%rip), %rsi      # 0x3aea4
movq %r15, %rdi
callq 0x7180
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3592d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testl %ebp, %ebp
je 0x35974
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x358aa
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x358a8
leaq 0x4eb4(%rip), %rsi      # 0x3a813
movq %rbx, %rdi
callq 0x7180
testl %eax, %eax
jne 0x358a8
jmp 0x358aa
movb $0x1, %bpl
jmp 0x358aa
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
movq 0x140(%rsi), %rbp
cmpq 0x148(%rsi), %rbp
je 0x35c55
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x35c1f
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x35c28
movq (%r14), %rsi
movq %r13, %rdi
callq 0x74c0
testl %eax, %eax
sete %bl
jmp 0x35c2a
movq 0x8(%rsp), %r13
xorl %ebx, %ebx
jmp 0x35c2a
movb $0x1, %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x35c44
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x74b0
testb %bl, %bl
jne 0x35c74
addq $0x8, %rbp
cmpq 0x148(%r15), %rbp
jne 0x35beb
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5134(%rip), %rdx      # 0x3ad9b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80f4
jmp 0x35cc3
movq (%rbp), %rdi
callq 0x8e50
movq %rax, %r14
movq (%rbp), %rdi
callq 0x8e50
movq %rax, %rdi
movl $0x3a, %esi
xorl %edx, %edx
callq 0x75c0
movq %rax, %r15
movq (%rbp), %rdi
callq 0x8e50
movq 0x8(%rax), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x74d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x8(%rdi), %rbx
leaq 0x48(%rsp), %rbp
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %r13
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
cmpq 0x10(%rsp), %rbx
je 0x3615a
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %rbp, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x8a92
movq (%rsp), %rdi
movq %r15, %r12
movq %r15, %rsi
movq %r13, %r14
movq %r13, %rdx
callq 0x3659a
movl %eax, %r15d
movq 0x38(%rsp), %rdi
movq %rbp, %r13
cmpq %rbp, %rdi
je 0x36120
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3613c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r15b, %r15b
movq %r13, %rbp
movq %r12, %r15
movq %r14, %r13
je 0x360b7
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x3615c
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3618a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<IMethod*>::hasCandidates(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool hasCandidates(const std::string& type) const
		{
			for (typename std::list<value_type>::const_iterator it = _elements.begin(); it != _elements.end(); it++)
				if ((*it)->getType().substr(0, type.size()) == type)
					return true;
			return false;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbp
addq $0x8, %rbp
leaq 0x8(%rsp), %r15
movq %rbp, %rbx
movq (%rbx), %rbx
cmpq %rbp, %rbx
je 0x36252
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x74d0
movq 0x30(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x36206
movq 0x28(%rsp), %r13
testq %rdx, %rdx
je 0x36210
movq (%r14), %rsi
movq %r13, %rdi
callq 0x74c0
testl %eax, %eax
sete %r12b
jmp 0x36213
movq 0x28(%rsp), %r13
xorl %r12d, %r12d
jmp 0x36213
movb $0x1, %r12b
leaq 0x38(%rsp), %rax
cmpq %rax, %r13
je 0x3622d
movq 0x38(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x74b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x36249
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r12b, %r12b
je 0x361b2
cmpq %rbp, %rbx
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x36286
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::contains_ignore_case(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool contains_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 true;
			return false;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x8(%rdi), %r13
leaq 0x48(%rsp), %rbp
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r12
movq %r13, (%rsp)
movq (%r13), %r13
cmpq (%rsp), %r13
je 0x363e9
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbp, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x8a92
movq 0x8(%rsp), %rdi
movq %r14, %r15
movq %r14, %rsi
movq %r12, %rbx
movq %r12, %rdx
callq 0x3659a
movl %eax, %r14d
movq 0x38(%rsp), %rdi
movq %rbp, %r12
cmpq %rbp, %rdi
je 0x363bb
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x363d7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r14b, %r14b
movq %r12, %rbp
movq %r15, %r14
movq %rbx, %r12
je 0x36351
cmpq (%rsp), %r13
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3641e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Response.cpp
// Function: Response::operator=(Response const&)
Response& Response::operator=(const Response& other)
{
	_code = other._code;
	_message = other._message;
	_headers = other._headers;
	_body = other._body;
	_path = other._path;
	_cangzip = other._cangzip;
	_candeflate = other._candeflate;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x72c0
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x2ca24
leaq 0x60(%r14), %rsi
leaq 0x60(%rbx), %rdi
callq 0x72c0
movl $0x80, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x72c0
movb 0xd(%r14), %al
movb %al, 0xd(%rbx)
movb 0xc(%r14), %al
movb %al, 0xc(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Response.cpp
// Function: Response::addDateHeader()
void Response::addDateHeader(void)
{
	struct timeval		tv;
	char				buffer[1024];
	std::stringstream	ss;
	struct tm			time;

	gettimeofday(&tv, NULL);
	tv.tv_sec -= 7200;
	ss << tv.tv_sec;
	strptime(std::string(ss.str()).c_str(), "%s", &time);
	strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S GMT", &time);
	this->addHeader("Date", buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x618, %rsp            # imm = 0x618
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x7360
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7740
movq $-0x1c20, %rsi          # imm = 0xE3E0
addq (%r14), %rsi
leaq 0x98(%rsp), %rdi
callq 0x7470
leaq 0xa0(%rsp), %rsi
movq %rsp, %rdi
callq 0x7710
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
leaq 0x2fa1(%rip), %rsi      # 0x3a3a5
leaq 0x50(%rsp), %rdx
callq 0x70b0
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x37424
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x332f(%rip), %rdx      # 0x3a75a
leaq 0x210(%rsp), %rdi
leaq 0x50(%rsp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x73f0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x2d33(%rip), %rsi      # 0x3a182
leaq 0x2d30(%rip), %rdx      # 0x3a186
callq 0x80f4
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x210(%rsp), %r14
movq %r14, %rdi
callq 0x7220
leaq (%rsp,%rax), %rdx
addq $0x210, %rdx            # imm = 0x210
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x80f4
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x388ac
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x72c0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x374c0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x374d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x16a93(%rip), %rsi     # 0x4df70
leaq 0x88(%rsp), %rdi
callq 0x73b0
leaq 0x108(%rsp), %rdi
callq 0x71c0
addq $0x618, %rsp            # imm = 0x618
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x3752e
jmp 0x3750f
jmp 0x3750f
movq %rax, %rbx
jmp 0x37544
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x3752e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37544
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x16a25(%rip), %rsi     # 0x4df70
leaq 0x88(%rsp), %rdi
callq 0x73b0
leaq 0x108(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Response.cpp
// Function: Response::setCompression(std::vector<Header*, std::allocator<Header*>> const&)
void	Response::setCompression(const std::vector<Header*>& headers)
{
	AcceptEncodingHeader* aeh = NULL;
	for (std::vector<Header*>::const_iterator it = headers.begin(); it != headers.end(); it++)
		if ((*it)->getType() == AcceptEncodingHeader().getType()) {
			aeh = reinterpret_cast<AcceptEncodingHeader*>(*it);
			break;
		}
	if (!aeh)
		return;
	std::multimap<float, std::string, std::greater<float> > encoding_preferences = aeh->getPreferences();
	for (std::map<float, std::string, std::greater<float> >::const_iterator it = encoding_preferences.begin(); it != encoding_preferences.end(); it++)
	{
		if (it->second == "gzip" && it->first == encoding_preferences.begin()->first)
			_cangzip = true;
		else if (it->second == "deflate" && it->first == encoding_preferences.begin()->first)
			_candeflate = true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, (%rsp)
movq (%rsi), %rbx
cmpq 0x8(%rsi), %rbx
je 0x37c93
movq %rsi, %r14
leaq 0x48(%rsp), %r12
leaq 0x28(%rsp), %r13
movq (%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
movq %r12, %rdi
callq 0x818c
movq %r13, %rdi
movq %r12, %rsi
callq 0x81da
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x37b86
movq 0x28(%rsp), %rbp
testq %rdx, %rdx
je 0x37b90
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x74c0
testl %eax, %eax
sete %r15b
jmp 0x37b93
movq 0x28(%rsp), %rbp
xorl %r15d, %r15d
jmp 0x37b93
movb $0x1, %r15b
leaq 0x38(%rsp), %rax
cmpq %rax, %rbp
je 0x37bad
movq 0x38(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x74b0
movq %r12, %rdi
callq 0x81b8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x37bd1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r15b, %r15b
jne 0x37be9
addq $0x8, %rbx
cmpq 0x8(%r14), %rbx
jne 0x37b3a
jmp 0x37c93
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x37c93
movq (%rsi), %rax
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq *0x28(%rax)
movq 0x18(%r14), %r14
leaq 0x50(%rsp), %rbx
cmpq %rbx, %r14
je 0x37c89
leaq 0x5d14(%rip), %r15      # 0x3d92c
leaq 0x3cab(%rip), %r12      # 0x3b8ca
leaq 0x28(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x7180
testl %eax, %eax
je 0x37c5e
movq %r13, %rdi
movq %r12, %rsi
callq 0x7180
testl %eax, %eax
jne 0x37c79
movss 0x20(%r14), %xmm0
movq 0x60(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x37c79
jp 0x37c79
movq (%rsp), %rax
movb $0x1, 0xc(%rax)
jmp 0x37c79
movss 0x20(%r14), %xmm0
movq 0x60(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x37c32
jp 0x37c32
movq (%rsp), %rax
movb $0x1, 0xd(%rax)
movq %r14, %rdi
callq 0x7520
movq %rax, %r14
cmpq %rbx, %rax
jne 0x37c1f
leaq 0x48(%rsp), %rdi
callq 0x96fc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x37cb4
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x81b8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x37cd0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/VirtualHost.cpp
// Function: VirtualHost::VirtualHost(ConfigContext const&)
VirtualHost::VirtualHost(const ConfigContext& config)
	: _config(config)
{
	const std::list<std::string>& listen = _config.getParam("listen");
	for (std::list<std::string>::const_iterator it = listen.begin(); it != listen.end(); it++)
	{
		std::pair<std::string, int> full_ip = ft::complete_ip(*it);
		if (g_webserv.sockets.find(full_ip.second) == g_webserv.sockets.end())
			g_webserv.sockets.insert(std::make_pair(full_ip.second, new ServerSocket(full_ip.second)));
		_ports.push_back(full_ip.second);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x14e92(%rip), %rax     # 0x4dd30
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x27a7e
leaq 0x120(%r15), %r14
movq %r14, 0x128(%r15)
movq %r14, 0x120(%r15)
movq $0x0, 0x130(%r15)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3eb7(%rip), %rsi      # 0x3cd94
leaq 0x3eb6(%rip), %rdx      # 0x3cd9a
movq %rsp, %rdi
movq %rbx, 0x28(%rsp)
callq 0x80f4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b17e
movq %rax, %r12
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x38f1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r12), %r13
cmpq %r12, %r13
je 0x38fff
leaq 0x1563a(%rip), %rax     # 0x4e568
leaq 0x18(%rax), %rcx
movq %rcx, 0x30(%rsp)
leaq 0x20(%rax), %rbp
leaq 0x10(%r13), %rsi
movq %rsp, %rdi
callq 0x1c1d7
leaq 0x1561a(%rip), %rax     # 0x4e568
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x38f7f
movl 0x20(%rsp), %eax
movq %rbp, %rdx
xorl %esi, %esi
cmpl %eax, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x38f5e
cmpq %rbp, %rdx
je 0x38f7f
cmpl 0x20(%rdx), %eax
jge 0x38fb4
movl $0x60, %edi
callq 0x74a0
movq %rax, %rbx
movl 0x20(%rsp), %esi
movq %rax, %rdi
callq 0x11c2c
movl 0x20(%rsp), %eax
movl %eax, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3927e
movl $0x18, %edi
callq 0x74a0
movl 0x20(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x7090
incq 0x130(%r15)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x38ff2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r13), %r13
cmpq %r12, %r13
jne 0x38f3b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3902b
jmp 0x39024
movq %rax, %r15
movl $0x60, %esi
movq %rbx, %rdi
callq 0x74b0
jmp 0x3902e
movq %rax, %r15
jmp 0x39049
jmp 0x3902b
movq %rax, %r15
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x39049
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x39066
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x74b0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x39051
movq 0x28(%rsp), %rdi
callq 0x279dc
movq %r15, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/VirtualHost.cpp
// Function: VirtualHost::getServerByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::list<VirtualHost, std::allocator<VirtualHost>>&)
VirtualHost& VirtualHost::getServerByName(const std::string& name, int port, std::list<VirtualHost>& vhosts)
{
	std::list<VirtualHost*> matches;

	for (std::list<VirtualHost>::iterator vhost_it = vhosts.begin(); vhost_it != vhosts.end(); vhost_it++)
		if (ft::contains(vhost_it->getPorts(), port))
			matches.push_back(&(*vhost_it));
	if (matches.empty())
		throw std::invalid_argument("No matching server found"); // Si ça arrive c'est parce qu'on a un socket ouvert sur un port relié à aucun serveur
	for (std::list<VirtualHost*>::iterator matches_it = matches.begin(); matches_it != matches.end(); matches_it++)
		if (ft::contains((*matches_it)->getConfig().getNames(), name))
			return *(*matches_it);
	return (*matches.front());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq (%rdx), %r12
cmpq %rdx, %r12
je 0x3920c
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
leaq 0x130(%r12), %rax
movq 0x130(%r12), %rcx
cmpq %rax, %rcx
je 0x39171
leaq 0x10(%r12), %r13
cmpl %ebp, 0x10(%rcx)
je 0x3914e
movq (%rcx), %rcx
cmpq %rax, %rcx
jne 0x3913f
jmp 0x39171
cmpq %rax, %rcx
je 0x39171
movl $0x18, %edi
callq 0x74a0
movq %r13, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7090
incq 0x18(%rsp)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x39125
movq 0x8(%rsp), %rbp
cmpq %rbx, %rbp
je 0x3920c
leaq 0x20(%rsp), %r15
movq 0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2b160
movq %rax, %r12
movq (%rax), %r13
movq %r14, 0x20(%rsp)
cmpq %r12, %r13
je 0x391c4
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d37a
testb %al, %al
jne 0x391bf
movq (%r13), %r13
jmp 0x391a5
cmpq %r12, %r13
jne 0x391d7
movq (%rbp), %rbp
cmpq %rbx, %rbp
jne 0x3918d
movq 0x8(%rsp), %rdi
movq %rdi, %rbp
jmp 0x391dc
movq 0x8(%rsp), %rdi
movq 0x10(%rbp), %r14
cmpq %rbx, %rdi
je 0x391fa
movq (%rdi), %r15
movl $0x18, %esi
callq 0x74b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x391e5
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x4725(%rip), %rsi      # 0x3d945
movq %rax, %rdi
callq 0x78c0
movq 0x14d99(%rip), %rsi     # 0x4dfc8
movq 0x14d7a(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
jmp 0x3924f
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x39252
jmp 0x3924f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %r15
cmpq %r15, %rdi
je 0x39276
movq (%rdi), %r14
movl $0x18, %esi
callq 0x74b0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x39261
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/pollo[P]graph-partitioning/preprocessing.cpp
// Function: dfs(int, int, std::vector<int, std::allocator<int>>&, Graph const&)
int dfs(int node,
        int component_id,
        vector<int>& component,
        const Graph& graph)
{
  component[node] = component_id;
  int discovered = 1;
  for (size_t j = 0;
       j < graph.get_neighbors(node).size();
       j++)
  {
    int neighbor = graph.get_neighbors(node)[j];
    if (component[neighbor] == -1)
      discovered += dfs(neighbor, component_id, component, graph);
  }

  return discovered;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
movslq %edi, %rsi
movq (%rdx), %rax
movl %ebp, (%rax,%rsi,4)
movq %rcx, %rdi
callq 0x3334
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2480
movl $0x1, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3334
movq (%rax), %rax
movslq (%rax,%r13,4), %rdi
movq (%r14), %rax
cmpl $-0x1, (%rax,%rdi,4)
jne 0x2460
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23fc
addl %eax, %r12d
incq %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3334
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jb 0x2435
jmp 0x2486
movl $0x1, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pollo[P]graph-partitioning/preprocessing.cpp
// Function: find_largest_component(std::vector<int, std::allocator<int>>&, Graph const&)
int find_largest_component(vector<int>& component,
                           const Graph& graph) {
  component.resize(graph.get_nodes_number(), -1);
  int largest_component = -1;
  int largest_size = 0;
  int component_id = 1;
  for (int i=0; i<graph.get_nodes_number(); i++)
  {
    if (component[i] == -1)
    {
      int component_size = dfs(i, component_id, component, graph);
      if (component_size > largest_size)
      {
        largest_size = component_size;
        largest_component = component_id;
      }
      component_id ++;
    }
  }

  return largest_component;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rsi
leaq 0x4(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
callq 0x29a2
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x250e
xorl %r15d, %r15d
movl $0x1, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq (%r14), %rcx
cmpl $-0x1, (%rcx,%r15,4)
jne 0x2501
movl %r15d, %edi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23fc
cmpl %r13d, %eax
cmovgl %eax, %r13d
cmovgl %r12d, %ebp
incl %r12d
movl 0x8(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x24d5
jmp 0x2513
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pollo[P]graph-partitioning/preprocessing.cpp
// Function: count_nodes_edges(int, std::vector<int, std::allocator<int>> const&, Graph const&, int*, int*)
void count_nodes_edges(int component_id,
                      const vector<int>& component,
                      const Graph& graph,
                      int* n,
                      int *m)
{
  int nodes = 0, edges = 0;

  for (size_t i=0; i<component.size(); i++)
  {
    if (component[i] == component_id)
    {
      nodes ++;
      edges += graph.get_neighbors(i).size();
    }
  }

  edges /= 2.0;

  *n = nodes;
  *m = edges;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rax, %rsi
je 0x25b1
movq %rdx, %r15
movl %edi, %ebp
movq %rcx, 0x8(%rsp)
movq %r8, 0x10(%rsp)
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %ebx, %ebx
cmpl %ebp, (%rax,%r13,4)
jne 0x2582
incl %ebx
movq %r15, %rdi
movl %r13d, %esi
callq 0x3334
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
addl %ecx, %r14d
movq (%r12), %rax
movq 0x8(%r12), %rsi
incq %r13
movq %rsi, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
jb 0x2558
cvtsi2sd %r14d, %xmm0
mulsd 0x2a67(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %eax
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rcx
jmp 0x25b5
xorl %ebx, %ebx
xorl %eax, %eax
movl %ebx, (%rcx)
movl %eax, (%r8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int lex_whitespace(std::string raw_json, int index) {
  while (std::isspace(raw_json[index])) {
    if (index == raw_json.length()) {
      break;
    }

    index++;
  }

  return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r12
movslq %esi, %r15
movsbl (%r12,%r15), %edi
callq 0x2050
testl %eax, %eax
je 0x2846
movq 0x8(%r14), %rbx
cmpq %r15, %rbx
je 0x2840
movsbl 0x1(%r12,%r15), %edi
incq %r15
callq 0x2050
testl %eax, %eax
jne 0x2827
jmp 0x2843
movq %rbx, %r15
movl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_syntax(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_syntax(std::string raw_json,
                                                   int index) {
  JSONToken token{"", JSONTokenType::Syntax, index};
  std::string value = "";
  auto c = raw_json[index];
  if (c == '[' || c == ']' || c == '{' || c == '}' || c == ':' || c == ',') {
    token.value += c;
    index++;
  }

  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, -0x2c(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x898a(%rip), %r12      # 0xb207
leaq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x8c32
movl $0x2, 0x20(%r13)
movl %r14d, 0x24(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x8c32
movslq %r14d, %rax
movq (%r15), %rcx
movb (%rcx,%rax), %al
movzbl %al, %ecx
leal -0x2c(%rcx), %edx
cmpl $0x31, %edx
ja 0x296a
movabsq $0x2800000004001, %rsi  # imm = 0x2800000004001
btq %rdx, %rsi
jae 0x296a
movsbl %al, %esi
leaq -0x88(%rbp), %rdi
callq 0x8cd0
incl %r14d
movl %r14d, -0x2c(%rbp)
leaq 0x8901(%rip), %rcx      # 0xb207
leaq -0x88(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6d9a
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x292e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x293c
callq 0x6fa2
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2958
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7d, %ecx
je 0x28e9
cmpl $0x7b, %ecx
je 0x28e9
jmp 0x28ff
movq %rax, %rbx
jmp 0x299b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x299b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x88(%rbp), %rdi
callq 0x6734
movq %rbx, %rdi
callq 0x2290