LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12680(%rip), %rsi     # 0x3b88b
leaq 0x1267c(%rip), %rdx     # 0x3b88e
movq %rsp, %rdi
callq 0x80f4
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c232
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29243
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
addq $0xb0, %rbx
leaq 0x25317(%rip), %r15     # 0x4e568
movq 0x70(%r15), %rsi
leaq 0x70(%r15), %rdx
movq %rbx, %rdi
callq 0x2e00a
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x13b5f(%rip), %rsi     # 0x3cdd0
callq 0x7180
testl %eax, %eax
sete %al
movq 0x20(%rsp), %rbp
cmpq %r14, %rbp
sete %cl
orb %al, %cl
jne 0x292c8
addq $0x68, %r15
movq %rsp, %r12
leaq 0x10(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2c31e
testq %rax, %rax
je 0x292e1
movq %r15, %rdi
movq %r13, %rsi
callq 0x2c31e
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c3b6
movq (%rbp), %rbp
cmpq %r14, %rbp
jne 0x29291
leaq 0x20(%rsp), %rdi
callq 0x96d8
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 0x13c5d(%rip), %rsi     # 0x3cf52
movq %rax, %rdi
callq 0x78c0
movq 0x24cc4(%rip), %rsi     # 0x4dfc8
movq 0x24ca5(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
jmp 0x29346
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29353
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29353
movq %rax, %rbx
jmp 0x29353
jmp 0x29346
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x29349
jmp 0x29346
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x96d8
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11f58(%rip), %rsi     # 0x3b88b
leaq 0x11f54(%rip), %rdx     # 0x3b88e
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x1c232
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2996d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq $0x1, 0x58(%rsp)
jne 0x2998e
movq 0x48(%rsp), %rdi
addq $0x10, %rdi
leaq 0x11f26(%rip), %rsi     # 0x3b8ab
callq 0x7180
testl %eax, %eax
je 0x299f5
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x133ec(%rip), %rsi     # 0x3cd89
leaq 0x133ef(%rip), %rdx     # 0x3cd93
callq 0x80f4
addq $0x20, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c26c
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2dc54
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x299e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x48(%rsp), %rdi
callq 0x96d8
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x13385(%rip), %rsi     # 0x3cd89
leaq 0x13388(%rip), %rdx     # 0x3cd93
callq 0x80f4
addq $0x20, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c26c
movq %rax, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x11367(%rip), %rdx     # 0x3ad9b
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x80f4
leaq 0x28(%rsp), %rdx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2dc54
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x299ca
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x299ca
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x29abe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29abe
jmp 0x29abb
jmp 0x29abb
jmp 0x29a95
movq %rax, %rbx
jmp 0x29ad5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29adf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x29adf
movq %rax, %rbx
jmp 0x29adf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29ad5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x48(%rsp), %rdi
callq 0x96d8
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
leaq 0x8(%rsp), %r15
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x2c1b8
movq 0xa8(%r12), %rbp
movq 0x8(%r14), %rcx
movq 0x18(%rbp), %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x74d0
movq 0x18(%rbp), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x2c18f
testq %rdx, %rdx
je 0x2c18d
movq 0x8(%rsp), %rsi
movq 0x10(%rbp), %rdi
callq 0x74c0
testl %eax, %eax
sete %bl
jmp 0x2c18f
movb $0x1, %bl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2c1ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bl, %bl
je 0x2c139
addq $0x10, %r12
movq %r12, %rax
jmp 0x2c1bc
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_O1/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 0x2c233
movq %rsi, %r15
addq $0x10, %rdi
leaq 0x10bd3(%rip), %rsi     # 0x3cdcc
callq 0x7180
testl %eax, %eax
je 0x2c237
movq (%rbx), %r14
movq %r15, 0x8(%rsp)
cmpq %rbx, %r14
je 0x2c22b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d6b6
testb %al, %al
jne 0x2c22b
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x2c214
cmpq %rbx, %r14
setne %al
jmp 0x2c239
xorl %eax, %eax
jmp 0x2c239
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
addq $0x8, %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %r15, %rbp
movq (%rbp), %rbp
cmpq %r15, %rbp
je 0x2c3a4
movq 0x10(%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x2c37d
testq %rdx, %rdx
je 0x2c381
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x74c0
testl %eax, %eax
sete %bl
jmp 0x2c383
xorl %ebx, %ebx
jmp 0x2c383
movb $0x1, %bl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2c39a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bl, %bl
je 0x2c343
movq 0x10(%rbp), %rax
jmp 0x2c3a6
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_O1/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 0x2e440
xorl %r12d, %r12d
leaq 0xed29(%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 0x2e3f7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2e44f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2e465
movq (%r15), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e4d2
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 0x2e4aa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e4e6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2e4fc
movq (%r15), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x121cc
cmpb $0x1, 0x1fb46(%rip)     # 0x4e569
jne 0x2ea41
movq 0x8(%r14), %rax
cmpb $0x0, 0x190(%rax)
jne 0x2ea41
leaq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x2e7da
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33990
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ea68
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 0x2eadf
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 0xde9a
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x32d48
movl %eax, %ebx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ead5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x74b0
callq 0x7780
jmp 0x2ea51
cmpl $0x1, %edx
jne 0x2ebb0
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 0xde9a
movq 0x8(%r14), %rax
xorl %esi, %esi
cmpl $0x0, 0x188(%rax)
sete %sil
leaq 0x50(%rsp), %rdi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x32d48
movl %eax, %ebx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eb4d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x74b0
callq 0x7780
jmp 0x2ea51
jmp 0x2eb83
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eb7c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x2eb7c
movq %rax, %rbx
callq 0x7780
jmp 0x2ebb0
movq %rax, %rbx
jmp 0x2ebb0
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ebab
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x2ebab
movq %rax, %rbx
callq 0x7780
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ebc7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
movq %rax, %rdi
callq 0x96cc
// File: /workspace/github_cpp_makefile_star2_O1/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 0x339bc
movq %rdi, %r14
addq $0x8, %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x7190
movq %r14, %rdi
callq 0x339ca
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34762
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 0x35c96
testb %al, %al
je 0x34771
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b1b6
leaq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ba9e
leaq 0x28(%rsp), %rdi
callq 0x1bb28
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 0x34762
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 0x8fe3(%rip), %rsi      # 0x3d772
movq %rax, %rdi
callq 0x78c0
movq 0x1982a(%rip), %rsi     # 0x4dfc8
movq 0x1980b(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x347ce
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1bb28
jmp 0x347ce
jmp 0x347cb
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x347e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x1f40, 0x8(%rsi)      # imm = 0x1F40
jbe 0x35cbd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
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 0x35cdc
movq (%rbx), %rax
movb $0x1, %bpl
cmpb $0x2f, (%rax)
je 0x35cae
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x35d50
movq 0x8(%rbx), %r12
cmpq $0x8, %r12
jb 0x35d20
movq %rsp, %r15
movl $0x7, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x74d0
leaq 0x5194(%rip), %rsi      # 0x3aea4
movq %r15, %rdi
callq 0x7180
testl %eax, %eax
sete %r15b
jmp 0x35d23
xorl %r15d, %r15d
cmpq $0x8, %r12
jb 0x35d44
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35d44
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movb $0x1, %bpl
testb %r15b, %r15b
jne 0x35cae
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x35cae
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x35cac
leaq 0x4a95(%rip), %rsi      # 0x3a813
movq %rbx, %rdi
callq 0x7180
testl %eax, %eax
jne 0x35cac
jmp 0x35cae
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
cmpq 0x148(%rsi), %r13
sete %bpl
je 0x360c5
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3603a
testq %rdx, %rdx
je 0x3603e
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x74c0
testl %eax, %eax
sete %bl
jmp 0x36040
xorl %ebx, %ebx
jmp 0x36040
movb $0x1, %bl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3605c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bl, %bl
jne 0x36073
addq $0x8, %r13
cmpq 0x148(%r15), %r13
sete %bpl
jne 0x36009
jmp 0x360c5
movq (%r13), %rdi
callq 0x8e44
movq %rax, %r14
movq (%r13), %rdi
callq 0x8e44
movq %rax, %rdi
movl $0x3a, %esi
xorl %edx, %edx
callq 0x75c0
movq %rax, %r15
movq (%r13), %rdi
callq 0x8e44
movq 0x8(%rax), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq (%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x74d0
testb $0x1, %bpl
je 0x360df
movq (%rsp), %rdi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x4cc4(%rip), %rdx      # 0x3ad9b
movq %rdx, %rsi
callq 0x80f4
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Request.cpp
// Function: Request::operator=(Request const&)
Request& Request::operator=(const Request& other)
{
	_raw = other._raw;
	_method = other._method;
	_url = other._url;
	_protocolVersion = other._protocolVersion;
	_body = other._body;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x72c0
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x1ba9e
movl $0x120, %edi            # imm = 0x120
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x72c0
movl $0x158, %edi            # imm = 0x158
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x72c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36576
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 0x8a8a
movq (%rsp), %rdi
movq %r15, %r12
movq %r15, %rsi
movq %r13, %r14
movq %r13, %rdx
callq 0x369aa
movl %eax, %r15d
movq 0x38(%rsp), %rdi
movq %rbp, %r13
cmpq %rbp, %rdi
je 0x3653c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x36558
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r15b, %r15b
movq %r13, %rbp
movq %r12, %r15
movq %r14, %r13
je 0x364d3
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x36578
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 0x365a6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13
addq $0x8, %r13
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x3666a
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x74d0
movq 0x30(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x36622
testq %rdx, %rdx
je 0x36626
movq (%r14), %rsi
movq 0x28(%rsp), %rdi
callq 0x74c0
testl %eax, %eax
sete %bpl
jmp 0x36629
xorl %ebp, %ebp
jmp 0x36629
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x36645
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x36661
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bpl, %bpl
je 0x365d3
cmpq %r13, %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 0x3669e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36801
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 0x8a8a
movq 0x8(%rsp), %rdi
movq %r14, %r15
movq %r14, %rsi
movq %r12, %rbx
movq %r12, %rdx
callq 0x369aa
movl %eax, %r14d
movq 0x38(%rsp), %rdi
movq %rbp, %r12
cmpq %rbp, %rdi
je 0x367d3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x367ef
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r14b, %r14b
movq %r12, %rbp
movq %r15, %r14
movq %rbx, %r12
je 0x36769
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 0x36836
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cd60
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_O1/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
movq %rsi, (%r14)
leaq 0x98(%rsp), %rdi
callq 0x7470
leaq 0xa0(%rsp), %rsi
movq %rsp, %rdi
callq 0x7710
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
leaq 0x2b72(%rip), %rsi      # 0x3a3a5
leaq 0x50(%rsp), %rdx
callq 0x70b0
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x37853
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x2f00(%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 0x2904(%rip), %rsi      # 0x3a182
leaq 0x2901(%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 0x38cee
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x72c0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x378ef
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37905
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x16664(%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 0x3795d
jmp 0x3793e
jmp 0x3793e
movq %rax, %rbx
jmp 0x37973
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x3795d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37973
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x165f6(%rip), %rsi     # 0x4df70
leaq 0x88(%rsp), %rdi
callq 0x73b0
leaq 0x108(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbp
movq (%rsi), %rbx
cmpq 0x8(%rsi), %rbx
je 0x38016
movq %rsi, %r15
movq %rbp, (%rsp)
leaq 0x8(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x28(%rsp), %rbp
movq (%rbx), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
callq 0x8184
movq %rbp, %rdi
movq %r13, %rsi
callq 0x81d2
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x37fb7
testq %rdx, %rdx
je 0x37fbc
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x74c0
testl %eax, %eax
sete %r14b
jmp 0x37fbf
xorl %r14d, %r14d
jmp 0x37fbf
movb $0x1, %r14b
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x37fdb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r13, %rdi
callq 0x81b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x37fff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r14b, %r14b
jne 0x3801a
addq $0x8, %rbx
cmpq 0x8(%r15), %rbx
jne 0x37f70
movq (%rsp), %rbp
xorl %esi, %esi
jmp 0x38021
movq (%rbx), %rsi
movq (%rsp), %rbp
testq %rsi, %rsi
je 0x380c0
movq (%rsi), %rax
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %r14
leaq 0x50(%rsp), %rbx
cmpq %rbx, %r14
je 0x380b6
leaq 0x58df(%rip), %r15      # 0x3d92c
leaq 0x3876(%rip), %r12      # 0x3b8ca
leaq 0x28(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x7180
testl %eax, %eax
je 0x3808f
movq %r13, %rdi
movq %r12, %rsi
callq 0x7180
testl %eax, %eax
jne 0x380a6
movss 0x20(%r14), %xmm0
movq 0x60(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x380a6
jp 0x380a6
movb $0x1, 0xc(%rbp)
jmp 0x380a6
movss 0x20(%r14), %xmm0
movq 0x60(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x38067
jp 0x38067
movb $0x1, 0xd(%rbp)
movq %r14, %rdi
callq 0x7520
movq %rax, %r14
cmpq %rbx, %rax
jne 0x38054
leaq 0x48(%rsp), %rdi
callq 0x971e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x380e1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x81b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x380fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14a5e(%rip), %rax     # 0x4dd30
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x27dca
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 0x3a83(%rip), %rsi      # 0x3cd94
leaq 0x3a82(%rip), %rdx      # 0x3cd9a
movq %rsp, %rdi
movq %rbx, 0x28(%rsp)
callq 0x80f4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b4c6
movq %rax, %r12
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3934e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r12), %r13
cmpq %r12, %r13
je 0x3943a
leaq 0x15206(%rip), %rax     # 0x4e568
leaq 0x20(%rax), %rbp
addq $0x18, %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%r13), %rsi
movq %rsp, %rdi
callq 0x1c4d9
leaq 0x151e6(%rip), %rax     # 0x4e568
movq 0x28(%rax), %rcx
movq %rbp, %rax
testq %rcx, %rcx
je 0x393ac
movl 0x20(%rsp), %edx
movq %rbp, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x39395
cmpq %rbp, %rax
je 0x393ba
movl 0x20(%rsp), %ecx
cmpl 0x20(%rax), %ecx
jge 0x393ef
movl $0x60, %edi
callq 0x74a0
movq %rax, %rbx
movl 0x20(%rsp), %esi
movq %rax, %rdi
callq 0x11cc0
movl 0x20(%rsp), %eax
movl %eax, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x396ca
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 0x3942d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r13), %r13
cmpq %r12, %r13
jne 0x3936f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39466
jmp 0x39461
movq %rax, %r15
movl $0x60, %esi
movq %rbx, %rdi
callq 0x74b0
jmp 0x39469
jmp 0x39466
movq %rax, %r15
jmp 0x39484
movq %rax, %r15
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x39484
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x394a1
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x74b0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x3948c
movq 0x28(%rsp), %rdi
callq 0x27d28
movq %r15, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, 0x8(%r13)
movq %r13, (%r13)
movq $0x0, 0x10(%r13)
movq (%rdx), %r12
cmpq %rdx, %r12
je 0x395ae
movq %rdx, %r14
movl %esi, %ebp
leaq 0x8(%rsp), %r15
leaq 0x130(%r12), %rax
movq 0x130(%r12), %rcx
cmpq %rax, %rcx
je 0x3957d
cmpl %ebp, 0x10(%rcx)
je 0x3957d
movq (%rcx), %rcx
jmp 0x3956e
cmpq %rax, %rcx
je 0x395a5
movl $0x18, %edi
callq 0x74a0
leaq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x7090
incq 0x18(%rsp)
movq (%r12), %r12
cmpq %r14, %r12
jne 0x3955e
movq 0x8(%rsp), %rbp
cmpq %r13, %rbp
je 0x39658
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
movq 0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2b4a8
movq %rax, %r15
movq (%rax), %r12
movq %rbx, 0x20(%rsp)
cmpq %r15, %r12
je 0x395f6
movq %r14, %rdi
movq %r12, %rsi
callq 0x2d6b6
testb %al, %al
jne 0x395f6
movq (%r12), %r12
jmp 0x395dc
cmpq %r15, %r12
jne 0x3960f
movq (%rbp), %rbp
leaq 0x8(%rsp), %rax
cmpq %rax, %rbp
sete %r13b
jne 0x395c4
jmp 0x39613
movq 0x10(%rbp), %r15
testb $0x1, %r13b
je 0x39622
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r15
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %r14
cmpq %r14, %rdi
je 0x39646
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x74b0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x39631
movq %r15, %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 0x42d9(%rip), %rsi      # 0x3d945
movq %rax, %rdi
callq 0x78c0
movq 0x1494d(%rip), %rsi     # 0x4dfc8
movq 0x1492e(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
jmp 0x3969b
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x3969e
jmp 0x3969b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %r15
cmpq %r15, %rdi
je 0x396c2
movq (%rdi), %r14
movl $0x18, %esi
callq 0x74b0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x396ad
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3332
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2490
movl $0x1, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3332
movq (%rax), %rax
movslq (%rax,%r13,4), %rdi
movq (%r14), %rax
cmpl $-0x1, (%rax,%rdi,4)
jne 0x2470
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x240c
addl %eax, %r12d
incq %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3332
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jb 0x2445
jmp 0x2496
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_O1/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
cmpl $0x0, 0x8(%rbx)
jle 0x251b
xorl %r15d, %r15d
movl $0x1, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq (%r14), %rax
cmpl $-0x1, (%rax,%r15,4)
jne 0x250d
movl %r15d, %edi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x240c
cmpl %r13d, %eax
cmovgl %eax, %r13d
cmovgl %r12d, %ebp
incl %r12d
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x24e4
jmp 0x2520
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_O1/eatonphil[P]cpp-json/json.cpp
// Function: json::JSONTokenType_to_string[abi:cxx11](json::JSONTokenType)
std::string JSONTokenType_to_string(JSONTokenType jtt) {
  switch (jtt) {
  case JSONTokenType::String:
    return "String";
  case JSONTokenType::Number:
    return "Number";
  case JSONTokenType::Syntax:
    return "Syntax";
  case JSONTokenType::Boolean:
    return "Boolean";
  case JSONTokenType::Null:
    return "Null";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl %esi, %eax
leaq 0x8bbf(%rip), %rcx      # 0xb004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8c0b(%rip), %rsi      # 0xb060
leaq 0x8c0a(%rip), %rdx      # 0xb066
jmp 0x249c
leaq 0x8c18(%rip), %rsi      # 0xb07d
leaq 0x8c15(%rip), %rdx      # 0xb081
jmp 0x249c
leaq 0x8bf9(%rip), %rsi      # 0xb06e
leaq 0x8bf8(%rip), %rdx      # 0xb074
jmp 0x249c
leaq 0x8bf0(%rip), %rsi      # 0xb075
leaq 0x8bf0(%rip), %rdx      # 0xb07c
jmp 0x249c
leaq 0x8bd2(%rip), %rsi      # 0xb067
leaq 0x8bd1(%rip), %rdx      # 0xb06d
movq %rbx, %rdi
callq 0x8c74
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2877
movq 0x8(%r14), %rbx
cmpq %r15, %rbx
je 0x2871
movsbl 0x1(%r12,%r15), %edi
incq %r15
callq 0x2050
testl %eax, %eax
jne 0x2858
jmp 0x2874
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_O1/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
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x2c(%rbp)
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x895c(%rip), %r15      # 0xb207
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8c74
movl $0x2, 0x20(%r12)
movl -0x2c(%rbp), %eax
movl %eax, 0x24(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r12)
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8c74
movslq -0x2c(%rbp), %rax
movq (%r14), %rcx
movb (%rcx,%rax), %al
movzbl %al, %ecx
leal -0x2c(%rcx), %edx
cmpl $0x31, %edx
ja 0x2994
movabsq $0x2800000004001, %rsi  # imm = 0x2800000004001
btq %rdx, %rsi
jae 0x2994
movsbl %al, %esi
leaq -0x88(%rbp), %rdi
callq 0x8d0e
incl -0x2c(%rbp)
leaq 0x88d3(%rip), %rcx      # 0xb207
leaq -0x88(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6dee
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x295c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x296a
callq 0x6ff2
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x2982
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 0x291b
cmpl $0x7b, %ecx
je 0x291b
jmp 0x292d
movq %rax, %rbx
jmp 0x29c1
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x29c1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x88(%rbp), %rdi
callq 0x678c
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_number(std::string raw_json,
                                                   int original_index) {
  int index = original_index;
  JSONToken token = {"", JSONTokenType::Number, index};
  std::string value = "";
  // TODO: handle not just integers
  while (true) {
    if (index == raw_json.length()) {
      break;
    }

    auto c = raw_json[index];
    if (!(c >= '0' && c <= '9')) {
      break;
    }

    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
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x2c(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x857b(%rip), %r15      # 0xb207
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8c74
movl $0x1, 0x20(%r12)
movl -0x2c(%rbp), %eax
movl %eax, 0x24(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r12)
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8c74
leaq -0x88(%rbp), %r15
movslq -0x2c(%rbp), %rax
cmpq %rax, 0x8(%r14)
je 0x2d08
movq (%r14), %rcx
movb (%rcx,%rax), %al
leal -0x30(%rax), %r13d
cmpb $0xa, %r13b
jae 0x2d08
movsbl %al, %esi
movq %r15, %rdi
callq 0x8d0e
incl -0x2c(%rbp)
cmpb $0xa, %r13b
jb 0x2cda
leaq 0x84f8(%rip), %rcx      # 0xb207
leaq -0x88(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6dee
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2d37
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d45
callq 0x6ff2
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2d61
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
jmp 0x2d7a
movq %rax, %rbx
jmp 0x2d92
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2d92
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x88(%rbp), %rdi
callq 0x678c
movq %rbx, %rdi
callq 0x2290