LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37384
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c381(%rip), %rsi     # 0x3a055
leaq 0x2c389(%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 0x35fd4
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %rbx
cmpq %rax, %rdi
je 0xdd22
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xdd39
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testq %rbx, %rbx
movq (%rsp), %rbx
je 0xdd51
leaq 0x140(%r13), %rsi
movq %rbx, %rdi
callq 0x37f3c
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x1359c
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x1606c
leaq 0x48(%rsp), %rdi
callq 0x15920
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xde85
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x15920
jmp 0xddb0
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xde88
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 0xde9a
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0xded8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xde11
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rsp), %rdi
movl %eax, %esi
callq 0x37f1c
movq (%rsp), %rbx
callq 0x7780
jmp 0xdd7e
jmp 0xde85
jmp 0xde57
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xde5a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0xde5a
movq %rax, %r14
callq 0x7780
jmp 0xde88
movq %rax, %rdi
callq 0x96cc
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xde88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0xde88
movq %rax, %r14
movq (%rsp), %rdi
callq 0x371c6
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37384
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28994(%rip), %rsi     # 0x3a152
leaq 0x28999(%rip), %rdx     # 0x3a15e
leaq 0x28(%rsp), %rdi
callq 0x80f4
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x290a4(%rip), %rsi     # 0x3a884
leaq 0x290b8(%rip), %rdx     # 0x3a89f
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3744c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1181a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x11831
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x28a57(%rip), %rsi     # 0x3a297
leaq 0x28a56(%rip), %rdx     # 0x3a29d
callq 0x80f4
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x29381(%rip), %rsi     # 0x3abdc
leaq 0x29381(%rip), %rdx     # 0x3abe3
callq 0x80f4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3744c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11890
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x118a7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x377cc
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37f32
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x118d3
jmp 0x118ef
jmp 0x1190d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x118f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x118f2
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x11910
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x11910
jmp 0x1190d
movq %rax, %r14
movq %rbx, %rdi
callq 0x371c6
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1256c
leaq 0x3c12a(%rip), %rax     # 0x4da80
movq %rax, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x126aa
testb %al, %al
je 0x11985
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x128ac
testb %al, %al
je 0x119de
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 0x28f0b(%rip), %rsi     # 0x3a8ae
leaq 0x28f23(%rip), %rdx     # 0x3a8cd
leaq 0x20(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11c26
xorl %ebp, %ebp
leaq 0x3c0db(%rip), %rsi     # 0x4daa8
leaq 0x29c(%rip), %rdx       # 0x11c70
movq %r15, %rdi
callq 0x77d0
jmp 0x11a31
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28ed2(%rip), %rsi     # 0x3a8ce
leaq 0x28ee5(%rip), %rdx     # 0x3a8e8
movq %rsp, %rdi
callq 0x80f4
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x11c26
xorl %ebp, %ebp
leaq 0x3c086(%rip), %rsi     # 0x4daa8
leaq 0x247(%rip), %rdx       # 0x11c70
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x11a68
movq 0x10(%rsp), %rsi
jmp 0x11a58
jmp 0x11a62
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x11a68
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x11a68
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x11a7a
movq %r15, %rdi
callq 0x7390
jmp 0x11a7a
movq %rax, %r14
movq %rbx, %rdi
callq 0x12614
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1256c
leaq 0x3be19(%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 0x126aa
testb %al, %al
je 0x11d38
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x1272c
testb %al, %al
je 0x11d93
movq %rbx, %rdi
callq 0x12ad0
testb %al, %al
je 0x11deb
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 0x28c01(%rip), %rsi     # 0x3a956
leaq 0x28c12(%rip), %rdx     # 0x3a96e
leaq 0x48(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bda1(%rip), %rsi     # 0x4db20
leaq 0x726(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
jmp 0x11e41
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28bbf(%rip), %rsi     # 0x3a96f
leaq 0x28bcf(%rip), %rdx     # 0x3a986
leaq 0x28(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bd46(%rip), %rsi     # 0x4db20
leaq 0x6cb(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
jmp 0x11e41
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28b7f(%rip), %rsi     # 0x3a987
leaq 0x28b93(%rip), %rdx     # 0x3a9a2
leaq 0x8(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bcee(%rip), %rsi     # 0x4db20
leaq 0x673(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11e8f
movq 0x18(%rsp), %rsi
jmp 0x11e7f
jmp 0x11e89
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x11e8f
movq 0x38(%rsp), %rsi
jmp 0x11e7f
jmp 0x11e89
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x11e8f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x11e8f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x11ea1
movq %r15, %rdi
callq 0x7390
jmp 0x11ea1
movq %rax, %r14
movq 0x40(%rbx), %rdi
cmpq %r12, %rdi
je 0x11eb6
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x12614
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1256c
leaq 0x3bc12(%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 0x126aa
testb %al, %al
je 0x11f43
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x1272c
testb %al, %al
je 0x11f9e
movq %rbx, %rdi
callq 0x12ad0
testb %al, %al
je 0x11ff6
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 0x289f6(%rip), %rsi     # 0x3a956
leaq 0x28a07(%rip), %rdx     # 0x3a96e
leaq 0x48(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bb96(%rip), %rsi     # 0x4db20
leaq 0x51b(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
jmp 0x1204c
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x289b4(%rip), %rsi     # 0x3a96f
leaq 0x289c4(%rip), %rdx     # 0x3a986
leaq 0x28(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bb3b(%rip), %rsi     # 0x4db20
leaq 0x4c0(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
jmp 0x1204c
movl $0x28, %edi
callq 0x7260
movq %rax, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28974(%rip), %rsi     # 0x3a987
leaq 0x28988(%rip), %rdx     # 0x3a9a2
leaq 0x8(%rsp), %rdi
callq 0x80f4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x12462
xorl %ebp, %ebp
leaq 0x3bae3(%rip), %rsi     # 0x4db20
leaq 0x468(%rip), %rdx       # 0x124ac
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1209a
movq 0x18(%rsp), %rsi
jmp 0x1208a
jmp 0x12094
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1209a
movq 0x38(%rsp), %rsi
jmp 0x1208a
jmp 0x12094
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x1209a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1209a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x120ac
movq %r15, %rdi
callq 0x7390
jmp 0x120ac
movq %rax, %r14
movq 0x40(%rbx), %rdi
cmpq %r12, %rdi
je 0x120c1
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x12614
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x123c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x3bbd8(%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 0x123ec
movq %rax, %rbx
movq 0x3bbaa(%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_O1/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 0x1269e
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_O1/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Create(bool)
bool					Socket::Create(bool nonblocking)
{
	m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (!this->Success())
		return (false);
	int optval = 1;
	if (setsockopt(this->m_sockfd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&optval), sizeof(optval)))
		return (false);
	if (nonblocking)
		return (fcntl(this->m_sockfd, F_SETFL, O_NONBLOCK) != -1);
	return (true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x7140
movl %eax, 0x28(%rbx)
cmpl $-0x1, %eax
je 0x1271f
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x7830
testl %eax, %eax
sete %r14b
andb %r14b, %bpl
cmpb $0x1, %bpl
jne 0x1271f
movl 0x28(%rbx), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x72f0
cmpl $-0x1, %eax
setne %r14b
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12768
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 0x1276c
xorl %eax, %eax
jmp 0x127a7
movl 0x30(%rbx), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x127af
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x127a5
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_O1/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 0x2ae4f(%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 0x2ae28(%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 0x2ae01(%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 0x3b713(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3b6e3(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12b5c
movl 0x30(%r15), %esi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x127af
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7590
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x12b5c
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_O1/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 0x281ee(%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 0x1d904
movl 0x28(%rbx), %edi
movl $0xfffe, %edx           # imm = 0xFFFE
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x71b0
movq %rax, %rbx
testl %ebx, %ebx
je 0x12c5e
cmpl $-0x1, %ebx
jne 0x12c3a
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x27e26(%rip), %rsi     # 0x3aa20
leaq 0x27e37(%rip), %rdx     # 0x3aa38
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x80f4
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x12c94
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12c5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x12c5e
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 0x12c88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25bbe(%rip), %rsi     # 0x3a70d
leaq 0x25bbe(%rip), %rdx     # 0x3a714
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2b4c6
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 0x8a8a
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14ba5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x15a02
leaq 0x40(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7590
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14bdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq $0x0, 0x48(%rbx)
jne 0x14bf8
addq $0xb8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x72c0
leaq 0xc0(%rbx), %r14
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rcx
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 0x14c55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x68(%rbx), %rdx
testq %rdx, %rdx
je 0x14c75
movq (%r14), %rax
cmpb $0x2f, -0x1(%rax,%rdx)
jne 0x14c89
decq %rdx
movq %rdx, 0x68(%rbx)
movb $0x0, (%rax,%rdx)
jmp 0x14c89
leaq 0x2611f(%rip), %rcx     # 0x3ad9b
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x76f0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x14ca0
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 0x14cb5
jmp 0x14cb5
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x14ce8
movq 0x38(%rsp), %rsi
jmp 0x14ce0
movq %rax, %rbx
jmp 0x14ce8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14ce8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x100(%rdi), %rax
subq 0xf8(%rdi), %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
shrq $0x3d, %rcx
leaq 0x8(,%rax,8), %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x7030
movq 0xf8(%rbx), %rcx
movq 0x100(%rbx), %rdx
movabsq $0x1fffffffffffffff, %r14 # imm = 0x1FFFFFFFFFFFFFFF
movq %rax, 0x118(%rbx)
subq %rcx, %rdx
je 0x15f89
movl $0x1, %r15d
xorl %r12d, %r12d
movq (%rcx,%r15,8), %rdi
incq %rdi
callq 0x7030
movq 0x118(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0xf8(%rbx), %rax
movq 0x118(%rbx), %rcx
movq (%rcx,%r12,8), %rdi
movq -0x8(%rax,%r15,8), %rsi
movq (%rax,%r15,8), %rdx
incq %rdx
callq 0x1d8c3
incq %r12
movq 0xf8(%rbx), %rcx
movq 0x100(%rbx), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
addq $0x4, %r15
cmpq %rdx, %r12
jb 0x15f2c
jmp 0x15f8d
sarq $0x5, %rdx
movq 0x118(%rbx), %rax
movq $0x0, (%rax,%rdx,8)
movq 0xe8(%rbx), %rax
subq 0xe0(%rbx), %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
cmpq %r14, %rcx
leaq 0x8(,%rax,8), %rax
movq $-0x1, %rdi
cmovbeq %rax, %rdi
callq 0x7030
movq 0xe0(%rbx), %rcx
movq 0xe8(%rbx), %rdx
movq %rax, 0x110(%rbx)
subq %rcx, %rdx
je 0x1604d
movl $0x1, %r14d
xorl %r15d, %r15d
movq (%rcx,%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 0x1d8c3
incq %r15
movq 0xe0(%rbx), %rcx
movq 0xe8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
addq $0x4, %r14
cmpq %rdx, %r15
jb 0x15ff0
jmp 0x16051
sarq $0x5, %rdx
movq 0x110(%rbx), %rax
movq $0x0, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d8f7
leaq 0x23df9(%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 0x16f8b
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 0x16f67
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70c0
testl %ebp, %ebp
je 0x16f35
movq %rsp, %rdi
callq 0x7300
cmpl $0x1, %ebp
jne 0x16fbd
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 0x23d45(%rip), %rsi     # 0x3ace4
movq %rax, %rdi
callq 0x7200
movq 0x37042(%rip), %rsi     # 0x4dff0
movq 0x36fe3(%rip), %rdx     # 0x4df98
movq %rbx, %rdi
callq 0x77d0
movl $0x10, %edi
callq 0x7260
movq %rax, %r15
leaq 0x23d2a(%rip), %rsi     # 0x3acfb
movq %rax, %rdi
callq 0x7200
movq 0x37010(%rip), %rsi     # 0x4dff0
movq 0x36fb1(%rip), %rdx     # 0x4df98
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x1700e
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
jmp 0x17022
jmp 0x1700b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x17022
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d8f7
leaq 0x23c83(%rip), %rdx     # 0x3acdd
movq %r14, %rdi
movl %ebp, %esi
movl $0x70, %ecx
callq 0x7040
testl %eax, %eax
jne 0x170ec
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 0x170c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70c0
testl %ebp, %ebp
je 0x17096
movq %rsp, %rdi
callq 0x7300
cmpl $0x1, %ebp
jne 0x1711e
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 0x23c1e(%rip), %rsi     # 0x3ad1e
movq %rax, %rdi
callq 0x7200
movq 0x36ee1(%rip), %rsi     # 0x4dff0
movq 0x36e82(%rip), %rdx     # 0x4df98
movq %rbx, %rdi
callq 0x77d0
movl $0x10, %edi
callq 0x7260
movq %rax, %r15
leaq 0x23bc9(%rip), %rsi     # 0x3acfb
movq %rax, %rdi
callq 0x7200
movq 0x36eaf(%rip), %rsi     # 0x4dff0
movq 0x36e50(%rip), %rdx     # 0x4df98
movq %r15, %rdi
callq 0x77d0
movq %rax, %r14
movq %r15, %rdi
callq 0x7390
jmp 0x1716f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
jmp 0x17183
jmp 0x1716c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x17183
movq (%r12), %rsi
incq %rsi
callq 0x74b0
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Is_Cache_Uptodate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool						Credentials::Is_Cache_Uptodate(const std::string &path) const
{
	struct stat 			stats;
	if (lstat(path.c_str(), &stats) < 0)
		return (false);
	for (std::list<Authentication_file>::const_iterator it = m_credentials.begin(); it != m_credentials.end(); it++)
		if (path == it->file_path && it->last_modified == stats.st_mtime)
			return (true);
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x78e0
testl %eax, %eax
js 0x1732e
movq (%rbx), %r12
cmpq %rbx, %r12
setne %bpl
je 0x17330
movq (%r15), %r14
movq 0x8(%r15), %r15
movq 0x60(%rsp), %r13
cmpq 0x18(%r12), %r15
jne 0x1731f
testq %r15, %r15
je 0x17318
movq 0x10(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
jne 0x1731f
cmpq %r13, 0x48(%r12)
je 0x17330
movq (%r12), %r12
cmpq %rbx, %r12
setne %bpl
jne 0x172f8
jmp 0x17330
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/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 0x17644
movq 0x18(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x1763c
testq %rdx, %rdx
je 0x1762b
movq (%rbx), %rsi
movq 0x10(%r15), %rdi
callq 0x74c0
testl %eax, %eax
jne 0x1763c
movq (%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x17e26
movq %r12, %r15
movq (%r15), %r15
cmpq %r14, %r15
jne 0x1760c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17348
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r13
cmpq %rdi, %r13
setne %bl
je 0x176a2
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq 0x18(%r13), %r12
jne 0x17696
testq %r12, %r12
je 0x176a2
movq 0x10(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x74c0
testl %eax, %eax
je 0x176a2
movq (%r13), %r13
cmpq %r14, %r13
setne %bl
jne 0x17678
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
callq 0x172b8
testb %al, %al
jne 0x176dd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x175f6
movq (%rbx), %r14
cmpq %rbx, %r14
setne %bpl
je 0x17784
movq %rbx, 0x18(%rsp)
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
movq (%r13), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r13), %r13
movq 0x8(%rsp), %rax
cmpq 0x18(%r14), %rax
jne 0x17776
cmpq $0x0, 0x8(%rsp)
je 0x1773a
movq 0x10(%r14), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x74c0
testl %eax, %eax
jne 0x17776
movq 0x30(%r14), %rbx
movq 0x38(%r14), %r12
cmpq %r12, %rbx
sete %r15b
je 0x17776
cmpq 0x8(%rbx), %r13
jne 0x1776a
testq %r13, %r13
je 0x17770
movq (%rbx), %rsi
movq 0x20(%rsp), %rdi
movq %r13, %rdx
callq 0x74c0
testl %eax, %eax
je 0x17770
addq $0x20, %rbx
jmp 0x17742
testb $0x1, %r15b
je 0x17784
movq (%r14), %r14
cmpq 0x18(%rsp), %r14
setne %bpl
jne 0x17710
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/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 0x17e78
movl $0x1, 0x8(%rbx)
movl 0x8(%rbx), %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
testq %r14, %r14
je 0x17ea6
xorl %eax, %eax
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x17e93
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17ec6
movl $0x1, 0x8(%rbx)
testl %edx, %edx
jne 0x17ed1
movl $0x4, 0xc(%rbx)
movl 0x8(%rbx), %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
testq %r14, %r14
je 0x17eff
xorl %eax, %eax
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x17eec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x8(%rdi)
je 0x17f7b
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x17f70
movq 0x20(%r14), %rdi
movq 0x40(%r14), %r12
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x17f44
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x17f5b
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movl $0x48, %esi
movq %r14, %rdi
callq 0x74b0
movq %r12, %r14
testq %r12, %r12
jne 0x17f28
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0x17f1c
movq (%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x17f93
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75b0
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17ff7
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 0x17ff3
leaq 0x1(%rsi), %r9
cmpl %esi, %eax
movq %r9, %rsi
jne 0x17fc7
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_O1/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 0x180c7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x180b9
movq %rsi, %r15
movq %rdi, %rbx
callq 0x180c8
testq %rax, %rax
je 0x18048
xorl %eax, %eax
jmp 0x180b9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17f9c
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_O1/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 0x17f9c
movl %eax, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
je 0x18110
movq (%r15), %r14
movq 0x8(%r15), %r15
movq 0x8(%rbx), %rdx
cmpq %r15, %rdx
jne 0x18107
testq %rdx, %rdx
je 0x18110
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x74c0
testl %eax, %eax
je 0x18110
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x180ea
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17f9c
movq (%rbx), %rcx
movl %eax, %eax
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x18201
movq (%r14), %r15
movq 0x8(%r14), %rbp
xorl %ebx, %ebx
movq %rax, %r13
movq 0x8(%rax), %r12
cmpq %rbp, %r12
jne 0x1817c
testq %r12, %r12
je 0x1818a
movq (%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x74c0
testl %eax, %eax
je 0x1818a
movq 0x40(%r13), %rax
movq %r13, %rbx
testq %rax, %rax
jne 0x18158
jmp 0x18201
cmpq %rbp, %r12
jne 0x18201
testq %r12, %r12
je 0x181a7
movq (%r14), %rsi
movq (%r13), %rdi
movq %r12, %rdx
callq 0x74c0
testl %eax, %eax
jne 0x18201
movq 0x40(%r13), %rax
testq %rbx, %rbx
je 0x181b6
movq %rax, 0x40(%rbx)
jmp 0x181c4
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x20(%r13), %rdi
leaq 0x30(%r13), %rax
cmpq %rax, %rdi
je 0x181dc
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movq (%r13), %rdi
leaq 0x10(%r13), %rax
cmpq %rax, %rdi
je 0x181f4
movq (%rax), %rsi
incq %rsi
callq 0x74b0
movl $0x48, %esi
movq %r13, %rdi
callq 0x74b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Print() const
void					HashTable::Print(void) const
{
	t_hnode *node;
	for (unsigned int i = 0; i < this->m_size; i++)
	{
		node = this->m_table[i];
		if (node != NULL)
			std::cout << i << ":\n\t";
		while (node != NULL)
		{
			std::cout << node->key << "=" << node->value << " ";
			node = node->next;
		}
		if (!node)
			std::cout << std::endl;
	}
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
je 0x18301
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movq 0x35d77(%rip), %r15     # 0x4dfa8
leaq 0x2285f(%rip), %r13     # 0x3aa97
leaq 0x253d5(%rip), %rbp     # 0x3d614
movq %rdi, (%rsp)
movq (%rdi), %rax
movq (%rax,%r14,8), %rbx
testq %rbx, %rbx
je 0x182b9
movq %r15, %rdi
movq %r14, %rsi
callq 0x7330
movl $0x3, %edx
movq %rax, %rdi
leaq 0x22ae0(%rip), %rsi     # 0x3ad49
callq 0x7510
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x7510
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x7510
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r12, %rdi
callq 0x7510
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x7510
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x1826e
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x7490
movsbl %al, %esi
movq %r15, %rdi
callq 0x7050
movq %rax, %rdi
callq 0x7340
incq %r14
movq (%rsp), %rdi
movl 0x8(%rdi), %eax
cmpq %rax, %r14
jb 0x18243
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::Lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string &		HashTable::Lookup(std::string const &key) const
{
	t_hnode *node = this->m_table[this->Hash(key)];
	while (node != NULL && node->key != key)
		node = node->next;
	if (node == NULL)
		throw HashTable::HashTableException();
	return (node->value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq (%rdi), %rbx
callq 0x17f9c
movl %eax, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
je 0x1834a
movq (%r15), %r14
movq 0x8(%r15), %r15
movq 0x8(%rbx), %rdx
cmpq %r15, %rdx
jne 0x18341
testq %rdx, %rdx
je 0x18375
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x74c0
testl %eax, %eax
je 0x18375
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x18324
movl $0x28, %edi
callq 0x7260
movq %rax, %rbx
movq %rax, %rdi
callq 0x18396
leaq 0x3585a(%rip), %rsi     # 0x4dbc0
leaq 0x75(%rip), %rdx        # 0x183e2
movq %rbx, %rdi
callq 0x77d0
addq $0x20, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7810
nop