LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x181d7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movq 0x35ea1(%rip), %r15     # 0x4dfa8
leaq 0x22989(%rip), %r13     # 0x3aa97
leaq 0x254ff(%rip), %rbp     # 0x3d614
movq %rdi, (%rsp)
movq (%rdi), %rax
movq (%rax,%r14,8), %rbx
testq %rbx, %rbx
je 0x1818f
movq %r15, %rdi
movq %r14, %rsi
callq 0x7330
movl $0x3, %edx
movq %rax, %rdi
leaq 0x22c0a(%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 0x18144
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 0x18119
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/HashTable.cpp
// Function: HashTable::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 0x17ea8
movl %eax, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
je 0x18220
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, 0x8(%rbx)
jne 0x18217
testq %r15, %r15
je 0x1824b
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74c0
testl %eax, %eax
je 0x1824b
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x181fa
movl $0x28, %edi
callq 0x7260
movq %rax, %rbx
movq %rax, %rdi
callq 0x1826c
leaq 0x35984(%rip), %rsi     # 0x4dbc0
leaq 0x75(%rip), %rdx        # 0x182b8
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
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %esi
movl $0x2, %edi
callq 0x7560
movq 0x35c52(%rip), %rbx     # 0x4dfa8
leaq 0x22a3c(%rip), %rsi     # 0x3ad99
movl $0x2, %edx
movq %rbx, %rdi
callq 0x7510
movq %rbx, %rdi
callq 0x7340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x22a1a(%rip), %rsi     # 0x3ad9c
leaq 0x22a2f(%rip), %rdx     # 0x3adb8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x80f4
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
movl $0x2, %ecx
callq 0xdea4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x183c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x361a0(%rip), %rax     # 0x4e568
movb $0x0, (%rax)
leaq -0x99(%rip), %rsi       # 0x18339
movl $0x2, %edi
callq 0x7560
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x183fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
movq %r14, %rdi
xorl %esi, %esi
callq 0x18f1c
leaq 0x68(%rbx), %r13
movq %r13, 0x70(%rbx)
movq %r13, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
movl %ebp, 0x80(%rbx)
movq $0x64, 0xb0(%rbx)
testl %ebp, %ebp
je 0x1854c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x22930(%rip), %rsi     # 0x3adb9
leaq 0x2294e(%rip), %rdx     # 0x3adde
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x2, %ecx
callq 0xdea4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x184c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movl 0x80(%rbx), %esi
movq %rbx, %rdi
callq 0x18a60
leaq 0x88(%rbx), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x7680
cmpl $0x0, 0x80(%rbx)
je 0x1854c
leaq 0x60a(%rip), %r15       # 0x18afc
movq %rsp, %r12
movl $0x8, %edi
callq 0x74a0
movq %rax, (%rsp)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x7860
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x7380
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x18537
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x18542
movq %rbx, %rdi
movq %r12, %rdx
callq 0x19106
incl %ebp
cmpl 0x80(%rbx), %ebp
jb 0x184f5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18580
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x18583
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x18583
jmp 0x18580
movq %rax, %r15
jmp 0x185a9
movq %rax, %r15
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x185a1
movq (%rdi), %r12
movl $0x18, %esi
callq 0x74b0
movq %r12, %rdi
cmpq %r13, %r12
jne 0x1858c
movq %r14, %rdi
callq 0x19092
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x185bd
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x74b0
movq %r15, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x80(%rdi)
je 0x186ae
cmpq $0x0, 0x78(%rbx)
je 0x185f1
movl $0x1, %edi
callq 0x7610
jmp 0x185de
cmpl $0x0, 0x80(%rbx)
je 0x1861c
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
movl $0x8, %esi
callq 0x74b0
incq %r14
movl 0x80(%rbx), %eax
cmpq %rax, %r14
jb 0x185fd
leaq 0x18(%rbx), %r14
movl $0x200, %r12d           # imm = 0x200
movq 0x60(%rbx), %rax
movq %rax, %rsi
subq 0x40(%rbx), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
shlq $0x6, %rsi
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, %r8
subq %rdx, %r8
sarq $0x3, %r8
addq %rsi, %r8
subq 0x28(%rbx), %rdi
sarq $0x3, %rdi
addq %r8, %rdi
je 0x186a2
cmpq %rdx, %rcx
jne 0x18673
movq -0x8(%rax), %rcx
addq %r12, %rcx
movq -0x8(%rcx), %r15
testq %r15, %r15
je 0x186a2
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1868b
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %esi
movq %r15, %rdi
callq 0x74b0
movq %r14, %rdi
callq 0x18b06
jmp 0x18626
leaq 0x88(%rbx), %rdi
callq 0x7530
leaq 0x68(%rbx), %r14
movq 0x68(%rbx), %rdi
cmpq %r14, %rdi
je 0x186d0
movq (%rdi), %r15
movl $0x18, %esi
callq 0x74b0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x186bb
leaq 0x18(%rbx), %rdi
callq 0x19092
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x186f8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x74b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x96aa
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18776
movq %rsi, %r14
movl 0x80(%rsi), %eax
movl %eax, 0x80(%rbx)
movq %rbx, %rdi
callq 0x18b52
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x18c36
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_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
cmpl $0x0, 0x80(%rdi)
je 0x1880c
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq %rax, %rcx
subq 0x40(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x38(%rdi), %rax
movq 0x48(%rdi), %rdx
subq 0x50(%rdi), %rdx
sarq $0x3, %rdx
subq 0x28(%rdi), %rax
sarq $0x3, %rax
addq %rdx, %rax
addq %rcx, %rax
cmpq 0xb0(%rdi), %rax
jbe 0x18821
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2e88d
movl $0x10, %edi
callq 0x74a0
movq %rax, %r12
movq %rax, 0x8(%rsp)
movq (%r14), %rax
movq %rax, (%r12)
leaq 0x88(%rbx), %r15
movq %r15, %rdi
callq 0x7660
movq 0x8(%r14), %rax
movq %rax, 0x8(%r12)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x74a0
movq %rax, %r13
movq (%r14), %rdi
callq 0x12388
movq %r13, %rdi
movl %eax, %esi
callq 0x333ee
movq %r13, 0x8(%r14)
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
je 0x1888a
movq %r12, -0x8(%rax)
addq $-0x8, 0x28(%rbx)
jmp 0x18898
leaq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1aac0
cmpl $0x0, 0x80(%rbx)
je 0x188a9
movq %r15, %rdi
callq 0x73c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x1a0, %esi            # imm = 0x1A0
movq %r13, %rdi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x35c84(%rip), %rbp     # 0x4e568
movb (%rbp), %al
cmpb $0x1, %al
jne 0x18a43
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
leaq 0x18(%rdi), %r15
leaq 0x68(%rdi), %r12
movq %rsp, %r13
cmpl $0x0, 0x80(%rbx)
je 0x18918
movq %r14, %rdi
callq 0x7660
movb (%rbp), %al
testb $0x1, %al
je 0x18a43
movq 0x60(%rbx), %rax
movq %rax, %rsi
subq 0x40(%rbx), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
shlq $0x6, %rsi
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, %r8
subq %rdx, %r8
sarq $0x3, %r8
addq %rsi, %r8
subq 0x28(%rbx), %rdi
sarq $0x3, %rdi
addq %r8, %rdi
jne 0x18982
cmpl $0x0, 0x80(%rbx)
je 0x18a31
movq %r14, %rdi
callq 0x73c0
imull $0x64, 0x80(%rbx), %edi
jmp 0x18a33
cmpq %rdx, %rcx
jne 0x18993
movq -0x8(%rax), %rcx
movl $0x200, %eax            # imm = 0x200
addq %rax, %rcx
movq -0x8(%rcx), %rax
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x18b06
movl $0x18, %edi
callq 0x74a0
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x7090
incq 0x78(%rbx)
cmpl $0x0, 0x80(%rbx)
je 0x189d5
movq %r14, %rdi
callq 0x73c0
movq (%rsp), %rdi
callq 0x2e88d
cmpl $0x0, 0x80(%rbx)
je 0x189ef
movq %r14, %rdi
callq 0x7660
movq %r12, %rdi
movq %r13, %rsi
callq 0x18e8a
movq (%rsp), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x18a14
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x74b0
cmpl $0x0, 0x80(%rbx)
je 0x18a38
movq %r14, %rdi
callq 0x73c0
jmp 0x18a38
xorl %edi, %edi
callq 0x7610
movb (%rbp), %al
testb %al, %al
jne 0x18904
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1fcd9(%rip), %rsi     # 0x3aefd
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x76c0
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x74d0
leaq 0x88(%rbx), %rdi
movq %r15, %rsi
callq 0x7590
movq (%r15), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x1b277
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x90(%rbx), %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x3f, %al
jne 0x1b2f6
incq %r15
movq %r14, %rdi
movl $0x23, %esi
movq %r15, %rdx
callq 0x75c0
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
subq %r15, %rcx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74d0
leaq 0xa8(%rbx), %rdi
movq %r12, %rsi
callq 0x7590
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1b2e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x1b352
addq %rax, %r15
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x23, %al
jne 0x1b344
incq %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74d0
leaq 0xc8(%rbx), %rdi
movq %r12, %rsi
callq 0x7590
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1b33a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq $0x0, 0xd0(%rbx)
je 0x1b370
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x1fb9a(%rip), %rsi     # 0x3af00
movq %rax, %rdi
callq 0x78c0
jmp 0x1b38c
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x1fb8f(%rip), %rsi     # 0x3af13
movq %rax, %rdi
callq 0x78c0
movq 0x32c35(%rip), %rsi     # 0x4dfc8
movq 0x32c16(%rip), %rdx     # 0x4dfb0
movq %rbx, %rdi
callq 0x77d0
jmp 0x1b3a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdx, %rdi
movl $0x2f, %esi
movq %r12, %rdx
callq 0x75c0
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 0x74d0
movq %r13, %rdi
movl $0x40, %esi
xorl %edx, %edx
callq 0x75c0
testq %rax, %rax
je 0x1ba47
leaq 0x20(%rsp), %rdx
movb $0x40, (%rdx)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq %rdi, %rsi
callq 0xf389
movq (%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x1ba02
movq %rsp, %r15
movq %r15, %rdi
movl $0x40, %esi
xorl %edx, %edx
callq 0x75c0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x74d0
leaq 0x28(%rbx), %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0x7590
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1b9f0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x30(%rbx), %rax
movq (%r14), %rcx
addq %rcx, %rax
incq %rax
movq %rax, (%r14)
jmp 0x1ba1e
movq 0x30(%rbx), %rdx
addq $0x28, %rbx
leaq 0x1f38a(%rip), %rcx     # 0x3ad9b
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x76f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ba39
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x1f410(%rip), %rsi     # 0x3ae6b
movq %rax, %rdi
callq 0x78c0
movq 0x3255e(%rip), %rsi     # 0x4dfc8
movq 0x3253f(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x1ba8d
jmp 0x1ba8a
jmp 0x1ba8a
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1baa8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/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 0x8(%rdi), %rax
testq %rax, %rax
je 0x1badf
movq (%rsi), %rcx
xorl %edx, %edx
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x1bb33
incq %rdx
cmpq %rdx, %rax
jne 0x1bacb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x7790
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x7320
movl 0x4(%rsp), %ebx
movq 0x32481(%rip), %rsi     # 0x4df90
leaq 0x8(%rsp), %rdi
callq 0x7630
leaq 0x80(%rsp), %rdi
callq 0x71c0
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x1f691(%rip), %rsi     # 0x3b1d8
movq %rax, %rdi
callq 0x78c0
movq 0x32472(%rip), %rsi     # 0x4dfc8
movq 0x32453(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq 0x32421(%rip), %rsi     # 0x4df90
leaq 0x8(%rsp), %rdi
callq 0x7630
leaq 0x80(%rsp), %rdi
callq 0x71c0
jmp 0x1bb93
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7360
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
movq 0x8(%rbx), %rdx
callq 0x7510
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7800
movl 0x4(%rsp), %ebx
movq 0x3208b(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x3205f(%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_O3/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)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x77a0
cmpq 0x8(%r15), %rax
jae 0x1c042
movq %rax, %rbp
leaq 0x18(%rsp), %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbp, %rdx
callq 0x76c0
movq %rax, %r12
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rax, %rdx
callq 0x77a0
movq %rax, %r13
subq %rbp, %r12
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x74d0
movl $0x30, %edi
callq 0x74a0
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
cmpq %rbx, %rdx
je 0x1bfe8
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1bfee
movups (%rbx), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, %rdi
movq (%rsp), %r12
movq %r12, %rsi
callq 0x7090
incq 0x10(%r12)
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1c035
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r13, %rbp
cmpq 0x8(%r15), %r13
jb 0x1bf7a
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c074
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1c074
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
callq 0x96b6
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const&)
std::list<std::string> ft::split(const std::string& str, const char &needle)
{
	std::list<std::string> ret;

	size_t i = str.find_first_not_of(needle, 0);
	while (i < str.size())
	{
		size_t word_start = i;
		i = str.find_first_of(needle, i);
		size_t word_end = i;
		i = str.find_first_not_of(needle, 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)
movq $0x0, 0x10(%rdi)
movsbl (%rdx), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x7440
cmpq 0x8(%r15), %rax
jae 0x1c194
movq %rax, %rbp
leaq 0x18(%rsp), %r12
movq %r12, %rbx
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x75c0
movq %rax, %r12
movsbl (%r14), %esi
movq %r15, %rdi
movq %rax, %rdx
callq 0x7440
movq %rax, %r13
subq %rbp, %r12
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x74d0
movl $0x30, %edi
movq %rbx, %r12
callq 0x74a0
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
cmpq %r12, %rdx
je 0x1c139
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1c141
movups (%r12), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, %rdi
movq (%rsp), %rbx
movq %rbx, %rsi
callq 0x7090
incq 0x10(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c187
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r13, %rbp
cmpq 0x8(%r15), %r13
jb 0x1c0cb
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c1c6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c1c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
callq 0x96b6
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_directory(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return S_ISDIR(st.st_mode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x2f, (%rdi)
je 0x1cddf
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1ce54
leaq 0x1ddb4(%rip), %rsi     # 0x3aa94
movq %r14, %rdi
callq 0x78d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1cd0f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1cd16
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x7190
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1cd66
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1cd6e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x1cdaa
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cdc1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cddc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rbx), %rdi
leaq 0x68(%rsp), %rbx
movq %rbx, %rsi
callq 0x78e0
testl %eax, %eax
setns %cl
movl 0x18(%rbx), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb %cl, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ce31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1ce31
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ce4c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::get_cwd[abi:cxx11]()
std::string ft::get_cwd()
{
	std::string cwd;
	char *buf = getcwd(NULL, 0);
	if (buf == NULL)
		return "";
	cwd += buf;
	free(buf);
	return cwd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorl %edi, %edi
xorl %esi, %esi
callq 0x7290
testq %rax, %rax
je 0x1ceb7
movq %rax, %r14
movq %rsp, %rdi
movq %rax, %rsi
callq 0x78d0
movq %r14, %rdi
callq 0x7570
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
cmpq %r15, %rcx
je 0x1cee8
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x1ceef
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1ded6(%rip), %rdx     # 0x3ad9b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80f4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1cef8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1cef8
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1cf07
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1cf20
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_regular_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_regular_file(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return S_ISREG(st.st_mode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x2f, (%rdi)
je 0x1d058
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1ce54
leaq 0x1db3b(%rip), %rsi     # 0x3aa94
movq %r14, %rdi
callq 0x78d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1cf88
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1cf8f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x7190
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1cfdf
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1cfe7
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x1d023
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d03a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d055
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rbx), %rdi
leaq 0x68(%rsp), %rbx
movq %rbx, %rsi
callq 0x78e0
testl %eax, %eax
setns %cl
movl 0x18(%rbx), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
andb %cl, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d0aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d0aa
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d0c5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::is_executable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ft::is_executable(std::string realPath)
{
	struct stat st;
	if (realPath[0] != '/')
		realPath = ft::get_cwd() + "/" + realPath;
	if (lstat(realPath.c_str(), &st) < 0)
		return false;
	return st.st_mode & S_IXUSR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x2f, (%rdi)
je 0x1d1fd
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1ce54
leaq 0x1d996(%rip), %rsi     # 0x3aa94
movq %r14, %rdi
callq 0x78d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1d12d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1d134
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x7190
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1d184
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1d18c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7590
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x1d1c8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d1df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d1fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rbx), %rdi
leaq 0x68(%rsp), %rbx
movq %rbx, %rsi
callq 0x78e0
testl %eax, %eax
setns %cl
movl 0x18(%rbx), %eax
andl $0x40, %eax
shrl $0x6, %eax
andb %cl, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d248
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d248
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d263
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::strncpy(char*, char const*, unsigned long)
char	*ft::strncpy(char *dest, const char *src, size_t n)
{
	size_t i;

	for (i = 0; i < n && src[i] != '\0'; i++)
		dest[i] = src[i];
	for ( ; i < n; i++)
		dest[i] = '\0';
	return (dest);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
testq %rdx, %rdx
je 0x1d5cb
movb (%rsi,%rdi), %al
testb %al, %al
je 0x1d5cb
movb %al, (%rbx,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x1d5b7
jmp 0x1d5da
subq %rdi, %rdx
jbe 0x1d5da
addq %rbx, %rdi
xorl %esi, %esi
callq 0x72e0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Utils.cpp
// Function: ft::get_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string ft::get_extension(std::string path)
{
	if (path[path.size() - 1] == '/')
		path.erase(--path.end());

	if (!ft::contains(path, '.'))
		return "";

	if (!ft::contains(path, '/'))
	{
		if (path.rfind('.') == 0)
			return "";
		return path.substr(path.rfind('.'));
	}

	if (!ft::contains(path.substr(path.rfind('/') + 1), '.'))
		return "";

	if (path.substr(path.rfind('/') + 1).rfind('.') == 0)
		return "";

	return path.substr(path.rfind('/') + 1 + (path.rfind('.') - path.rfind('/') - 1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpb $0x2f, -0x1(%rdi,%rsi)
jne 0x1d63a
addq %rdi, %rsi
decq %rsi
subq %rdi, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x7540
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdx
movb $0x2e, (%rdx)
addq %rdi, %rsi
callq 0xf389
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
cmpq %rsi, %rax
je 0x1d7ea
leaq 0x10(%rsp), %rdx
movb $0x2f, (%rdx)
callq 0xf389
movq (%r14), %rcx
addq 0x8(%r14), %rcx
movq %r14, %rdi
cmpq %rcx, %rax
je 0x1d7a9
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x7900
leaq 0x1(%rax), %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x74d0
leaq 0xf(%rsp), %rdx
movb $0x2e, (%rdx)
movq (%r12), %rdi
movq 0x8(%r12), %rsi
addq %rdi, %rsi
callq 0xf389
movq %rax, %r15
movq (%r12), %rdi
movq 0x8(%r12), %r12
addq %rdi, %r12
leaq 0x20(%rsp), %r13
cmpq %r13, %rdi
je 0x1d6e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq %r12, %r15
je 0x1d7ea
movq %r14, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x7900
leaq 0x1(%rax), %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x74d0
movq %r12, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7900
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1d74d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
testq %r15, %r15
je 0x1d7ea
movq %r14, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x7900
movq %rax, %r15
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7900
movq %rax, %r12
movq %r14, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x7900
addq %r15, %r12
subq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0x1d7dc
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7900
testq %rax, %rax
je 0x1d7ea
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7900
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x74d0
jmp 0x1d803
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d5a3(%rip), %rdx     # 0x3ad9b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80f4
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Utils/Webserv.cpp
// Function: s_webserv::s_webserv()
s_webserv::s_webserv()
	: run(true), debug(DEBUG), file_formatname(new HashTable(256)), languages(new HashTable(256)), cwd(ft::get_cwd()), workers_amount(0), max_connections(100), compression_deflate(false), compression_gzip(false), compression_level(6)
{
	init_factories();
	parse_types_file(file_formatname, (cwd+"/config/mime.types").c_str());
	parse_types_file(file_formatname, "/etc/mime.types");
	init_languages();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movw $0x1, (%rdi)
movl $0x10, %edi
callq 0x74a0
movq %rax, %r14
movq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x17d68
movq %r14, 0x8(%rbx)
movl $0x10, %edi
callq 0x74a0
movq %rax, %r14
movq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x17d68
movq %r14, 0x10(%rbx)
leaq 0x20(%rbx), %rax
movl $0x0, 0x20(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
callq 0x1ce54
leaq 0x303ae(%rip), %rax     # 0x4dc40
movq %rax, 0x68(%rbx)
leaq 0x70(%rbx), %rax
movq %rax, 0x78(%rbx)
movq %rax, 0x70(%rbx)
xorl %eax, %eax
movq %rax, 0x80(%rbx)
leaq 0x303be(%rip), %rcx     # 0x4dc70
movq %rcx, 0x88(%rbx)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rcx, 0x90(%rbx)
movq %rax, 0xa0(%rbx)
leaq 0xa8(%rbx), %r14
movq %r14, 0xb0(%rbx)
movq %r14, 0xa8(%rbx)
movq %rax, 0xb8(%rbx)
movabsq $0x6400000000, %rcx     # imm = 0x6400000000
movq %rcx, 0xc0(%rbx)
movb %al, 0xc8(%rbx)
movb %al, 0xc9(%rbx)
movl $0x6, 0xcc(%rbx)
movq %rbx, %rdi
callq 0x1da22
movq 0x8(%rbx), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x8a92
leaq 0x1debe(%rip), %rsi     # 0x3b806
movq %rsp, %rdi
callq 0x78d0
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x1ab88
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d972
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rbx), %rdi
leaq 0x1de9c(%rip), %rsi     # 0x3b819
callq 0x1ab88
movq %rbx, %rdi
callq 0x1e02e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1d99a
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d9d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d9d3
jmp 0x1d9d0
movq %rax, %r15
jmp 0x1da0e
jmp 0x1d9be
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x74b0
jmp 0x1da1a
movq %rax, %r15
leaq 0x68(%rbx), %r12
leaq 0x88(%rbx), %r13
movq %r14, %rdi
callq 0x277f6
movq %r13, %rdi
callq 0x276d4
movq %r12, %rdi
callq 0x27730
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x1da0e
movq (%rax), %rsi
incq %rsi
callq 0x74b0
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2782e
movq %r15, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::~Factory()
virtual ~Factory()
		{
			if (_elements.empty())
				return;
			for (typename std::list<value_type>::iterator it = _elements.begin(); it != _elements.end(); it++)
				delete *it;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2658d(%rip), %rax     # 0x4dc70
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x2770d
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x27702
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x276f3
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x2772a
movq (%r14), %r15
movl $0x18, %esi
movq %r14, %rdi
callq 0x74b0
movq %r15, %r14
cmpq %rbx, %r15
jne 0x27712
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::operator=(ConfigContext const&)
ConfigContext& ConfigContext::operator=(const ConfigContext& other)
{
	_params = other._params;
	_error_pages = other._error_pages;
	_autoIndex = other._autoIndex;
	_directive_names = other._directive_names;
	_childs = other._childs;
	_names = other._names;
	_acceptedMethods = other._acceptedMethods;
	_cgi_exts = other._cgi_exts;
	_uploads_exts = other._uploads_exts;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x2c2d6
leaq 0x68(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x2c702
movb 0x110(%r14), %al
movb %al, 0x110(%rbx)
cmpq %r14, %rbx
je 0x27cb5
leaq 0x8(%r14), %rdx
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2ce64
leaq 0x50(%r14), %rdx
leaq 0x50(%rbx), %rdi
movq 0x50(%r14), %rsi
callq 0x2cfd6
movl $0x98, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x98(%r14), %rsi
callq 0x2ce64
movl $0xb0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xb0(%r14), %rsi
callq 0x2d1c8
movl $0xc8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x2ca24
movl $0xf8, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xf8(%r14), %rsi
callq 0x2ce64
jmp 0x27cc8
movl $0xc8, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x2ca24
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::handle_parent_and_directives(ConfigContext const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::handle_parent_and_directives(const ConfigContext* parent, const std::string& name)
{
	if (parent != NULL)
	{
		_params = parent->_params;
		_error_pages = parent->_error_pages;
		_autoIndex = parent->_autoIndex;
		_acceptedMethods = parent->_acceptedMethods;
		_cgi_exts = parent->_cgi_exts;
		_uploads_exts = parent->_uploads_exts;
		_names.push_back(name);
	}
	else
	{
		// Directives réservées aux contexts server{}
		add_server_directives();
		for (std::list<IMethod*>::const_iterator it = g_webserv.methods.getRegistered().begin(); it != g_webserv.methods.getRegistered().end(); it++)
			_acceptedMethods.push_back(*it);
	}
	add_location_directives();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x288a3
movq %rdx, %r14
movq %rsi, %r15
addq $0x20, %rsi
leaq 0x20(%rbx), %rdi
callq 0x2c2d6
leaq 0x68(%r15), %rsi
leaq 0x68(%rbx), %rdi
callq 0x2c702
movb 0x110(%r15), %al
movb %al, 0x110(%rbx)
cmpq %r15, %rbx
je 0x288f6
movl $0xb0, %edi
leaq (%r15,%rdi), %rdx
addq %rbx, %rdi
movq 0xb0(%r15), %rsi
callq 0x2d1c8
movl $0xc8, %edi
leaq (%r15,%rdi), %rsi
addq %rbx, %rdi
callq 0x2ca24
movl $0xf8, %edi
leaq (%r15,%rdi), %rdx
addq %rbx, %rdi
movq 0xf8(%r15), %rsi
callq 0x2ce64
jmp 0x28909
movq %rbx, %rdi
callq 0x2a848
leaq 0x25cb6(%rip), %r15     # 0x4e568
movq 0x70(%r15), %r12
addq $0x70, %r15
cmpq %r15, %r12
je 0x2892d
leaq 0xb0(%rbx), %r14
movl $0x18, %edi
callq 0x74a0
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x7090
incq 0xc0(%rbx)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x288c6
jmp 0x2892d
movl $0xc8, %edi
addq %rdi, %r15
addq %rbx, %rdi
movq %r15, %rsi
callq 0x2ca24
leaq 0x98(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c6b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x7090
incq 0xa8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2aa3e
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::find_closing_bracket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
size_t ConfigContext::find_closing_bracket(const std::string& str, size_t start) const
{
	size_t nesting = 1;

	for (size_t i = start; i < str.size(); i++)
	{
		if (str[i] == '{')
			nesting++;
		if (str[i] == '}')
			nesting--;
		if (nesting == 0)
			return i;
	}
	return size_t(-1);
}

// Assembly:
movq 0x8(%rsi), %rcx
movq $-0x1, %rax
cmpq %rdx, %rcx
jbe 0x28982
movq (%rsi), %rsi
movl $0x1, %edi
movb (%rsi,%rdx), %r8b
xorl %r9d, %r9d
cmpb $0x7b, %r8b
sete %r9b
addq %r9, %rdi
xorl %r9d, %r9d
cmpb $0x7d, %r8b
sete %r9b
subq %r9, %rdi
je 0x28983
incq %rdx
cmpq %rdx, %rcx
jne 0x28958
retq
movq %rdx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_server_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_server_name(const std::string& directive_value)
{
	for (size_t j = 0; j < directive_value.size();)
	{
		std::string name = directive_value.substr(j, directive_value.find_first_of(" \t\n", j) - j);
		j = directive_value.find_first_of(" \t\n", j);
		_names.push_back(name);

		// Si on est arrivé au dernier mot de la directive, on arrête
		if (j >= directive_value.size() || directive_value[j] == '\n')
			break;
		j = directive_value.find_first_not_of(" \t\n", j);
		if (j >= directive_value.size())
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x98(%rdi), %r15
xorl %ebp, %ebp
leaq 0x12edf(%rip), %r12     # 0x3b88b
cmpq 0x8(%rbx), %rbp
jae 0x28a6c
movl $0x3, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x76c0
subq %rbp, %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x74d0
movl $0x3, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x76c0
movq %rax, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x2c6b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x7090
incq 0xa8(%r14)
cmpq 0x8(%rbx), %rbp
jae 0x28a24
movq (%rbx), %rax
cmpb $0xa, (%rax,%rbp)
jne 0x28a29
xorl %r13d, %r13d
jmp 0x28a47
movl $0x3, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x77a0
movq %rax, %rbp
cmpq 0x8(%rbx), %rax
setb %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x28a63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r13b, %r13b
jne 0x289ac
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x28a9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810