LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::get_last_modified_format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string GetMethod::get_last_modified_format(const std::string& realPath, const std::string& format)
{
	struct stat st;
	if (lstat(realPath.c_str(), &st) < 0)
		return "-";
	std::ostringstream convert;
	struct tm	time;
	strptime(std::string(convert.str()).c_str(), "%s", &time);
	convert << st.st_mtime;
	strptime(std::string(convert.str()).c_str(), "%s", &time);
	char		buffer[1024];
	strftime(buffer, sizeof(buffer), format.c_str(), &time);
	convert.str("");
	return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x668, %rsp            # imm = 0x668
movq %rcx, %r15
movq %rdi, %rbx
movq (%rdx), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x78e0
testl %eax, %eax
js 0xa7f8
leaq 0x58(%rsp), %rdi
callq 0x75e0
leaq 0x60(%rsp), %r14
leaq 0x260(%rsp), %rdi
movq %r14, %rsi
callq 0x7710
leaq 0x270(%rsp), %r12
movq -0x10(%r12), %rdi
leaq 0x2fccc(%rip), %rsi     # 0x3a3a5
leaq 0x20(%rsp), %rdx
callq 0x70b0
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xa6fd
movq 0x270(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x228(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x7470
leaq 0x260(%rsp), %rdi
movq %r14, %rsi
callq 0x7710
movq 0x260(%rsp), %rdi
leaq 0x2fc77(%rip), %rsi     # 0x3a3a5
leaq 0x20(%rsp), %rdx
callq 0x70b0
movq 0x260(%rsp), %rdi
cmpq %r12, %rdi
je 0xa755
movq 0x270(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r15), %rdx
leaq 0x260(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x73f0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3061c(%rip), %rdx     # 0x3ad9b
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x80f4
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7690
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa7ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x260(%rsp), %r14
movq %r14, %rdi
callq 0x7220
leaq (%rsp,%rax), %rdx
addq $0x260, %rdx            # imm = 0x260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80f4
movq 0x437c1(%rip), %rsi     # 0x4dfa0
leaq 0x58(%rsp), %rdi
callq 0x72b0
leaq 0xc8(%rsp), %rdi
callq 0x71c0
jmp 0xa815
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x303f2(%rip), %rsi     # 0x3abf8
leaq 0x303ec(%rip), %rdx     # 0x3abf9
movq %rbx, %rdi
callq 0x80f4
movq %rbx, %rax
addq $0x668, %rsp            # imm = 0x668
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa84a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa84d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0xa84d
jmp 0xa84a
jmp 0xa84a
jmp 0xa84a
movq %rax, %rbx
movq 0x4374c(%rip), %rsi     # 0x4dfa0
leaq 0x58(%rsp), %rdi
callq 0x72b0
leaq 0xc8(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::get_file_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string GetMethod::get_file_size(const std::string& realPath)
{
	struct stat st;
	if (lstat(realPath.c_str(), &st) < 0)
		return "-";
	std::ostringstream convert;
	convert << st.st_size;
	return convert.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rdx), %rdi
leaq 0x178(%rsp), %rsi
callq 0x78e0
testl %eax, %eax
js 0xa8d8
movq %rsp, %r14
movq %r14, %rdi
callq 0x75e0
movq 0x1a8(%rsp), %rsi
movq %r14, %rdi
callq 0x7470
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7710
movq 0x436dc(%rip), %rsi     # 0x4dfa0
movq %rsp, %rdi
callq 0x72b0
leaq 0x70(%rsp), %rdi
callq 0x71c0
jmp 0xa8f5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x30312(%rip), %rsi     # 0x3abf8
leaq 0x3030c(%rip), %rdx     # 0x3abf9
movq %rbx, %rdi
callq 0x80f4
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x43693(%rip), %rsi     # 0x4dfa0
movq %rsp, %rdi
callq 0x72b0
leaq 0x70(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::process_cgi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, URL const&, ConfigContext const&, ServerSocket const&, Request const&)
Response GetMethod::process_cgi(const std::string& realPath, const URL& url, const ConfigContext& config, const ServerSocket& socket, const Request& request)
{
	Response response(200, url._path);
	if (!request.getHeaderValue("Accept-Encoding").empty())
		response.setCompression(request._headers);
	try
	{
		CGI	cgi(request, config, socket, realPath);
		cgi.process(response);
	}
	catch(const CGI::CGIException &e)
	{
		Logger::print(e.what(), NULL, ERROR, NORMAL);
		response.setCode(e.code());
	}
	return (response);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, %r14
movq %r8, %r12
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x88(%rcx), %rdx
movl $0xc8, %esi
callq 0x36f58
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c3b5(%rip), %rsi     # 0x3a055
leaq 0x2c3bd(%rip), %rdx     # 0x3a064
leaq 0x8(%rsp), %rdi
movq %rbx, (%rsp)
callq 0x80f4
movq 0x1a0(%rsp), %r13
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r13, %rsi
callq 0x35bbe
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %rbx
cmpq %rax, %rdi
je 0xdcee
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xdd05
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testq %rbx, %rbx
movq (%rsp), %rbx
je 0xdd1d
leaq 0x140(%r13), %rsi
movq %rbx, %rdi
callq 0x37b0e
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x13518
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x15fb0
leaq 0x48(%rsp), %rdi
callq 0x15872
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xde51
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x15872
jmp 0xdd7c
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xde54
movq %r14, %rdi
callq 0x7210
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rax, %rsi
callq 0xde66
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0xdea4
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdddd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rsp), %rdi
movl %eax, %esi
callq 0x37aee
movq (%rsp), %rbx
callq 0x7780
jmp 0xdd4a
jmp 0xde51
jmp 0xde23
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xde26
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0xde26
movq %rax, %r14
callq 0x7780
jmp 0xde54
movq %rax, %rdi
callq 0x96aa
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xde54
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0xde54
movq %rax, %r14
movq (%rsp), %rdi
callq 0x36d9a
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Methods/TraceMethod.cpp
// Function: TraceMethod::process(Request const&, ConfigContext const&, ServerSocket const&)
Response TraceMethod::process(const Request& request, const ConfigContext&, const ServerSocket&)
{
	const URL& url = request._url;
	Response response(200, url._path);
	response.addHeader("Content-Type", "message/http; charset=UTF-8");
	response.addHeader("Server", "Webserv");
	response.addDateHeader();
	response.setBody(request._raw);
	return response;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0xb8, %rdx
movl $0xc8, %esi
callq 0x36f58
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28a1c(%rip), %rsi     # 0x3a152
leaq 0x28a21(%rip), %rdx     # 0x3a15e
leaq 0x28(%rsp), %rdi
callq 0x80f4
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2912c(%rip), %rsi     # 0x3a884
leaq 0x29140(%rip), %rdx     # 0x3a89f
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x37020
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11792
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x117a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x28adf(%rip), %rsi     # 0x3a297
leaq 0x28ade(%rip), %rdx     # 0x3a29d
callq 0x80f4
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x29409(%rip), %rsi     # 0x3abdc
leaq 0x29409(%rip), %rdx     # 0x3abe3
callq 0x80f4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x37020
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11808
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1181f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x373a0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37b04
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1184b
jmp 0x11867
jmp 0x11885
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1186a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1186a
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x11888
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x11888
jmp 0x11885
movq %rax, %r14
movq %rbx, %rdi
callq 0x36d9a
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/ClientSocket.cpp
// Function: ClientSocket::ClientSocket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
ClientSocket::ClientSocket(const std::string &host, int port)
{
	if (!Socket::Create(false))
    {
		throw ClientSocketException("Could not create client socket.");
    }
	if (!Socket::Connect(host, port))
    {
		throw ClientSocketException("Could not Connect to host.");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x124dc
leaq 0x3c1b2(%rip), %rax     # 0x4da80
movq %rax, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1261a
testb %al, %al
je 0x118fd
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1281a
testb %al, %al
je 0x11956
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28f93(%rip), %rsi     # 0x3a8ae
leaq 0x28fab(%rip), %rdx     # 0x3a8cd
leaq 0x20(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11b94
xorl %ebp, %ebp
leaq 0x3c163(%rip), %rsi     # 0x4daa8
leaq 0x292(%rip), %rdx       # 0x11bde
movq %r15, %rdi
callq 0x77d0
jmp 0x119a9
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28f5a(%rip), %rsi     # 0x3a8ce
leaq 0x28f6d(%rip), %rdx     # 0x3a8e8
movq %rsp, %rdi
callq 0x80f4
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x11b94
xorl %ebp, %ebp
leaq 0x3c10e(%rip), %rsi     # 0x4daa8
leaq 0x23d(%rip), %rdx       # 0x11bde
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x119d8
movq 0x10(%rsp), %rsi
jmp 0x119d0
jmp 0x119df
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x119d8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bpl, %bpl
jne 0x119e2
jmp 0x119ef
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x119ef
movq %rax, %r14
movq %rbx, %rdi
callq 0x12584
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::ServerSocket(int)
ServerSocket::ServerSocket(int port) : m_port(port)
{
	if (!Socket::Create(true))
		throw ServerSocketException("Counldn't create socket.");
	if (!Socket::Bind(this->m_port))
		throw ServerSocketException("Counldn't bind to port.");
	if (!Socket::Listen())
		throw ServerSocketException("Counldn't listen to socket.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x124dc
leaq 0x3bead(%rip), %rax     # 0x4daf8
movq %rax, (%rbx)
movl %ebp, 0x3c(%rbx)
leaq 0x50(%rbx), %r12
movq %r12, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1261a
testb %al, %al
je 0x11ca4
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x1269c
testb %al, %al
je 0x11cff
movq %rbx, %rdi
callq 0x12a3e
testb %al, %al
je 0x11d57
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28c95(%rip), %rsi     # 0x3a956
leaq 0x28ca6(%rip), %rdx     # 0x3a96e
leaq 0x48(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3be35(%rip), %rsi     # 0x4db20
leaq 0x72c(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
jmp 0x11dad
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28c53(%rip), %rsi     # 0x3a96f
leaq 0x28c63(%rip), %rdx     # 0x3a986
leaq 0x28(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3bdda(%rip), %rsi     # 0x4db20
leaq 0x6d1(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
jmp 0x11dad
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28c13(%rip), %rsi     # 0x3a987
leaq 0x28c27(%rip), %rdx     # 0x3a9a2
leaq 0x8(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3bd82(%rip), %rsi     # 0x4db20
leaq 0x679(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11df3
movq 0x18(%rsp), %rsi
jmp 0x11deb
jmp 0x11dfa
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x11df3
movq 0x38(%rsp), %rsi
jmp 0x11deb
jmp 0x11dfa
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x11df3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bpl, %bpl
jne 0x11dfd
jmp 0x11e0a
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x11e0a
movq %rax, %r14
movq 0x40(%rbx), %rdi
cmpq %r12, %rdi
je 0x11e1f
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x12584
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::ServerSocket(ServerSocket const&)
ServerSocket::ServerSocket(const ServerSocket &src) : m_port(src.m_port)
{
	if (!Socket::Create(true))
		throw ServerSocketException("Counldn't create socket.");
	if (!Socket::Bind(this->m_port))
		throw ServerSocketException("Counldn't bind to port.");
	if (!Socket::Listen())
		throw ServerSocketException("Counldn't listen to socket.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x124dc
leaq 0x3bca8(%rip), %rax     # 0x4daf8
movq %rax, (%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
leaq 0x50(%rbx), %r12
movq %r12, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1261a
testb %al, %al
je 0x11ead
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x1269c
testb %al, %al
je 0x11f08
movq %rbx, %rdi
callq 0x12a3e
testb %al, %al
je 0x11f60
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28a8c(%rip), %rsi     # 0x3a956
leaq 0x28a9d(%rip), %rdx     # 0x3a96e
leaq 0x48(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3bc2c(%rip), %rsi     # 0x4db20
leaq 0x523(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
jmp 0x11fb6
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28a4a(%rip), %rsi     # 0x3a96f
leaq 0x28a5a(%rip), %rdx     # 0x3a986
leaq 0x28(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3bbd1(%rip), %rsi     # 0x4db20
leaq 0x4c8(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
jmp 0x11fb6
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28a0a(%rip), %rsi     # 0x3a987
leaq 0x28a1e(%rip), %rdx     # 0x3a9a2
leaq 0x8(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x123d4
xorl %ebp, %ebp
leaq 0x3bb79(%rip), %rsi     # 0x4db20
leaq 0x470(%rip), %rdx       # 0x1241e
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ffc
movq 0x18(%rsp), %rsi
jmp 0x11ff4
jmp 0x12003
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ffc
movq 0x38(%rsp), %rsi
jmp 0x11ff4
jmp 0x12003
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ffc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %bpl, %bpl
jne 0x12006
jmp 0x12013
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x12013
movq %rax, %r14
movq 0x40(%rbx), %rdi
cmpq %r12, %rdi
je 0x12028
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x12584
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::setServerPort(int)
void					ServerSocket::setServerPort(int port)
{
	m_port = port;
	std::ostringstream	convert;
	convert << m_port;
	m_port_str = convert.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
movl %esi, 0x3c(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x75e0
movl 0x3c(%rbx), %esi
movq %r14, %rdi
callq 0x77e0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7710
addq $0x40, %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x12333
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x3bc66(%rip), %rsi     # 0x4dfa0
leaq 0x20(%rsp), %rdi
callq 0x72b0
leaq 0x90(%rsp), %rdi
callq 0x71c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x1235e
movq %rax, %rbx
movq 0x3bc38(%rip), %rsi     # 0x4dfa0
leaq 0x20(%rsp), %rdi
callq 0x72b0
leaq 0x90(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::operator=(Socket const&)
Socket &				Socket::operator=(Socket const &rhs)
{
	if (this != &rhs)
	{
		this->m_ipaddr = rhs.m_ipaddr;
		this->m_sockfd = rhs.m_sockfd;
		this->m_addr_in = rhs.m_addr_in;
	}
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1260e
movq %rsi, %r14
addq $0x8, %rsi
leaq 0x8(%rbx), %rdi
callq 0x72c0
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x2c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Bind(int)
bool					Socket::Bind(int const port)
{
	if (!this->Success())
		return (false);
	this->m_addr_in.sin_family = AF_INET;
	this->m_addr_in.sin_addr.s_addr = INADDR_ANY;
	this->m_addr_in.sin_port = htons(port);
	if (bind(this->m_sockfd, reinterpret_cast<sockaddr*>(&this->m_addr_in), sizeof(this->m_addr_in)) != 0)
		return (false);
	this->m_ipaddr = my_inet_ntoa(this->m_addr_in.sin_addr);
	return (true);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %edi
cmpl $-0x1, %edi
je 0x126d8
leaq 0x2c(%rbx), %rax
movw $0x2, 0x2c(%rbx)
movl $0x0, 0x30(%rbx)
rolw $0x8, %si
movw %si, 0x2e(%rbx)
movq %rax, %rsi
movl $0x10, %edx
callq 0x70d0
testl %eax, %eax
je 0x126dc
xorl %eax, %eax
jmp 0x12717
movl 0x30(%rbx), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1271f
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12715
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: my_inet_ntoa[abi:cxx11](in_addr)
static std::string		my_inet_ntoa(struct in_addr in)
{
	std::stringstream ss;
	unsigned char *bytes = reinterpret_cast<unsigned char *>(&in);
	ss << static_cast<int>(bytes[0]) << "." << static_cast<int>(bytes[1]) << "." << static_cast<int>(bytes[2]) << "." << static_cast<int>(bytes[3]);
	return (ss.str());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7360
leaq 0x18(%rsp), %rdi
movzbl %bpl, %esi
callq 0x77e0
movq %rax, %r14
leaq 0x2aedf(%rip), %rsi     # 0x3d630
movl $0x1, %edx
movq %rax, %rdi
callq 0x7510
movl %ebp, %eax
shrl $0x8, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0x77e0
movq %rax, %r14
leaq 0x2aeb8(%rip), %rsi     # 0x3d630
movl $0x1, %edx
movq %rax, %rdi
callq 0x7510
movl %ebp, %eax
shrl $0x10, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0x77e0
movq %rax, %r14
leaq 0x2ae91(%rip), %rsi     # 0x3d630
movl $0x1, %edx
movq %rax, %rdi
callq 0x7510
shrl $0x18, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x77e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7710
movq 0x3b7a3(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3b776(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Accept(Socket&)
bool					Socket::Accept(Socket &connection)
{
	int	addr_length = sizeof(this->m_addr_in);
	connection.m_sockfd = accept(this->m_sockfd, reinterpret_cast<sockaddr *>(&this->m_addr_in), reinterpret_cast<socklen_t*>(&addr_length));
	if (connection.m_sockfd <= 0)
		return (false);
	connection.m_ipaddr = my_inet_ntoa(this->m_addr_in.sin_addr);
	return (true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x28(%rdi), %edi
leaq 0x2c(%r15), %rsi
callq 0x71a0
movl %eax, %ebx
movl %eax, 0x28(%r14)
testl %eax, %eax
jle 0x12aca
movl 0x30(%r15), %esi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1271f
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7590
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x12aca
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
testl %ebx, %ebx
setg %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Recieve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int						Socket::Recieve(std::string &str) const
{
	char	buff[MAX_RECIEVE + 1];

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10028, %rsp          # imm = 0x10028
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
leaq 0x28280(%rip), %rcx     # 0x3ad9b
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x76f0
leaq 0x20(%rsp), %r15
movl $0xffff, %esi           # imm = 0xFFFF
movq %r15, %rdi
callq 0x1d5ec
movl 0x28(%rbx), %edi
movl $0xfffe, %edx           # imm = 0xFFFE
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x71b0
movq %rax, %rbx
testl %ebx, %ebx
je 0x12bcc
cmpl $-0x1, %ebx
jne 0x12ba8
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x27eb8(%rip), %rsi     # 0x3aa20
leaq 0x27ec9(%rip), %rdx     # 0x3aa38
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x80f4
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x12c02
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12bcc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x12bcc
movq 0x8(%r14), %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x7220
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x76f0
movl %ebx, %eax
addq $0x10028, %rsp          # imm = 0x10028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12bf6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/CGI.cpp
// Function: CGI::ParseURI(Request const&, ConfigContext const&)
int	CGI::ParseURI(const Request& req, const ConfigContext& config)
{
	std::string	cgi_path = config.getParam("cgi_dir").front();

	m_env_Script_Name = find_first_file(req._url._path, config);
	if (m_env_Script_Name.empty())
		m_env_Script_Name = req._url._path; //return (404); (tester pass...)
	m_env_Path_Info = m_realPath.substr(m_realPath.find(m_env_Script_Name) + m_env_Script_Name.size());
	if (m_env_Path_Info.empty())
		m_env_Path_Info = "";
	else if (m_env_Path_Info[m_env_Path_Info.size() - 1] == '/')
		m_env_Path_Info.erase(m_env_Path_Info.size() - 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x25c3e(%rip), %rsi     # 0x3a70d
leaq 0x25c3e(%rip), %rdx     # 0x3a714
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2b17e
movq (%rax), %rax
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x8a92
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14b25
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x15954
leaq 0x40(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7590
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14b5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
jne 0x14b7e
addq $0xb8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x72c0
movq 0x48(%rbx), %rcx
leaq 0xc0(%rbx), %r14
movq 0x40(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x77f0
addq 0x48(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x74d0
leaq 0x60(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7590
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x14bd7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x14bf7
movq (%r14), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
jne 0x14c0d
decq %rax
movq %rax, 0x68(%rbx)
movb $0x0, (%rcx,%rax)
jmp 0x14c0d
leaq 0x2619d(%rip), %rcx     # 0x3ad9b
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x76f0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x14c24
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14c39
jmp 0x14c39
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x14c6c
movq 0x38(%rsp), %rsi
jmp 0x14c64
movq %rax, %rbx
jmp 0x14c6c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14c6c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/CGI.cpp
// Function: CGI::VectorToArray()
void	CGI::VectorToArray(void)
{
	m_c_env = new char*[m_env.size() + 1];
	for (size_t i = 0; i < m_env.size(); i++)
	{
		m_c_env[i] = new char[m_env[i].length() + 1];
		ft::strncpy(m_c_env[i], m_env[i].c_str(), m_env[i].size() + 1);
	}
	m_c_env[m_env.size()] = NULL;
	m_c_args = new char*[m_args.size() + 1];
	for (size_t i = 0; i < m_args.size(); i++)
	{
		m_c_args[i] = new char[m_args[i].size() + 1];
		ft::strncpy(m_c_args[i], m_args[i].c_str(), m_args[i].size() + 1);
	}
	m_c_args[m_args.size()] = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
movq 0x100(%rdi), %r13
movq %r13, %r12
subq %r15, %r12
sarq $0x5, %r12
leaq 0x1(%r12), %rax
shrq $0x3d, %rax
leaq 0x8(,%r12,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movabsq $0x1fffffffffffffff, %r14 # imm = 0x1FFFFFFFFFFFFFFF
movq %rax, 0x118(%rbx)
cmpq %r15, %r13
je 0x15ee3
movl $0x1, %r13d
xorl %ebp, %ebp
movq (%r15,%r13,8), %rdi
incq %rdi
callq 0x7030
movq 0x118(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0xf8(%rbx), %rax
movq 0x118(%rbx), %rcx
movq (%rcx,%rbp,8), %rdi
movq -0x8(%rax,%r13,8), %rsi
movq (%rax,%r13,8), %rdx
incq %rdx
callq 0x1d5ac
incq %rbp
movq 0xf8(%rbx), %r15
movq 0x100(%rbx), %r12
subq %r15, %r12
sarq $0x5, %r12
addq $0x4, %r13
cmpq %r12, %rbp
jb 0x15e81
movq 0x118(%rbx), %rax
movq $0x0, (%rax,%r12,8)
movq 0xe0(%rbx), %r12
movq 0xe8(%rbx), %r15
movq %r15, %r13
subq %r12, %r13
sarq $0x5, %r13
leaq 0x1(%r13), %rax
cmpq %r14, %rax
leaq 0x8(,%r13,8), %rax
movq $-0x1, %rdi
cmovbeq %rax, %rdi
callq 0x7030
movq %rax, 0x110(%rbx)
cmpq %r12, %r15
je 0x15f99
movl $0x1, %r14d
xorl %r15d, %r15d
movq (%r12,%r14,8), %rdi
incq %rdi
callq 0x7030
movq 0x110(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xe0(%rbx), %rax
movq 0x110(%rbx), %rcx
movq (%rcx,%r15,8), %rdi
movq -0x8(%rax,%r14,8), %rsi
movq (%rax,%r14,8), %rdx
incq %rdx
callq 0x1d5ac
incq %r15
movq 0xe0(%rbx), %r12
movq 0xe8(%rbx), %r13
subq %r12, %r13
sarq $0x5, %r13
addq $0x4, %r14
cmpq %r13, %r15
jb 0x15f37
movq 0x110(%rbx), %rax
movq $0x0, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Compress.cpp
// Function: compress_gzip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
std::string compress_gzip(const std::string &str, unsigned int compressionlevel)
{
	z_stream zs;
	ft::memset(&zs, 0, sizeof(zs));
	if (deflateInit2(&zs, compressionlevel, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY) != Z_OK)
		throw(std::runtime_error("deflateInit2() failed."));

	zs.next_in = (Bytef*)str.data();
	zs.avail_in = str.size();
	int ret;
	char outbuffer[32768];
	std::string outstring;

	do {
		zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
		zs.avail_out = sizeof(outbuffer);
		ret = deflate(&zs, Z_FINISH);
		if (outstring.size() < zs.total_out) {
			outstring.append(outbuffer,
			zs.total_out - outstring.size());
		}
	} while (ret == Z_OK);
	deflateEnd(&zs);

	if (ret != Z_STREAM_END)
		throw(std::runtime_error("Exception during zlib compression."));
	return (outstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x8070, %rsp           # imm = 0x8070
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movl $0x70, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d5df
leaq 0x23ee1(%rip), %rax     # 0x3acdd
movq %r14, %rdi
movl %ebp, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x9, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x70a0
addq $0x10, %rsp
testl %eax, %eax
jne 0x16ea3
movq (%r15), %rax
movq %rsp, %r14
movq %rax, (%r14)
movl 0x8(%r15), %eax
movl %eax, 0x8(%r14)
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x70(%rsp), %r15
movq %r15, 0x18(%rsp)
movl $0x8000, 0x20(%rsp)     # imm = 0x8000
movq %r14, %rdi
movl $0x4, %esi
callq 0x7230
movl %eax, %ebp
movq 0x28(%rsp), %rdx
subq 0x8(%rbx), %rdx
jbe 0x16e7f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70c0
testl %ebp, %ebp
je 0x16e4d
movq %rsp, %rdi
callq 0x7300
cmpl $0x1, %ebp
jne 0x16ed5
movq %rbx, %rax
addq $0x8070, %rsp           # imm = 0x8070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x23e2d(%rip), %rsi     # 0x3ace4
movq %rax, %rdi
callq 0x7200
movq 0x3712a(%rip), %rsi     # 0x4dff0
movq 0x370cb(%rip), %rdx     # 0x4df98
movq %rbx, %rdi
callq 0x77d0
movl $0x10, %edi
callq 0x7260
movq %rax, %r15
leaq 0x23e12(%rip), %rsi     # 0x3acfb
movq %rax, %rdi
callq 0x7200
movq 0x370f8(%rip), %rsi     # 0x4dff0
movq 0x37099(%rip), %rdx     # 0x4df98
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x16f26
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
jmp 0x16f3a
jmp 0x16f23
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x16f3a
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Compress.cpp
// Function: compress_deflate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
std::string compress_deflate(const std::string &str, unsigned int compressionlevel)
{
	z_stream zs;
	ft::memset(&zs, 0, sizeof(zs));
	if (deflateInit(&zs, compressionlevel) != Z_OK)
		throw(std::runtime_error("deflateInit() failed."));

	zs.next_in = (Bytef*)str.data();
	zs.avail_in = str.size();
	int ret;
	char outbuffer[32768];
	std::string outstring;

	do {
		zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
		zs.avail_out = sizeof(outbuffer);
		ret = deflate(&zs, Z_FINISH);
		if (outstring.size() < zs.total_out) {
			outstring.append(outbuffer,
			zs.total_out - outstring.size());
		}
	} while (ret == Z_OK);
	deflateEnd(&zs);

	if (ret != Z_STREAM_END)
		throw(std::runtime_error("Exception during zlib compression."));
	return (outstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x8070, %rsp           # imm = 0x8070
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movl $0x70, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d5df
leaq 0x23d6b(%rip), %rdx     # 0x3acdd
movq %r14, %rdi
movl %ebp, %esi
movl $0x70, %ecx
callq 0x7040
testl %eax, %eax
jne 0x17004
movq (%r15), %rax
movq %rsp, %r14
movq %rax, (%r14)
movl 0x8(%r15), %eax
movl %eax, 0x8(%r14)
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x70(%rsp), %r15
movq %r15, 0x18(%rsp)
movl $0x8000, 0x20(%rsp)     # imm = 0x8000
movq %r14, %rdi
movl $0x4, %esi
callq 0x7230
movl %eax, %ebp
movq 0x28(%rsp), %rdx
subq 0x8(%rbx), %rdx
jbe 0x16fe0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70c0
testl %ebp, %ebp
je 0x16fae
movq %rsp, %rdi
callq 0x7300
cmpl $0x1, %ebp
jne 0x17036
movq %rbx, %rax
addq $0x8070, %rsp           # imm = 0x8070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x23d06(%rip), %rsi     # 0x3ad1e
movq %rax, %rdi
callq 0x7200
movq 0x36fc9(%rip), %rsi     # 0x4dff0
movq 0x36f6a(%rip), %rdx     # 0x4df98
movq %rbx, %rdi
callq 0x77d0
movl $0x10, %edi
callq 0x7260
movq %rax, %r15
leaq 0x23cb1(%rip), %rsi     # 0x3acfb
movq %rax, %rdi
callq 0x7200
movq 0x36f97(%rip), %rsi     # 0x4dff0
movq 0x36f38(%rip), %rdx     # 0x4df98
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x17087
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
jmp 0x1709b
jmp 0x17084
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1709b
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Is_Cache_Uptodate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool						Credentials::Is_Cache_Uptodate(const std::string &path) const
{
	struct stat 			stats;
	if (lstat(path.c_str(), &stats) < 0)
		return (false);
	for (std::list<Authentication_file>::const_iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (path == it->file_path && it->last_modified == stats.st_mtime)
			return (true);
	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rsp, %rsi
callq 0x78e0
testl %eax, %eax
js 0x17239
movq (%rbx), %r12
cmpq %rbx, %r12
je 0x17239
movq (%r15), %r14
movq 0x8(%r15), %r15
movq 0x58(%rsp), %r13
cmpq 0x18(%r12), %r15
jne 0x17230
testq %r15, %r15
je 0x17229
movq 0x10(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
jne 0x17230
cmpq %r13, 0x48(%r12)
je 0x1724c
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x17209
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x1723b
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Update_user_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void						Credentials::Update_user_file(const std::string &path)
{
	for (std::list<Authentication_file>::iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (it->file_path == path)
			it = m_credentials.erase(it);
	Parse_user_file(path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
cmpq %rdi, %r15
je 0x1754c
movq 0x18(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x17544
testq %rdx, %rdx
je 0x17533
movq (%rbx), %rsi
movq 0x10(%r15), %rdi
callq 0x74c0
testl %eax, %eax
jne 0x17544
movq (%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x17d32
movq %r12, %r15
movq (%r15), %r15
cmpq %r14, %r15
jne 0x17514
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17250
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Is_Cached(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool						Credentials::Is_Cached(const std::string &path) const
{
	for (std::list<Authentication_file>::const_iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (path == it->file_path)
			return (true);
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x175a8
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq 0x18(%r12), %r15
jne 0x1759f
movb $0x1, %bpl
testq %r15, %r15
je 0x175aa
movq 0x10(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
je 0x175aa
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x1757c
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Check_Credentials(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool						Credentials::Check_Credentials(const std::string &path, const std::string &credentials)
{
	if (!Is_Cache_Uptodate(path))
		Update_user_file(path);
	for (std::list<Authentication_file>::iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
	{
		if (path == it->file_path)
			for (std::vector<std::string>::iterator ita = it->content.begin(); ita != it->content.end(); ita++)
			{
				if (credentials == *ita)
					return (true);
			}
	}
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
callq 0x171d0
testb %al, %al
jne 0x175e1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x174fe
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x17676
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r15), %rax
movq %rax, (%rsp)
movq (%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r13), %r13
movq %rbx, %r15
movq (%rsp), %rax
cmpq 0x18(%r14), %rax
jne 0x17634
cmpq $0x0, (%rsp)
je 0x17641
movq 0x10(%r14), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
callq 0x74c0
testl %eax, %eax
je 0x17641
movq (%r14), %r14
movq %r15, %rbx
cmpq %r15, %r14
jne 0x1760a
jmp 0x17676
movq 0x30(%r14), %rbx
movq 0x38(%r14), %r12
cmpq %r12, %rbx
je 0x17634
cmpq 0x8(%rbx), %r13
jne 0x17670
movb $0x1, %bpl
testq %r13, %r13
je 0x17678
movq (%rbx), %rsi
movq 0x10(%rsp), %rdi
movq %r13, %rdx
callq 0x74c0
testl %eax, %eax
je 0x17678
addq $0x20, %rbx
jmp 0x17649
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::HashTable(unsigned int)
HashTable::HashTable(unsigned int size) : m_size(size), m_hashdepth(4)
{
	if (!m_size)//Y U DO DIS
		this->m_size = 1;
	this->m_table = new t_hnode*[m_size];
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		this->m_table[i] = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl $0x4, 0xc(%rdi)
testl %esi, %esi
jne 0x17d89
movl $0x1, 0x8(%rbx)
movl $0x1, %esi
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
xorl %eax, %eax
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x17d9e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::HashTable(unsigned int, unsigned int)
HashTable::HashTable(unsigned int size, unsigned int hashdepth) : m_size(size), m_hashdepth(hashdepth)
{
	if (!m_size)
		m_size = 1;
	if (!m_hashdepth)
		m_hashdepth = 4;
	this->m_table = new t_hnode*[m_size];
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		this->m_table[i] = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
testl %esi, %esi
jne 0x17dd7
movl $0x1, 0x8(%rbx)
movl $0x1, %esi
testl %edx, %edx
jne 0x17de2
movl $0x4, 0xc(%rbx)
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
xorl %eax, %eax
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x17df7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::~HashTable()
HashTable::~HashTable()
{
	t_hnode *node;
	t_hnode *tmp;
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		node = this->m_table[i];
		while (node != NULL)
		{
			tmp = node;
			node = node->next;
			delete tmp;
		}
	}
	delete [] this->m_table;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x17e88
xorl %r15d, %r15d
movq (%rbx), %rcx
movq (%rcx,%r15,8), %r14
testq %r14, %r14
je 0x17e7e
movq 0x20(%r14), %rdi
movq 0x40(%r14), %r12
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x17e4f
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x17e66
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movl $0x48, %esi
movq %r14, %rdi
callq 0x74b0
movq %r12, %r14
testq %r12, %r12
jne 0x17e33
movl 0x8(%rbx), %eax
incq %r15
movl %eax, %ecx
cmpq %rcx, %r15
jb 0x17e27
movq (%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x17ea0
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75b0
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint32_t				HashTable::Hash(std::string const &str) const
{
	uint32_t					hash = 0;
	unsigned int				j = this->m_hashdepth;
	std::string::const_iterator	it = str.begin();

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

// Assembly:
movl 0xc(%rdi), %eax
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
setne %dl
testl %eax, %eax
setne %r8b
andb %dl, %r8b
xorl %edx, %edx
cmpb $0x1, %r8b
jne 0x17f03
movq (%rsi), %rdx
decl %eax
decq %rcx
xorl %esi, %esi
xorl %r8d, %r8d
movsbl (%rdx,%rsi), %r9d
addl %r8d, %r9d
movl %r9d, %r10d
shll $0xa, %r10d
addl %r9d, %r10d
movl %r10d, %r8d
shrl $0x6, %r8d
xorl %r10d, %r8d
cmpq %rsi, %rcx
je 0x17eff
leaq 0x1(%rsi), %r9
cmpl %esi, %eax
movq %r9, %rsi
jne 0x17ed3
leal (%r8,%r8,8), %edx
movl %edx, %ecx
shrl $0xb, %ecx
xorl %edx, %ecx
movl %ecx, %eax
shll $0xf, %eax
addl %ecx, %eax
xorl %edx, %edx
divl 0x8(%rdi)
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool					HashTable::Insert(std::string const &key, std::string const &value)
{
	if (key.empty() || value.empty() || this->GetNode(key))
		return (false);
	t_hnode 		*newnode;
	unsigned int	index = this->Hash(key);

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

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x8(%rsi)
je 0x17fd3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x17fc5
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17fd4
testq %rax, %rax
je 0x17f54
xorl %eax, %eax
jmp 0x17fc5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17ea8
movl %eax, %ebp
movl $0x48, %edi
callq 0x74a0
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movb %al, 0x10(%r12)
leaq 0x20(%r12), %r13
leaq 0x30(%r12), %rcx
movq %rcx, 0x20(%r12)
movq %rax, 0x28(%r12)
movb %al, 0x30(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x72c0
movq %r13, %rdi
movq %r14, %rsi
callq 0x72c0
movq (%rbx), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x40(%r12)
movq %r12, (%rax,%rcx,8)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::GetNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
t_hnode*				HashTable::GetNode(std::string const &key) const
{
	t_hnode *node = this->m_table[this->Hash(key)];
	while (node != NULL && node->key != key)
		node = node->next;
	return (node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq (%rdi), %rbx
callq 0x17ea8
movl %eax, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
je 0x1801c
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, 0x8(%rbx)
jne 0x18013
testq %r15, %r15
je 0x1801e
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
je 0x1801e
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x17ff6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool					HashTable::Delete(std::string const &key)
{
	unsigned int index = this->Hash(key);
	t_hnode *node = this->m_table[index];
	t_hnode *prevnode = NULL;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17ea8
movq (%r14), %r12
movl %eax, %r13d
movq (%r12,%r13,8), %rax
testq %rax, %rax
je 0x180d7
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %ebp, %ebp
movq %rax, %rbx
cmpq %r15, 0x8(%rax)
jne 0x1807a
testq %r15, %r15
je 0x18088
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
je 0x18088
movq 0x40(%rbx), %rax
movq %rbx, %rbp
testq %rax, %rax
jne 0x1805a
jmp 0x180d7
movq 0x40(%rbx), %rax
testq %rbp, %rbp
je 0x18097
movq %rax, 0x40(%rbp)
jmp 0x1809b
movq %rax, (%r12,%r13,8)
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x180b3
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x180ca
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movl $0x48, %esi
movq %rbx, %rdi
callq 0x74b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq