LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x70
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x17de6
leaq 0x1a8ef(%rip), %rax     # 0x2cc91
pushq $0x8
popq %rdx
pushq $0x1f
popq %rcx
pushq $0x9
popq %r8
movq %r14, %rdi
movl %ebp, %esi
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x7090
popq %rcx
popq %rdx
testl %eax, %eax
jne 0x12440
movq (%r15), %rax
movq %rsp, %r14
movq %rax, (%r14)
movl 0x8(%r15), %eax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movl %eax, 0x8(%r14)
movb $0x0, 0x10(%rbx)
leaq 0x70(%rsp), %r15
pushq $0x4
popq %r12
movq %r15, 0x18(%rsp)
movl $0x8000, 0x20(%rsp)     # imm = 0x8000
movq %r14, %rdi
movl %r12d, %esi
callq 0x7260
movl %eax, %ebp
movq 0x28(%rsp), %rdx
subq 0x8(%rbx), %rdx
jbe 0x1241c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70b0
testl %ebp, %ebp
je 0x123ec
movq %rsp, %rdi
callq 0x7340
cmpl $0x1, %ebp
jne 0x12470
movq %rbx, %rax
addq $0x8070, %rsp           # imm = 0x8070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x1a846(%rip), %rsi     # 0x2cc98
movq %rax, %rdi
callq 0x7210
movq 0x30b8f(%rip), %rsi     # 0x42ff0
movq 0x30b38(%rip), %rdx     # 0x42fa0
movq %rbx, %rdi
callq 0x7830
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1a82d(%rip), %rsi     # 0x2ccaf
movq %rax, %rdi
callq 0x7210
movq 0x30b5f(%rip), %rsi     # 0x42ff0
movq 0x30b08(%rip), %rdx     # 0x42fa0
movq %r15, %rdi
callq 0x7830
movq %rax, %r14
movq %r15, %rdi
callq 0x73d0
jmp 0x124bf
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
jmp 0x124c7
jmp 0x124bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x79b8
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x70
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x17de6
leaq 0x1a794(%rip), %rdx     # 0x2cc91
pushq $0x70
popq %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7040
testl %eax, %eax
jne 0x1258c
movq (%r15), %rax
movq %rsp, %r14
movq %rax, (%r14)
movl 0x8(%r15), %eax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movl %eax, 0x8(%r14)
movb $0x0, 0x10(%rbx)
leaq 0x70(%rsp), %r15
pushq $0x4
popq %r12
movq %r15, 0x18(%rsp)
movl $0x8000, 0x20(%rsp)     # imm = 0x8000
movq %r14, %rdi
movl %r12d, %esi
callq 0x7260
movl %eax, %ebp
movq 0x28(%rsp), %rdx
subq 0x8(%rbx), %rdx
jbe 0x12568
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70b0
testl %ebp, %ebp
je 0x12538
movq %rsp, %rdi
callq 0x7340
cmpl $0x1, %ebp
jne 0x125bc
movq %rbx, %rax
addq $0x8070, %rsp           # imm = 0x8070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x1a734(%rip), %rsi     # 0x2ccd2
movq %rax, %rdi
callq 0x7210
movq 0x30a43(%rip), %rsi     # 0x42ff0
movq 0x309ec(%rip), %rdx     # 0x42fa0
movq %rbx, %rdi
callq 0x7830
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1a6e1(%rip), %rsi     # 0x2ccaf
movq %rax, %rdi
callq 0x7210
movq 0x30a13(%rip), %rsi     # 0x42ff0
movq 0x309bc(%rip), %rdx     # 0x42fa0
movq %r15, %rdi
callq 0x7830
movq %rax, %r14
movq %r15, %rdi
callq 0x73d0
jmp 0x1260b
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
jmp 0x12613
jmp 0x12608
movq %rax, %r14
movq %rbx, %rdi
callq 0x79b8
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Credentials()
Credentials::Credentials()
{
	try
	{
		for (std::list<VirtualHost>::iterator it = g_webserv.vhosts.begin(); it != g_webserv.vhosts.end(); it++)
		{
			const std::string	&path = it->getConfig().getParam("auth_basic_user_file").front();
			if (!path.empty() && !Is_Cache_Uptodate(path))
				Parse_user_file(path);
		}
	}
	catch (std::exception& e) {}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0xa8, %r14d
addq 0x30972(%rip), %r14     # 0x42fb8
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %r14, %rbp
movq (%rbp), %rbp
cmpq %r14, %rbp
je 0x126e8
leaq 0x10(%rbp), %rdi
callq 0x2b716
movq %rax, %r13
movq %r15, %rdi
leaq 0x1a672(%rip), %rsi     # 0x2cce8
movq %r12, %rdx
callq 0x8032
movq %r13, %rdi
movq %r15, %rsi
callq 0x2167a
movq (%rax), %r13
movq %r15, %rdi
callq 0x79b8
cmpq $0x0, 0x18(%r13)
je 0x12653
addq $0x10, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1270a
testb %al, %al
jne 0x12653
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12772
jmp 0x12653
jmp 0x126cf
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0x126d5
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x126fa
movq %r14, %rdi
callq 0x7220
callq 0x77f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12a96
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq %rsp, %rsi
callq 0x7940
testl %eax, %eax
js 0x1275d
movq 0x58(%rsp), %r15
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
setne %bpl
je 0x1275f
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0xc2ad
testb %al, %al
je 0x12736
cmpq %r15, 0x48(%r12)
jne 0x12736
jmp 0x1275f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Credentials.cpp
// Function: Credentials::Parse_user_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void						Credentials::Parse_user_file(const std::string &path)
{
	Authentication_file		user_file;
	struct stat 			stats;

	if (lstat(path.c_str(), &stats) < 0 || !S_ISREG(stats.st_mode) || user_file.last_modified == stats.st_mtime)
		return ;
	std::ifstream 			inputFileStream(path.c_str());
	if (!inputFileStream.is_open())
		return ;
	std::string				line;
	while (!inputFileStream.eof()) {
		std::getline(inputFileStream, line);
		if (!line.empty())
			user_file.content.push_back(base64_encode(line.c_str(), line.size()));
	}
	user_file.file_path = path;
	user_file.last_modified = stats.st_mtime;
	m_credentials.push_back(user_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rsi, %r14
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %rdi
leaq 0x90(%rsp), %rsi
callq 0x7940
testl %eax, %eax
js 0x128c4
movl $0xf000, %eax           # imm = 0xF000
andl 0xa8(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x128c4
movq 0xe8(%rsp), %rax
cmpq %rax, 0x68(%rsp)
je 0x128c4
movq %rax, 0x8(%rsp)
movq (%r14), %rsi
leaq 0x120(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x78d0
leaq 0x198(%rsp), %rdi
callq 0x7130
testb %al, %al
je 0x128b7
leaq 0x50(%rsp), %r15
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x120(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x70(%rsp), %rbp
movq 0x120(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x140(%rsp,%rax)
jne 0x1288a
movq %r12, %rdi
movq %r13, %rsi
callq 0x70e0
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0x1283d
movq 0x10(%rsp), %rsi
movq %rbp, %rdi
callq 0xfbac
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1227c
movq %rbp, %rdi
callq 0x79b8
jmp 0x1283d
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x7300
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsi)
movq %rbx, %rdi
callq 0x12a66
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x120(%rsp), %rdi
callq 0x7170
leaq 0x30(%rsp), %rdi
callq 0x12a72
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x128f8
movq %rax, %rbx
jmp 0x12912
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x79b8
jmp 0x128fb
jmp 0x128f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x120(%rsp), %rdi
callq 0x7170
leaq 0x30(%rsp), %rdi
callq 0x12a72
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x12998
leaq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0xc2ad
testb %al, %al
je 0x12970
movq %r14, %rdi
movq %r15, %rsi
callq 0x12a88
movq %rax, %r15
jmp 0x12970
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12772
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x129ce
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0xc2ad
testb %al, %al
je 0x129b6
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1270a
testb %al, %al
jne 0x12a00
movq %r14, %rdi
movq %r15, %rsi
callq 0x12962
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x12a39
leaq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0xc2ad
testb %al, %al
je 0x12a03
movq 0x30(%r13), %r12
cmpq 0x38(%r13), %r12
je 0x12a03
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc2ad
addq $0x20, %r12
testb %al, %al
je 0x12a20
cmpq %r14, %r13
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1313f
movl $0x1, 0x8(%rbx)
pushq $0x1
popq %rsi
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
xorl %eax, %eax
cmpq %rax, %r14
je 0x13166
movq (%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x13154
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13189
movl $0x1, 0x8(%rbx)
pushq $0x1
popq %rsi
testl %edx, %edx
jne 0x13194
movl $0x4, 0xc(%rbx)
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x7030
movq %rax, (%rbx)
xorl %eax, %eax
cmpq %rax, %r14
je 0x131bb
movq (%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x131a9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x48
popq %r14
movl 0x8(%rbx), %eax
movq (%rbx), %rdi
cmpq %rax, %r12
jae 0x1320c
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x13207
movq 0x40(%r15), %r13
movq %r15, %rdi
callq 0x1351e
movq %r15, %rdi
movq %r14, %rsi
callq 0x7530
movq %r13, %r15
jmp 0x131e6
incq %r12
jmp 0x131d7
testq %rdi, %rdi
je 0x1321f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7630
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 (%rsi), %rcx
movq 0x8(%rsi), %rdx
xorl %esi, %esi
xorl %r8d, %r8d
cmpq %rsi, %rdx
je 0x13260
cmpl %esi, %eax
je 0x13260
movsbl (%rcx,%rsi), %r9d
addl %r9d, %r8d
imull $0x401, %r8d, %r9d      # imm = 0x401
movl %r9d, %r8d
shrl $0x6, %r8d
xorl %r9d, %r8d
incq %rsi
jmp 0x13239
leal (%r8,%r8,8), %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
imull $0x8001, %ecx, %eax     # imm = 0x8001
xorl %edx, %edx
divl 0x8(%rdi)
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13333
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x13325
movq %rsi, %r15
movq %rdi, %rbx
callq 0x13334
testq %rax, %rax
je 0x132b4
xorl %eax, %eax
jmp 0x13325
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1322a
movl %eax, %ebp
pushq $0x48
popq %rdi
callq 0x7520
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
andq $0x0, 0x8(%r12)
xorl %eax, %eax
movb %al, 0x10(%r12)
leaq 0x20(%r12), %r13
leaq 0x30(%r12), %rcx
movq %rcx, 0x20(%r12)
andq $0x0, 0x28(%r12)
movb %al, 0x30(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7300
movq %r13, %rdi
movq %r14, %rsi
callq 0x7300
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
callq 0x1322a
movl %eax, %eax
leaq (%r14,%rax,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x13366
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe716
testb %al, %al
je 0x13366
addq $0x40, %r14
jmp 0x13349
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1322a
movl %eax, %r12d
shlq $0x3, %r12
movq (%rbx), %rax
addq %r12, %rax
xorl %r13d, %r13d
movq (%rax), %r15
testq %r15, %r15
je 0x133ed
movq %r15, %rdi
movq %r14, %rsi
callq 0xe716
testb %al, %al
je 0x133b6
leaq 0x40(%r15), %rax
movq %r15, %r13
jmp 0x13396
movq %r15, %rdi
movq %r14, %rsi
callq 0xc2ad
testb %al, %al
je 0x133ed
addq (%rbx), %r12
leaq 0x40(%r13), %rax
testq %r13, %r13
movq 0x40(%r15), %rcx
cmoveq %r12, %rax
movq %rcx, (%rax)
movq %r15, %rdi
callq 0x1351e
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x7530
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2fb96(%rip), %r15     # 0x42fa8
leaq 0x19632(%rip), %r12     # 0x2ca4b
leaq 0x1c184(%rip), %r13     # 0x2f5a4
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jae 0x13490
movq (%rbx), %rax
movq (%rax,%r14,8), %rbp
testq %rbp, %rbp
je 0x1347e
movq %r15, %rdi
movq %r14, %rsi
callq 0x7370
movq %rax, %rdi
leaq 0x198b4(%rip), %rsi     # 0x2ccfd
callq 0x7510
jmp 0x1347e
movq %rbp, %rsi
callq 0x74a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x7510
leaq 0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x74a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x7510
movq 0x40(%rbp), %rbp
movq %r15, %rdi
testq %rbp, %rbp
jne 0x13450
callq 0x7280
incq %r14
jmp 0x13420
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
callq 0x1322a
movl %eax, %eax
leaq (%r14,%rax,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x134e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe716
testb %al, %al
je 0x134d2
addq $0x40, %r14
jmp 0x134b5
addq $0x20, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %rbx
movq %rax, %rdi
callq 0x13534
leaq 0x2f6dd(%rip), %rsi     # 0x42bd8
leaq 0x74(%rip), %rdx        # 0x13576
movq %rbx, %rdi
callq 0x7830
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Sighandler.cpp
// Function: sig_int(int)
static void	sig_int(int sig)
{
	(void)sig;
	signal(SIGINT, SIG_IGN);
	std:: cout << "\b\b" << std::flush;
	Logger::print("Interrupt signal was caught.", NULL, WARNING, SILENT);
	g_webserv.run = false;
	signal(SIGINT, &sig_int);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
pushq $0x2
popq %rbx
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x75c0
movq 0x2f9aa(%rip), %rdi     # 0x42fa8
leaq 0x19748(%rip), %rsi     # 0x2cd4d
callq 0x7510
movq %rax, %rdi
callq 0x7380
leaq 0x19737(%rip), %rsi     # 0x2cd50
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x8032
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
movl %ebx, %ecx
callq 0xbe10
leaq 0x8(%rsp), %rdi
callq 0x79b8
leaq 0x2ff66(%rip), %rax     # 0x435b0
movb $0x0, (%rax)
leaq -0x71(%rip), %rsi       # 0x135e3
pushq $0x2
popq %rdi
callq 0x75c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::Threadpool(unsigned int)
Threadpool::Threadpool(unsigned int numworkers) : m_numworkers(numworkers), m_maxqueuedjobs(100)
{
	if (!m_numworkers)
		return;
	Logger::print("Populating Threadpool with workers...", NULL, INFO, SILENT);
	m_workers.reserve(m_numworkers);
	pthread_mutex_init(&m_jobsmutex, NULL);
	for (unsigned int it = 0; it < m_numworkers; it++)
	{
		pthread_t *new_thread = new pthread_t;
		pthread_create(new_thread, NULL, worker_entry, this);
		pthread_detach(*new_thread);
		m_workers.push_back(new_thread);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, 0x10(%rsp)
callq 0x13eca
leaq 0x68(%rbx), %r15
movq %r15, 0x70(%rbx)
movq %r15, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
movl %ebp, 0x80(%rbx)
movq $0x64, 0xb0(%rbx)
testl %ebp, %ebp
je 0x13775
leaq 0x19694(%rip), %rsi     # 0x2cd6d
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x8032
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xbe10
leaq 0x18(%rsp), %rdi
callq 0x79b8
movl 0x80(%rbx), %esi
movq %rbx, %rdi
callq 0x13b24
leaq 0x88(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x7710
pushq $0x8
popq %r12
leaq 0x48d(%rip), %r13       # 0x13bba
leaq 0x8(%rsp), %rbp
cmpl 0x80(%rbx), %r14d
jae 0x13775
movq %r12, %rdi
callq 0x7520
movq %rax, 0x8(%rsp)
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x78c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x73c0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x13bc4
incl %r14d
jmp 0x13732
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1379c
movq %rax, %r12
leaq 0x18(%rsp), %rdi
callq 0x79b8
jmp 0x1379f
jmp 0x1379c
movq %rax, %r12
jmp 0x137b1
movq %rax, %r12
movq %r15, %rdi
callq 0x140d2
movq 0x10(%rsp), %rdi
callq 0x14130
movq %rbx, %rdi
callq 0x140fc
movq %r12, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::~Threadpool()
Threadpool::~Threadpool()
{
	if (!m_numworkers)
		return;
	while (m_currentjobs.size())
		usleep(1);
	for (unsigned int it = 0; it < m_numworkers; it++)
		delete m_workers[it];
	Client *job;
	while (m_jobs.size() && (job = m_jobs.back()))
	{
		delete job->req;
		delete job;
		m_jobs.pop_back();
	}
	pthread_mutex_destroy(&m_jobsmutex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x80(%rdi)
je 0x13880
pushq $0x1
popq %rbp
cmpq $0x0, 0x78(%rbx)
je 0x137f0
movl %ebp, %edi
callq 0x76a0
jmp 0x137e0
xorl %r15d, %r15d
pushq $0x8
popq %r14
movl 0x80(%rbx), %eax
cmpq %rax, %r15
jae 0x13816
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x7530
incq %r15
jmp 0x137f7
leaq 0x18(%rbx), %r14
movl $0x200, %r13d           # imm = 0x200
pushq $0x10
popq %r15
movq %r14, %rdi
callq 0x13be2
testq %rax, %rax
je 0x13874
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x13846
movq 0x60(%rbx), %rax
movq -0x8(%rax), %rax
addq %r13, %rax
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x13874
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x1385f
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7530
movq %r14, %rdi
callq 0x13bf2
jmp 0x13824
leaq 0x88(%rbx), %rdi
callq 0x75a0
leaq 0x68(%rbx), %rdi
callq 0x140d2
leaq 0x18(%rbx), %rdi
callq 0x14130
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x140fc
movq %rax, %rdi
callq 0x8f59
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::operator=(Threadpool const&)
Threadpool &				Threadpool::operator=(Threadpool const &rhs)
{
	if ( this != &rhs )
	{
		this->m_numworkers = rhs.m_numworkers;
		this->m_workers = rhs.m_workers;
		this->m_jobs = rhs.m_jobs;
		this->m_jobsmutex = rhs.m_jobsmutex;
		this->m_maxqueuedjobs = rhs.m_maxqueuedjobs;
	}
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1391a
movq %rsi, %r14
movl 0x80(%rsi), %eax
movl %eax, 0x80(%rbx)
movq %rbx, %rdi
callq 0x13c0a
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x13cd4
movups 0x88(%r14), %xmm0
movups 0x98(%r14), %xmm1
movups %xmm0, 0x88(%rbx)
movups %xmm1, 0x98(%rbx)
movq 0xa8(%r14), %rax
movq %rax, 0xa8(%rbx)
movq 0xb0(%r14), %rax
movq %rax, 0xb0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::AddJob(Client&)
bool					Threadpool::AddJob(Client &client)
{
	if (!m_numworkers || (m_jobs.size() > m_maxqueuedjobs))
		return(handle_server_response(client));
	Client *threaded_client = new Client;
	threaded_client->sckt = client.sckt;
	Lock();
	threaded_client->req = client.req;
	client.req = new Request(client.sckt->getServerPort());
	m_jobs.push_front(threaded_client);
	Unlock();
	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x0, 0x80(%rdi)
je 0x1397e
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x13be2
cmpq 0xb0(%rbx), %rax
jbe 0x13991
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x24629
pushq $0x10
popq %rdi
callq 0x7520
movq %rax, %r12
movq %rax, (%rsp)
movq (%r14), %rax
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x13926
movq 0x8(%r14), %rax
movq %rax, 0x8(%r12)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x7520
movq %rax, %r12
movq (%r14), %rdi
callq 0xf19a
movq %r12, %rdi
movl %eax, %esi
callq 0x274d8
movq %r12, 0x8(%r14)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x13e44
movq %rbx, %rdi
callq 0x1393c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x1a0, %esi            # imm = 0x1A0
movq %r12, %rdi
callq 0x7530
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Threadpool.cpp
// Function: Threadpool::WaitForWork(void*)
void					*Threadpool::WaitForWork(void *)
{
	while (g_webserv.run)
	{
		Lock();
		if (!g_webserv.run)
			return NULL;
		if (m_jobs.size())
		{
			Client *job = m_jobs.back();
			m_jobs.pop_back();
			m_currentjobs.push_back(job);
			Unlock();
			handle_server_response(*job);
			Lock();
			m_currentjobs.remove(job);
			delete job->req;
			delete job;
			Unlock();
		}
		else
		{
			Unlock();
			usleep(100 * m_numworkers);
		}
	}
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x68(%rdi), %r15
leaq 0x2fb7f(%rip), %rbp     # 0x435b0
movq %rsp, %r12
pushq $0x10
popq %r13
cmpb $0x1, (%rbp)
jne 0x13b06
movq %rbx, %rdi
callq 0x13926
cmpb $0x1, (%rbp)
jne 0x13b06
movq %r14, %rdi
callq 0x13be2
testq %rax, %rax
je 0x13aed
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x13a7f
movq 0x60(%rbx), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x13bf2
movq %r15, %rdi
movq %r12, %rsi
callq 0x13e60
movq %rbx, %rdi
callq 0x1393c
movq (%rsp), %rdi
callq 0x24629
movq %rbx, %rdi
callq 0x13926
movq %r15, %rdi
movq %r12, %rsi
callq 0x13e6c
movq (%rsp), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x13ad8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x7530
movq %rbx, %rdi
callq 0x1393c
jmp 0x13a38
movq %rbx, %rdi
callq 0x1393c
imull $0x64, 0x80(%rbx), %edi
callq 0x76a0
jmp 0x13a38
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Types_parser.cpp
// Function: parse_types_file(HashTable*, char const*)
bool	parse_types_file(HashTable *file_formatname, const char *src)
{
	std::ifstream inputFileStream(src);
	if (!inputFileStream.is_open())
		return (false);
	while (!inputFileStream.eof()) {
		std::string line;
		std::string formatname;
		std::getline(inputFileStream, line);
		std::stringstream currentline(line);
		currentline >> formatname;
		if (formatname[0] == '#')
			continue;
		if (formatname.size() && (formatname.size() != line.size()))
		{
			for (int i = 0; i < (std::count(line.begin(), line.end(), ' ') + 1); i++)
			{
				std::string occurrence;
				currentline >> occurrence;
				if (occurrence.size())
					file_formatname->Insert(occurrence, formatname);
			}
		}
	}
	inputFileStream.close();
	return (true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %r14
leaq 0x68(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x78d0
leaq 0xe0(%rsp), %rdi
callq 0x7130
movl %eax, %ebx
testb %al, %al
je 0x1612b
movb %bl, 0x7(%rsp)
leaq 0x58(%rsp), %rbp
leaq 0x28(%rsp), %rbx
leaq 0x270(%rsp), %r13
leaq 0x48(%rsp), %r15
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x88(%rsp,%rax)
jne 0x1611d
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
xorl %ecx, %ecx
movb %cl, 0x38(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb %cl, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x70e0
movq %r13, %rdi
movq %rbx, %rsi
pushq $0x18
popq %rdx
callq 0x7790
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7620
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
je 0x1609c
movq 0x10(%rsp), %rax
testq %rax, %rax
sete %cl
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
sete %al
orb %cl, %al
je 0x160bb
movq %r13, %rdi
callq 0x73f0
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x79b8
jmp 0x1600f
xorl %r12d, %r12d
movq 0x28(%rsp), %rdi
addq %rdi, %rsi
movb $0x20, 0x48(%rsp)
movq %r15, %rdx
callq 0x1619c
cmpq %r12, %rax
jl 0x1609c
movq %rbp, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x7620
cmpq $0x0, 0x50(%rsp)
je 0x1610b
movq %r14, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rdx
callq 0x1327a
movq %r15, %rdi
callq 0x79b8
incq %r12
movq 0x30(%rsp), %rsi
jmp 0x160be
leaq 0x68(%rsp), %rdi
callq 0x70f0
movb 0x7(%rsp), %bl
leaq 0x68(%rsp), %rdi
callq 0x7170
movl %ebx, %eax
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1618a
jmp 0x16157
jmp 0x16152
movq %rax, %rbx
jmp 0x16176
movq %rax, %rbx
jmp 0x16169
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x79b8
leaq 0x270(%rsp), %rdi
callq 0x73f0
leaq 0x8(%rsp), %rdi
callq 0x79b8
leaq 0x28(%rsp), %rdi
callq 0x79b8
leaq 0x68(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::parse_partial(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void URL::parse_partial(const std::string& url)
{
	size_t i = 0;

	_path = url.substr(i, std::min(url.find_first_of("?#", i), url.size()) - i);
	i += _path.size();
	if (url[i] == '?')
	{
		i++;
		_query = url.substr(i, std::min(url.find_first_of('#', i), url.size()) - i);
		if (_query.size() == 0)
			throw std::invalid_argument("Empty query in url");
		i += _query.size();
	}
	if (url[i] == '#')
	{
		i++;
		_fragment = url.substr(i, url.size() - i);
		if (_fragment.size() == 0)
			throw std::invalid_argument("Empty fragment in url");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x169d3(%rip), %rsi     # 0x2ceb1
movq %r14, %rdi
xorl %edx, %edx
callq 0x72b0
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7540
leaq 0x88(%rbx), %rdi
movq %r15, %rsi
callq 0x75f0
movq %r15, %rdi
callq 0x79b8
movq 0x90(%rbx), %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x3f, %al
jne 0x1658d
incq %r15
pushq $0x23
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x7650
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
subq %r15, %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7540
leaq 0xa8(%rbx), %rdi
movq %r12, %rsi
callq 0x75f0
movq %r12, %rdi
callq 0x79b8
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x165db
addq %rax, %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x23, %al
jne 0x165cf
incq %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7540
leaq 0xc8(%rbx), %rdi
movq %r12, %rsi
callq 0x75f0
movq %r12, %rdi
callq 0x79b8
cmpq $0x0, 0xd0(%rbx)
je 0x165f7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x168c7(%rip), %rsi     # 0x2ceb4
movq %rax, %rdi
callq 0x7910
jmp 0x16611
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x168be(%rip), %rsi     # 0x2cec7
movq %rax, %rdi
callq 0x7910
movq 0x2c9b0(%rip), %rsi     # 0x42fc8
movq 0x2c991(%rip), %rdx     # 0x42fb0
movq %rbx, %rdi
callq 0x7830
jmp 0x16629
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::parse_full(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void URL::parse_full(const std::string& url)
{
	if (url.substr(0, 7) != "http://")
		throw std::invalid_argument("Full url doesnt start with 'http://'");
	_scheme = "http";
	size_t i = 7;

	parse_userinfo(i, url);
	_host = url.substr(i, url.find_first_of(":/", i) - i);
	if (_host.size() == 0)
		throw std::invalid_argument("Empty host in uri");
	i += _host.size();
	if (url[i] == ':')
	{
		i++;
		_port = url.substr(i, url.find_first_of('/', i) - i);
		if (_port.size() == 0)
			throw std::invalid_argument("Empty port in uri");
		i += _port.size();
	}
	if (url[i] == '/')
		parse_partial(url.substr(i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
pushq $0x7
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x7540
leaq 0x167f1(%rip), %rsi     # 0x2ce58
movq %r15, %rdi
callq 0x8f4f
movl %eax, %ebp
movq %r15, %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0x16796
leaq 0x8(%rbx), %rdi
leaq 0x167f8(%rip), %rsi     # 0x2ce85
callq 0x7930
leaq 0x28(%rsp), %r15
movq $0x7, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16a56
movq (%r15), %r12
leaq 0x167d4(%rip), %rsi     # 0x2ce8a
movq %r14, %rdi
movq %r12, %rdx
callq 0x72b0
subq %r12, %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x7540
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x75f0
movq %r15, %rdi
callq 0x79b8
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x167b2
addq %r12, %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x3a, %al
jne 0x1675a
incq %r15
pushq $0x2f
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x7650
subq %r15, %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x7540
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
callq 0x75f0
movq %r12, %rdi
callq 0x79b8
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x167ce
addq %rax, %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x2f, %al
jne 0x16789
leaq 0x8(%rsp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7540
movq %rbx, %rdi
movq %r12, %rsi
callq 0x164c6
leaq 0x8(%rsp), %rdi
callq 0x79b8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x166b8(%rip), %rsi     # 0x2ce60
movq %rax, %rdi
callq 0x7910
jmp 0x167e8
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x166c9(%rip), %rsi     # 0x2ce8d
movq %rax, %rdi
callq 0x7910
jmp 0x167e8
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x166bf(%rip), %rsi     # 0x2ce9f
movq %rax, %rdi
callq 0x7910
movq 0x2c7d9(%rip), %rsi     # 0x42fc8
movq 0x2c7ba(%rip), %rdx     # 0x42fb0
movq %r14, %rdi
callq 0x7830
jmp 0x16811
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0x1681c
jmp 0x16811
movq %rax, %rbx
movq %r14, %rdi
callq 0x73d0
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::operator=(URL const&)
URL& URL::operator=(const URL& other)
{
	_scheme = other._scheme;
	_userinfo = other._userinfo;
	_host = other._host;
	_port = other._port;
	_path = other._path;
	_query = other._query;
	_fragment = other._fragment;
	_is_directory = other._is_directory;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x7300
leaq 0x28(%r14), %rsi
leaq 0x28(%rbx), %rdi
callq 0x7300
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x7300
leaq 0x68(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x7300
movl $0x88, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x7300
movl $0xa8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x7300
movl $0xc8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x7300
movb 0xe8(%r14), %al
movb %al, 0xe8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/URL.cpp
// Function: URL::parse_userinfo(unsigned long&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void URL::parse_userinfo(size_t& i, const std::string& url)
{
	std::string authority = url.substr(i, std::min(url.find('/', i), url.size()) - i);

	if (authority.find('@') == 0)
		throw std::invalid_argument("@ delimiter is present but no user info was given in uri");
	if (!ft::contains(authority, '@'))
	{
		_userinfo = "";
		return;
	}
	_userinfo = authority.substr(0, authority.find('@'));
	i += _userinfo.size() + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r12
pushq $0x2f
popq %rsi
movq %rdx, %rdi
movq %r12, %rdx
callq 0x7650
movq 0x8(%r15), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
subq (%r14), %rcx
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7540
pushq $0x40
popq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x7650
testq %rax, %rax
je 0x16b3c
leaq 0x20(%rsp), %rsi
movb $0x40, (%rsi)
movq %rsp, %rdi
callq 0xc288
testb %al, %al
je 0x16b13
movq %rsp, %r15
pushq $0x40
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x7650
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x7540
leaq 0x28(%rbx), %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0x75f0
movq %r15, %rdi
callq 0x79b8
movq 0x30(%rbx), %rax
movq (%r14), %rcx
addq %rcx, %rax
incq %rax
movq %rax, (%r14)
jmp 0x16b26
addq $0x28, %rbx
leaq 0x16231(%rip), %rsi     # 0x2cd4f
movq %rbx, %rdi
callq 0x7930
movq %rsp, %rdi
callq 0x79b8
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x162d1(%rip), %rsi     # 0x2ce1f
movq %rax, %rdi
callq 0x7910
movq 0x2c46b(%rip), %rsi     # 0x42fc8
movq 0x2c44c(%rip), %rdx     # 0x42fb0
movq %r14, %rdi
callq 0x7830
jmp 0x16b7d
movq %rax, %rbx
movq %r14, %rdi
callq 0x73d0
jmp 0x16b80
jmp 0x16b7d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::toInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int ft::toInt(const std::string& str)
{
	for (size_t i = 0; i < str.size(); ++i)
		if (!std::isdigit(str[i]))
			throw std::invalid_argument("String is not an integer");

	std::istringstream iss(str);
	int ret = 0;
	iss >> ret;
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jae 0x16bea
movsbl (%rax,%rdx), %edi
addl $-0x30, %edi
incq %rdx
cmpl $0xa, %edi
jb 0x16ba6
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x165c0(%rip), %rsi     # 0x2d18c
movq %rax, %rdi
callq 0x7910
movq 0x2c3ed(%rip), %rsi     # 0x42fc8
movq 0x2c3ce(%rip), %rdx     # 0x42fb0
movq %rbx, %rdi
callq 0x7830
leaq 0x8(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x7800
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x7360
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x7250
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7250
jmp 0x16c3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::hexToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int			ft::hexToInt(const std::string& str)
{
	unsigned int out;
    std::stringstream ss;
    ss << std::hex << str;
    ss >> out;
	return (static_cast<int>(out));
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x73a0
leaq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x30(%rsp,%rax)
movq %rbx, %rsi
callq 0x74a0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7850
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x73f0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x73f0
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::split(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::list<std::string> ft::split(const std::string& str, const std::string& charset)
{
	std::list<std::string> ret;

	size_t i = str.find_first_not_of(charset, 0);
	while (i < str.size())
	{
		size_t word_start = i;
		i = str.find_first_of(charset, i);
		size_t word_end = i;
		i = str.find_first_not_of(charset, i);
		ret.push_back(str.substr(word_start, word_end - word_start));
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x7470
movq %rax, %r13
leaq 0x8(%rsp), %r12
cmpq 0x8(%r15), %r13
jae 0x16f9e
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x74b0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7470
movq %rax, %rbp
subq %r13, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x7540
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xbe78
movq %r12, %rdi
callq 0x79b8
movq %rbp, %r13
jmp 0x16f49
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0x16fc3
movq %rax, %r14
movq (%rsp), %rdi
callq 0x8f64
movq %r14, %rdi
callq 0x7860