LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/tcp-server.cpp
// Function: string_to_hex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string string_to_hex(const std::string& input)
{
    static const char hex_digits[] = "0123456789ABCDEF";

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq %rsi, %rsi
callq 0x7760
xorl %r15d, %r15d
leaq 0xafbc(%rip), %r12      # 0x2f0b0
pushq $0x20
popq %rbp
cmpq 0x8(%r14), %r15
jae 0x2413f
movq (%r14), %rax
movb (%rax,%r15), %al
sarb $0x4, %al
movsbq %al, %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x7480
movq (%r14), %rax
movzbl (%rax,%r15), %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x7480
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7480
incq %r15
jmp 0x240f7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2414d
movq %rax, %r14
movq %rbx, %rdi
callq 0x79b8
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x7760
xorl %r15d, %r15d
pushq $0x20
popq %r12
cmpq 0x8(%r14), %r15
jae 0x241b8
movq (%r14), %rax
movsbl (%rax,%r15), %ebp
movl %ebp, %edi
callq 0x7870
testl %eax, %eax
cmovel %r12d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7480
incq %r15
jmp 0x2418e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x241c6
movq %rax, %r14
movq %rbx, %rdi
callq 0x79b8
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/tcp-server.cpp
// Function: handle_new_connection(ServerSocket&, std::__cxx11::list<Client, std::allocator<Client>>&)
int		handle_new_connection(ServerSocket &server, std::list<Client> &clients)
{
	if (clients.size() <= g_webserv.max_connections)
	{
		Client	new_client;
		new_client.sckt = new ServerSocket;
		new_client.req = new Request(server.getServerPort());
		new_client.sckt->setServerPort(server.getServerPort());
		server.Accept(*new_client.sckt);
		clients.push_back(new_client);
		return (Logger::print("New Client Connected ("+new_client.sckt->getIPAddress()+")", new_client.sckt->GetSocket(), SUCCESS, NORMAL));
	}
	else
	{
		return (Logger::print("Connections limit reached, client pending connection.", 0, ERROR, NORMAL));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl 0x1f485(%rip), %eax     # 0x43674
cmpq %rax, 0x10(%rsi)
jbe 0x24229
leaq 0xaedc(%rip), %rsi      # 0x2f0d8
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x8032
leaq 0x30(%rsp), %rdi
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
xorl %esi, %esi
callq 0xf802
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
jmp 0x24304
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x7520
movq %rax, %r15
movq %rax, %rdi
callq 0x26d6c
movq %r15, (%rsp)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x7520
movq %rax, %r12
movq %r14, %rdi
callq 0xf19a
movq %r12, %rdi
movl %eax, %esi
callq 0x274d8
movq %rsp, %r13
movq %r12, 0x8(%r13)
movq %r14, %rdi
callq 0xf19a
movq %r15, %rdi
movl %eax, %esi
callq 0xf11e
movq %r14, %rdi
movq %r15, %rsi
callq 0xf064
movq %rbx, %rdi
movq %r13, %rsi
callq 0x26d96
movq (%r13), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xf1b0
leaq 0xae15(%rip), %rsi      # 0x2f0c1
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0xc30e
leaq 0x8b50(%rip), %rdx      # 0x2ce10
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xbe83
movq (%rsp), %rdi
callq 0xf7fe
leaq 0x50(%rsp), %rdi
pushq $0x1
popq %rcx
movl %eax, %esi
movl %ecx, %edx
callq 0xf802
movl %eax, %ebx
leaq 0x50(%rsp), %rdi
callq 0x79b8
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x70(%rsp), %rdi
callq 0x79b8
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x2434d
movq %rax, %rbx
jmp 0x24357
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x2435c
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
jmp 0x2436e
movq %rax, %rbx
jmp 0x24373
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x79b8
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x70(%rsp), %rdi
callq 0x79b8
jmp 0x24373
movq %rax, %rbx
movl $0x1a0, %esi            # imm = 0x1A0
movq %r12, %rdi
callq 0x7530
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2766a
movq %rdi, %r14
addq $0x8, %rdi
callq 0x7950
movq %r14, %rdi
callq 0x27678
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Request.cpp
// Function: Request::parse_method()
void Request::parse_method()
{
	std::string method = _raw.substr(0, _raw.find(' '));
	if (!g_webserv.methods.hasCandidates(method) || method.empty())
	{
		_error_code = 400;
		throw std::invalid_argument("Method could not be recognized.");
	}
	if (ft::contains(_raw, ' ') && g_webserv.methods.getByType(method) != NULL)
	{
		Logger::print("Request method is " + method + ".", true, INFO, VERBOSE);
		_method = g_webserv.methods.getByType(method);
		_parse_start = _raw.find(' ');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7650
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x7540
leaq 0x1b691(%rip), %r15     # 0x435b0
addq $0x68, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x296f0
cmpq $0x0, 0x10(%rsp)
setne %cl
testb %cl, %al
je 0x27ff5
leaq 0x28(%rsp), %rsi
movb $0x20, (%rsi)
movq %r14, %rdi
callq 0xc288
testb %al, %al
je 0x27fdf
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x21ede
testq %rax, %rax
je 0x27fdf
leaq 0x777f(%rip), %rsi      # 0x2f6ef
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc154
leaq 0x763a(%rip), %rdx      # 0x2f5c0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xbe83
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x26da2
leaq 0x48(%rsp), %rdi
callq 0x79b8
leaq 0x28(%rsp), %rdi
callq 0x79b8
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x21ede
movq %rax, 0x28(%rbx)
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7650
movq %rax, 0x198(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x79b8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x190, 0x188(%rbx)     # imm = 0x190
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x76be(%rip), %rsi      # 0x2f6cf
movq %rax, %rdi
callq 0x7910
movq 0x1afa8(%rip), %rsi     # 0x42fc8
movq 0x1af89(%rip), %rdx     # 0x42fb0
movq %r14, %rdi
callq 0x7830
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x79b8
jmp 0x28041
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x79b8
jmp 0x28061
jmp 0x2805e
movq %rax, %rbx
movq %r14, %rdi
callq 0x73d0
jmp 0x28061
jmp 0x2805e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x7650
cmpq $-0x1, %rax
je 0x28143
movq 0x198(%rbx), %r15
incq %r15
pushq $0x20
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x7650
movq 0x198(%rbx), %rcx
notq %rcx
addq %rax, %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7540
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29036
testb %al, %al
je 0x28152
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1625a
leaq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1695a
leaq 0x28(%rsp), %rdi
callq 0x169e4
movq 0x198(%rbx), %rdx
incq %rdx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x7650
movq %rax, 0x198(%rbx)
movb $0x1, 0x191(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x79b8
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x190, 0x188(%rbx)     # imm = 0x190
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x7594(%rip), %rsi      # 0x2f702
movq %rax, %rdi
callq 0x7910
movq 0x1ae4b(%rip), %rsi     # 0x42fc8
movq 0x1ae2c(%rip), %rdx     # 0x42fb0
movq %r14, %rdi
callq 0x7830
movq %rax, %rbx
movq %r14, %rdi
callq 0x73d0
jmp 0x281ad
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x169e4
jmp 0x281ad
jmp 0x281aa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2905d
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 0x2907c
movq (%rbx), %rax
movb $0x1, %bpl
cmpb $0x2f, (%rax)
je 0x2904e
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x290c6
cmpq $0x8, 0x8(%rbx)
jb 0x290c6
movq %rsp, %r15
pushq $0x7
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x7540
leaq 0x3dad(%rip), %rsi      # 0x2ce58
movq %r15, %rdi
callq 0x91b7
movl %eax, %r12d
movq %r15, %rdi
callq 0x79b8
movb $0x1, %bpl
testb %r12b, %r12b
jne 0x2904e
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x2904e
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x2904c
leaq 0x36d3(%rip), %rsi      # 0x2c7c7
movq %rbx, %rdi
callq 0x91b7
testb %al, %al
je 0x2904c
jmp 0x2904e
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Request.cpp
// Function: is_header_field_finished(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t is_header_field_finished(std::string str)
{
	size_t i = 0;

	while (str.find("\r\n", i) != std::string::npos)
	{
		if (str.find("\r\n", i) == 0)
			return (0);
		if (!str[str.find("\r\n", i) + 2])
			return Logger::print("Header field is not finished", -1, INFO, VERBOSE);
		if (str[str.find("\r\n", i) + 2] != ' ' && str[str.find("\r\n", i) + 2] != '\t')
			return Logger::print("Header field is finished", str.find("\r\n", i) + 2, INFO, VERBOSE);
		i = str.find("\r\n", i) + 2;
	}
	return Logger::print("Header field is not finished", -1, INFO, VERBOSE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x6760(%rip), %r12      # 0x2f880
xorl %r15d, %r15d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
cmpq $-0x1, %rax
je 0x291b0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
testq %rax, %rax
je 0x29259
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
movq (%r14), %rcx
cmpb $0x0, 0x2(%rcx,%rax)
je 0x291e1
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
movq (%r14), %rcx
cmpb $0x20, 0x2(%rcx,%rax)
je 0x29196
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
movq (%r14), %rcx
cmpb $0x9, 0x2(%rcx,%rax)
jne 0x29212
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7980
movq %rax, %r15
addq $0x2, %r15
jmp 0x29123
leaq 0x65e4(%rip), %rsi      # 0x2f79b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf802
movslq %eax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x29254
leaq 0x65b3(%rip), %rsi      # 0x2f79b
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x48(%rsp), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf802
movslq %eax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x29254
leaq 0x659f(%rip), %rsi      # 0x2f7b8
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x6651(%rip), %rsi      # 0x2f880
movq %r14, %rdi
movq %r15, %rdx
callq 0x7980
leaq 0x2(%rax), %rsi
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x29788
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x79b8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x29288
jmp 0x2928f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x29288
jmp 0x2928f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0x29292
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x140(%rsi), %r13
leaq 0x8(%rsp), %r12
cmpq 0x148(%r15), %r13
je 0x2931b
movq (%r13), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0xc2ad
movl %eax, %ebp
movq %r12, %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0x29331
addq $0x8, %r13
jmp 0x292e5
leaq 0x3a2d(%rip), %rsi      # 0x2cd4f
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8032
jmp 0x2937a
movq (%r13), %rdi
callq 0x8964
movq %rax, %r14
movq (%r13), %rdi
callq 0x8964
pushq $0x3a
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x7650
movq %rax, %r15
movq (%r13), %rdi
callq 0x8964
movq 0x8(%rax), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x7540
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7300
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x1695a
movl $0x120, %edi            # imm = 0x120
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x7300
movl $0x158, %edi            # imm = 0x158
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x7300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Request.cpp
// Function: operator<<(std::ostream&, Request const&)
std::ostream& operator<<(std::ostream& out, const Request& request)
{
	if (request._error_code < 400)
	{
		out <<	"Method: " << request._method->getType() << '\n' <<
				"Path: " << request._url._path << '\n' <<
				"Protocol Version: " << request._protocolVersion << '\n' <<
				"Headers: " << std::endl;
		for (Request::HeadersVector::const_iterator it = request._headers.begin(); it != request._headers.end(); it++)
			out << "  \"" << (*it)->getType() << "\" -> \"" << (*it)->getValue() << '"' << std::endl;
		if (request._body.size() < 100)
			out << "Body:\n\"" << request._body << "\"" << std::endl;
		else
			out << "Body:\n\"" << "<<<BODY TOO LONG>>>" << "\"" << std::endl;
	}
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x18f, 0x188(%rsi)     # imm = 0x18F
jg 0x295d1
movq %rsi, %r14
leaq 0x6401(%rip), %rsi      # 0x2f834
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x7510
movq %rax, %rbx
movq 0x28(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74a0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x7590
leaq 0x63cc(%rip), %rsi      # 0x2f83d
movq %rax, %rdi
callq 0x7510
leaq 0xb8(%r14), %rsi
movq %rax, %rdi
callq 0x74a0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x7590
leaq 0x63aa(%rip), %rsi      # 0x2f844
movq %rax, %rdi
callq 0x7510
leaq 0x120(%r14), %rsi
movq %rax, %rdi
callq 0x74a0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x7590
leaq 0x6394(%rip), %rsi      # 0x2f857
movq %rax, %rdi
callq 0x7510
movq %rax, %rdi
callq 0x7280
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x79b8
movq 0x140(%r14), %r12
leaq 0x6377(%rip), %r13      # 0x2f865
pushq $0x22
popq %rbp
cmpq 0x148(%r14), %r12
je 0x29567
movq (%rsp), %rdi
leaq 0x635c(%rip), %rsi      # 0x2f861
callq 0x7510
movq %rax, %rbx
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x7510
movq %rax, %rbx
movq (%r12), %rdi
callq 0x8964
movq %rbx, %rdi
movq %rax, %rsi
callq 0x74a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x7590
movq %rax, %rdi
callq 0x7280
movq %r15, %rdi
callq 0x79b8
addq $0x8, %r12
jmp 0x294f1
cmpq $0x64, 0x160(%r14)
jae 0x29598
addq $0x158, %r14            # imm = 0x158
leaq 0x62ed(%rip), %rsi      # 0x2f86c
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x7510
movq %rax, %rdi
movq %r14, %rsi
callq 0x74a0
jmp 0x295ba
leaq 0x62cd(%rip), %rsi      # 0x2f86c
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x7510
leaq 0x6109(%rip), %rsi      # 0x2f6bb
movq %rax, %rdi
callq 0x7510
leaq 0x62b1(%rip), %rsi      # 0x2f872
movq %rax, %rdi
callq 0x7510
movq %rax, %rdi
callq 0x7280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x295e5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
leaq 0x8(%rdi), %r14
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r14, %rbx
movq (%rbx), %rbx
cmpq %r14, %rbx
je 0x296ac
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x7690
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x29a38
movl %eax, %ebp
movq %r13, %rdi
callq 0x79b8
movq %r12, %rdi
callq 0x79b8
testb %bpl, %bpl
je 0x2965a
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x296ae
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x2975e
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7540
movq %r12, %rdi
movq %r14, %rsi
callq 0xc2ad
movl %eax, %ebp
movq %r12, %rdi
callq 0x79b8
movq %r15, %rdi
callq 0x79b8
testb %bpl, %bpl
je 0x29715
cmpq %rbx, %r13
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x2985d
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x7690
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x29a38
movl %eax, %ebp
movq %r12, %rdi
callq 0x79b8
movq %r15, %rdi
callq 0x79b8
testb %bpl, %bpl
je 0x29816
cmpq %rbx, %r13
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7300
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x2293e
leaq 0x60(%r14), %rsi
leaq 0x60(%rbx), %rdi
callq 0x7300
movl $0x80, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x7300
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_O2/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 %rbx
subq $0x620, %rsp            # imm = 0x620
movq %rdi, %rbx
leaq 0x98(%rsp), %rdi
callq 0x73a0
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x77c0
movq $-0x1c20, %rsi          # imm = 0xE3E0
addq (%r14), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x74f0
leaq 0xb0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x7780
leaq 0x10(%rsp), %r14
movq (%r14), %rdi
leaq 0x2006(%rip), %rsi      # 0x2c359
leaq 0x60(%rsp), %r15
movq %r15, %rdx
callq 0x70a0
movq %r14, %rdi
callq 0x79b8
leaq 0x239f(%rip), %rdx      # 0x2c70e
leaq 0x220(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rcx
callq 0x7440
leaq 0x1df7(%rip), %rsi      # 0x2c182
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8032
leaq 0x30(%rsp), %rdi
leaq 0x220(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x8032
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a124
leaq 0x30(%rsp), %rdi
callq 0x79b8
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x98(%rsp), %rdi
callq 0x73f0
addq $0x620, %rsp            # imm = 0x620
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x79b8
jmp 0x2a403
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x79b8
jmp 0x2a416
jmp 0x2a413
jmp 0x2a413
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x73f0
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, (%rsp)
movq (%rsi), %rbx
leaq 0x38(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x58(%rsp), %r13
cmpq 0x8(%r14), %rbx
je 0x2a962
movq (%rbx), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
callq 0x8104
movq %r13, %rdi
movq %r12, %rsi
callq 0x8150
movq %r15, %rdi
movq %r13, %rsi
callq 0xc2ad
movl %eax, %ebp
movq %r13, %rdi
callq 0x79b8
movq %r12, %rdi
callq 0x8130
movq %r15, %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0x2a8b8
addq $0x8, %rbx
jmp 0x2a85f
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2a962
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x28(%rax)
movq 0x18(%r14), %r12
leaq 0x10(%rsp), %rbx
leaq 0x4fda(%rip), %r14      # 0x2f8bc
leaq 0x2f95(%rip), %r15      # 0x2d87e
cmpq %rbx, %r12
je 0x2a958
leaq 0x28(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x91b7
testb %al, %al
je 0x2a920
movss 0x20(%r12), %xmm0
movq 0x20(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x2a920
jp 0x2a920
movq (%rsp), %rax
movb $0x1, 0xd(%rax)
jmp 0x2a94b
movq %r13, %rdi
movq %r15, %rsi
callq 0x91b7
testb %al, %al
je 0x2a94b
movss 0x20(%r12), %xmm0
movq 0x20(%rsp), %rax
ucomiss 0x20(%rax), %xmm0
jne 0x2a94b
jp 0x2a94b
movq (%rsp), %rax
movb $0x1, 0xc(%rax)
movq %r12, %rdi
callq 0x7580
movq %rax, %r12
jmp 0x2a8e9
leaq 0x8(%rsp), %rdi
callq 0x8ffa
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8130
jmp 0x2a983
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
leaq 0x177b8(%rip), %rax     # 0x42d48
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1f16e
leaq 0x120(%rbx), %rax
movq %rax, 0x128(%rbx)
movq %rax, 0x8(%rsp)
movq %rax, 0x120(%rbx)
andq $0x0, 0x130(%rbx)
leaq 0x3761(%rip), %rsi      # 0x2ed29
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x8032
leaq 0x20(%rsp), %rsi
movq %r14, (%rsp)
movq %r14, %rdi
callq 0x2167a
movq %rax, %r12
leaq 0x20(%rsp), %rdi
callq 0x79b8
leaq 0x40(%rsp), %r13
leaq 0x17faf(%rip), %r14     # 0x435b0
leaq 0x18(%r14), %rbp
addq $0x20, %r14
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x2b67c
leaq 0x10(%r15), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1709a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2b8d8
cmpq %r14, %rax
jne 0x2b663
pushq $0x60
popq %rdi
callq 0x7520
movq %rax, %rbx
movl 0x40(%rsp), %esi
movq %rax, %rdi
callq 0xebc4
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b92a
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2b836
leaq 0x20(%rsp), %rdi
callq 0x79b8
jmp 0x2b60c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b6ab
movq %rax, %r15
jmp 0x2b6bc
movq %rax, %r15
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x7530
jmp 0x2b6ae
jmp 0x2b6ab
movq %rax, %r15
jmp 0x2b6b8
jmp 0x2b6ab
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x79b8
movq (%rsp), %r14
movq 0x8(%rsp), %rdi
callq 0x2b884
movq %r14, %rdi
callq 0x1f0f0
movq %r15, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
andq $0x0, 0x10(%r14)
leaq 0xc(%rsp), %r12
movl %esi, (%r12)
movq %rsp, %r13
movq %rdx, %rbp
movq (%rbp), %rbp
cmpq %r15, %rbp
je 0x2b789
leaq 0x130(%rbp), %rdi
movq %r12, %rsi
callq 0x2b85e
testb %al, %al
je 0x2b758
leaq 0x10(%rbp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2b878
jmp 0x2b758
movq 0x10(%rsp), %r15
cmpq %r14, %r15
je 0x2b7de
cmpq %r14, %r15
je 0x2b7b9
movq 0x10(%r15), %rdi
addq $0x8, %rdi
callq 0x2165c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21df4
testb %al, %al
jne 0x2b7be
movq (%r15), %r15
jmp 0x2b793
movq 0x10(%rsp), %r15
movq 0x10(%r15), %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b8ae
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x40e5(%rip), %rsi      # 0x2f8d5
movq %rax, %rdi
callq 0x7910
movq 0x177c9(%rip), %rsi     # 0x42fc8
movq 0x177aa(%rip), %rdx     # 0x42fb0
movq %r14, %rdi
callq 0x7830
jmp 0x2b821
movq %rax, %rbx
movq %r14, %rdi
callq 0x73d0
jmp 0x2b824
jmp 0x2b821
jmp 0x2b821
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b8ae
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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, %rax
movq (%rdx), %rcx
movl %esi, (%rcx,%rax,4)
pushq $0x1
popq %r12
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dc4
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jae 0x23cd
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dc4
movq (%rax), %rax
movslq (%rax,%r13,4), %rdi
movq (%r14), %rax
cmpl $-0x1, (%rax,%rdi,4)
jne 0x23c8
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x235c
addl %eax, %r12d
incq %r13
jmp 0x2382
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_O2/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
orl $-0x1, (%rdx)
callq 0x283e
pushq $-0x1
popq %rbp
pushq $0x1
popq %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x2445
movq (%r14), %rax
cmpl $-0x1, (%rax,%r12,4)
jne 0x2440
movl %r12d, %edi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x235c
cmpl %r13d, %eax
cmovgl %eax, %r13d
cmovgl %r15d, %ebp
incl %r15d
incq %r12
jmp 0x240e
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_O2/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 %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jae 0x24b9
cmpl %ebp, (%rax,%r13,4)
jne 0x24b4
incl %ebx
movq %r15, %rdi
movl %r13d, %esi
callq 0x2dc4
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
addl %ecx, %r14d
incq %r13
jmp 0x247e
cvtsi2sd %r14d, %xmm0
mulsd 0x2b42(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %eax
movq 0x8(%rsp), %rcx
movl %ebx, (%rcx)
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %eax
leaq 0x5c46(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c92(%rip), %rsi      # 0x9060
leaq -0xd(%rbp), %rdx
jmp 0x3406
leaq 0x5ca2(%rip), %rsi      # 0x907d
leaq -0x9(%rbp), %rdx
jmp 0x3406
leaq 0x5c86(%rip), %rsi      # 0x906e
leaq -0xb(%rbp), %rdx
jmp 0x3406
leaq 0x5c80(%rip), %rsi      # 0x9075
leaq -0xa(%rbp), %rdx
jmp 0x3406
leaq 0x5c65(%rip), %rsi      # 0x9067
leaq -0xc(%rbp), %rdx
movq %rbx, %rdi
callq 0x5820
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %r15
movslq %esi, %rbx
movsbl (%r15,%rbx), %edi
callq 0x3040
testl %eax, %eax
je 0x3690
cmpq 0x8(%r14), %rbx
je 0x3690
incq %rbx
jmp 0x3677
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
leaq 0x5b46(%rip), %r12      # 0x9207
leaq -0x88(%rbp), %r13
leaq -0x50(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x5820
movl $0x2, 0x20(%r13)
movl %r14d, 0x24(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r12, %rsi
callq 0x5820
movslq %r14d, %rax
movq (%r15), %rcx
movb (%rcx,%rax), %al
movzbl %al, %ecx
leal -0x2c(%rcx), %edx
cmpl $0x31, %edx
ja 0x3776
movabsq $0x2800000004001, %rsi  # imm = 0x2800000004001
btq %rdx, %rsi
jae 0x3776
movsbl %al, %esi
leaq -0x88(%rbp), %rdi
callq 0x7ab6
incl %r14d
movl %r14d, -0x30(%rbp)
leaq 0x5acb(%rip), %rcx      # 0x9207
leaq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x5f26
leaq -0x50(%rbp), %rdi
callq 0x585c
leaq -0x88(%rbp), %rdi
callq 0x5870
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7d, %ecx
je 0x371f
cmpl $0x7b, %ecx
je 0x371f
jmp 0x3735
movq %rax, %rbx
jmp 0x3793
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x585c
leaq -0x88(%rbp), %rdi
callq 0x5870
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_string(std::string raw_json,
                                                   int original_index) {
  int index = original_index;
  JSONToken token{"", JSONTokenType::String, index};
  std::string value = "";
  auto c = raw_json[index];
  if (c != '"') {
    return {token, original_index, ""};
  }
  index++;

  // TODO: handle nested quotes
  while (c = raw_json[index], c != '"') {
    if (index == raw_json.length()) {
      return {
          token, index,
          format_error("Unexpected EOF while lexing string", raw_json, index)};
    }

    token.value += c;
    index++;
  }
  index++;

  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x34(%rbp)
movl %edx, -0x2c(%rbp)
leaq 0x5a36(%rip), %r12      # 0x9207
leaq -0xf0(%rbp), %r13
leaq -0xb8(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x5820
andl $0x0, 0x20(%r13)
movl %r15d, 0x24(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r12, %rsi
callq 0x5820
movslq %r15d, %rax
movq (%r14), %rcx
cmpb $0x22, (%rcx,%rax)
jne 0x384b
leaq -0xf0(%rbp), %r15
movslq -0x2c(%rbp), %rax
leaq 0x1(%rax), %rdx
movl %edx, -0x2c(%rbp)
movq (%r14), %rcx
movb 0x1(%rcx,%rax), %cl
cmpb $0x22, %cl
je 0x3851
cmpq %rdx, 0x8(%r14)
je 0x3872
movsbl %cl, %esi
movq %r15, %rdi
callq 0x7ab6
jmp 0x3821
leaq -0x34(%rbp), %rdx
jmp 0x385a
addl $0x2, %eax
leaq -0x2c(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x59a6(%rip), %rcx      # 0x9207
leaq -0xf0(%rbp), %rsi
movq %rbx, %rdi
callq 0x5f26
jmp 0x38e1
leaq 0x5822(%rip), %rsi      # 0x909b
leaq -0x98(%rbp), %rdi
leaq -0x2d(%rbp), %rdx
callq 0x5820
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x5890
movl -0x2c(%rbp), %ecx
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x3418
leaq -0xf0(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x58(%rbp), %rcx
movq %rbx, %rdi
callq 0x5f9a
leaq -0x58(%rbp), %rdi
callq 0x585c
leaq -0x78(%rbp), %rdi
callq 0x585c
leaq -0x98(%rbp), %rdi
callq 0x585c
leaq -0xb8(%rbp), %rdi
callq 0x585c
leaq -0xf0(%rbp), %rdi
callq 0x5870
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x585c
jmp 0x391f
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x585c
jmp 0x392d
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x585c
jmp 0x3947
jmp 0x3944
jmp 0x3944
movq %rax, %rbx
jmp 0x3953
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x585c
leaq -0xf0(%rbp), %rdi
callq 0x5870
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x30(%rbp)
leaq 0x587c(%rip), %r12      # 0x9207
leaq -0x88(%rbp), %r13
leaq -0x50(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x5820
movl $0x1, 0x20(%r13)
movl %r15d, 0x24(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r12, %rsi
callq 0x5820
movslq %r15d, %r12
leaq -0x88(%rbp), %r15
cmpq 0x8(%r14), %r12
je 0x39f8
movq (%r14), %rax
movb (%rax,%r12), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jae 0x39f8
movsbl %al, %esi
movq %r15, %rdi
callq 0x7ab6
incq %r12
movl %r12d, -0x30(%rbp)
jmp 0x39cf
leaq 0x5808(%rip), %rcx      # 0x9207
leaq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x5f26
leaq -0x50(%rbp), %rdi
callq 0x585c
leaq -0x88(%rbp), %rdi
callq 0x5870
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a40
movq %rax, %rbx
jmp 0x3a4c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x585c
leaq -0x88(%rbp), %rdi
callq 0x5870
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_keyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, json::JSONTokenType, int)
std::tuple<JSONToken, int, std::string> lex_keyword(std::string raw_json,
                                                    std::string keyword,
                                                    JSONTokenType type,
                                                    int original_index) {
  int index = original_index;
  JSONToken token{"", type, index};
  while (keyword[index - original_index] == raw_json[index]) {
    if (index == raw_json.length()) {
      break;
    }

    index++;
  }

  if (index - original_index == keyword.length()) {
    token.value = keyword;
  }
  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
leaq 0x577b(%rip), %rsi      # 0x9207
leaq -0x70(%rbp), %rbx
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x5820
movl %r13d, 0x20(%rbx)
movl %r12d, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq (%r14), %rax
movslq %r12d, %rcx
movq (%r15), %rdx
addq %rcx, %rdx
leal 0x1(%rcx), %esi
xorl %edi, %edi
movb (%rax,%rdi), %r8b
cmpb (%rdx,%rdi), %r8b
jne 0x3add
leaq (%rcx,%rdi), %r8
cmpq 0x8(%r15), %r8
je 0x3add
leal (%rsi,%rdi), %r8d
movl %r8d, -0x30(%rbp)
incq %rdi
jmp 0x3abc
cmpq %rdi, 0x8(%r14)
movq -0x38(%rbp), %rbx
jne 0x3af3
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x7b1a
leaq 0x570d(%rip), %rcx      # 0x9207
leaq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x5f26
leaq -0x70(%rbp), %rdi
callq 0x5870
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x5870
movq %rbx, %rdi
callq 0x3260