LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b2a(%rip), %rbx     # 0x4dfa8
leaq 0x22914(%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 0x228f2(%rip), %rsi     # 0x3ad9c
leaq 0x22907(%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 0xded8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x184e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x36078(%rip), %rax     # 0x4e568
movb $0x0, (%rax)
leaq -0x99(%rip), %rsi       # 0x18461
movl $0x2, %edi
callq 0x7560
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x18526
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19048
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 0x18674
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x22808(%rip), %rsi     # 0x3adb9
leaq 0x22826(%rip), %rdx     # 0x3adde
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x2, %ecx
callq 0xded8
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x185ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movl 0x80(%rbx), %esi
movq %rbx, %rdi
callq 0x18b7c
leaq 0x88(%rbx), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x7680
cmpl $0x0, 0x80(%rbx)
je 0x18674
leaq 0x5f8(%rip), %r15       # 0x18c12
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 0x1865f
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x1866a
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1922a
incl %ebp
cmpl 0x80(%rbx), %ebp
jb 0x1861d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x186a8
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x186ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x186ab
jmp 0x186a8
movq %rax, %r15
jmp 0x186d1
movq %rax, %r15
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x186c9
movq (%rdi), %r12
movl $0x18, %esi
callq 0x74b0
movq %r12, %rdi
cmpq %r13, %r12
jne 0x186b4
movq %r14, %rdi
callq 0x191be
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x186e5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x74b0
movq %r15, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x187db
cmpq $0x0, 0x78(%rbx)
je 0x18719
movl $0x1, %edi
callq 0x7610
jmp 0x18706
cmpl $0x0, 0x80(%rbx)
je 0x18749
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1873b
movl $0x8, %esi
callq 0x74b0
incq %r14
movl 0x80(%rbx), %eax
cmpq %rax, %r14
jb 0x18725
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 0x187cf
cmpq %rdx, %rcx
jne 0x187a0
movq -0x8(%rax), %rcx
addq %r12, %rcx
movq -0x8(%rcx), %r15
testq %r15, %r15
je 0x187cf
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x187b8
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %esi
movq %r15, %rdi
callq 0x74b0
movq %r14, %rdi
callq 0x18c1c
jmp 0x18753
leaq 0x88(%rbx), %rdi
callq 0x7530
leaq 0x68(%rbx), %r14
movq 0x68(%rbx), %rdi
cmpq %r14, %rdi
je 0x187fd
movq (%rdi), %r15
movl $0x18, %esi
callq 0x74b0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x187e8
leaq 0x18(%rbx), %rdi
callq 0x191be
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x18825
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 0x96cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x188a4
movq %rsi, %r14
movl 0x80(%rsi), %eax
movl %eax, 0x80(%rbx)
movq %rbx, %rdi
callq 0x18c68
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x18d3e
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_O1/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 0x18935
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 0x18948
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ebd7
movl $0x10, %edi
callq 0x74a0
movq %rax, (%rsp)
movq (%r14), %rcx
movq %rcx, (%rax)
leaq 0x88(%rbx), %r15
movq %r15, %rdi
callq 0x7660
movq 0x8(%r14), %rax
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x74a0
movq %rax, %r12
movq (%r14), %rdi
callq 0x12416
movq %r12, %rdi
movl %eax, %esi
callq 0x33810
movq %r12, 0x8(%r14)
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
je 0x189b3
movq (%rsp), %rcx
movq %rcx, -0x8(%rax)
addq $-0x8, 0x28(%rbx)
jmp 0x189bf
leaq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0x1ad9c
cmpl $0x0, 0x80(%rbx)
je 0x189d0
movq %r15, %rdi
callq 0x73c0
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 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b60(%rip), %rbp     # 0x4e568
cmpb $0x1, (%rbp)
jne 0x18b5e
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
leaq 0x18(%rdi), %r15
leaq 0x68(%rdi), %r12
movq %rsp, %r13
cmpl $0x0, 0x80(%rbx)
je 0x18a38
movq %r14, %rdi
callq 0x7660
cmpb $0x1, (%rbp)
jne 0x18b5e
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 0x18aa5
cmpl $0x0, 0x80(%rbx)
je 0x18a94
movq %r14, %rdi
callq 0x73c0
imull $0x64, 0x80(%rbx), %edi
callq 0x7610
jmp 0x18b54
cmpq %rdx, %rcx
jne 0x18ab6
movq -0x8(%rax), %rcx
movl $0x200, %eax            # imm = 0x200
addq %rax, %rcx
movq -0x8(%rcx), %rax
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x18c1c
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 0x18af8
movq %r14, %rdi
callq 0x73c0
movq (%rsp), %rdi
callq 0x2ebd7
cmpl $0x0, 0x80(%rbx)
je 0x18b12
movq %r14, %rdi
callq 0x7660
movq %r12, %rdi
movq %r13, %rsi
callq 0x18fb6
movq (%rsp), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x18b30
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x18b43
movl $0x10, %esi
callq 0x74b0
cmpl $0x0, 0x80(%rbx)
je 0x18b54
movq %r14, %rdi
callq 0x73c0
cmpb $0x0, (%rbp)
jne 0x18a27
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_O1/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 0x1f9f7(%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 0x1b559
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x90(%rbx), %r15
movq (%r14), %rax
cmpb $0x3f, (%rax,%r15)
jne 0x1b5d0
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 0x1b5c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x1b632
addq %rax, %r15
movq (%r14), %rax
cmpb $0x23, (%rax,%r15)
jne 0x1b624
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 0x1b61a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq $0x0, 0xd0(%rbx)
je 0x1b650
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x1f8ba(%rip), %rsi     # 0x3af00
movq %rax, %rdi
callq 0x78c0
jmp 0x1b66c
movl $0x10, %edi
callq 0x7260
movq %rax, %rbx
leaq 0x1f8af(%rip), %rsi     # 0x3af13
movq %rax, %rdi
callq 0x78c0
movq 0x32955(%rip), %rsi     # 0x4dfc8
movq 0x32936(%rip), %rdx     # 0x4dfb0
movq %rbx, %rdi
callq 0x77d0
jmp 0x1b684
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x72c0
leaq 0x28(%r14), %rsi
leaq 0x28(%rbx), %rdi
callq 0x72c0
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x72c0
leaq 0x68(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x72c0
movl $0x88, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x72c0
movl $0xa8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x72c0
movl $0xc8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x72c0
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_O1/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 0x1bd39
leaq 0x20(%rsp), %rdx
movb $0x40, (%rdx)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq %rdi, %rsi
callq 0xf3d7
movq (%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x1bcf4
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 0x1bce2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x30(%rbx), %rax
movq (%r14), %rcx
addq %rcx, %rax
incq %rax
movq %rax, (%r14)
jmp 0x1bd10
movq 0x30(%rbx), %rdx
addq $0x28, %rbx
leaq 0x1f098(%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 0x1bd2b
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 0x1f11e(%rip), %rsi     # 0x3ae6b
movq %rax, %rdi
callq 0x78c0
movq 0x3226c(%rip), %rsi     # 0x4dfc8
movq 0x3224d(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x1bd7f
jmp 0x1bd7c
jmp 0x1bd7c
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bd9a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bdd3
movq (%rsi), %rcx
xorl %edx, %edx
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x1be27
incq %rdx
cmpq %rdx, %rax
jne 0x1bdbf
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 0x3218d(%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 0x1f39d(%rip), %rsi     # 0x3b1d8
movq %rax, %rdi
callq 0x78c0
movq 0x3217e(%rip), %rsi     # 0x4dfc8
movq 0x3215f(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
movq 0x3212d(%rip), %rsi     # 0x4df90
leaq 0x8(%rsp), %rdi
callq 0x7630
leaq 0x80(%rsp), %rdi
callq 0x71c0
jmp 0x1be87
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31d89(%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 0x31d5d(%rip), %rsi     # 0x4df70
leaq 0x8(%rsp), %rdi
callq 0x73b0
leaq 0x88(%rsp), %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/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 0x1c344
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 0x1c2ea
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1c2f0
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 0x1c337
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r13, %rbp
cmpq 0x8(%r15), %r13
jb 0x1c27c
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c376
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1c376
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
callq 0x96d8
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c496
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 0x1c43b
movq %rdx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1c443
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 0x1c489
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %r13, %rbp
cmpq 0x8(%r15), %r13
jb 0x1c3cd
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c4c8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c4c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq (%rsp), %rdi
callq 0x96d8
movq %r14, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpb $0x2f, (%rax)
je 0x1d0e1
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1d159
leaq 0x1daaf(%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 0x1d014
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1d01b
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 0x1d06b
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1d073
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 0x1d0af
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d0c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d0e1
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 0x1d136
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d136
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d151
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d1bc
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 0x1d1d7
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x1d1de
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1dbd1(%rip), %rdx     # 0x3ad9b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x80f4
jmp 0x1d1f9
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1d20f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1d21e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1d237
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Utils/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), %rax
cmpb $0x2f, (%rax)
je 0x1d36c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1d159
leaq 0x1d824(%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 0x1d29f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1d2a6
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 0x1d2f6
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1d2fe
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 0x1d33a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d351
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d36c
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 0x1d3c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d3c1
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d3dc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpb $0x2f, (%rax)
je 0x1d511
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1d159
leaq 0x1d67f(%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 0x1d444
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1d44b
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 0x1d49b
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x1d4a3
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 0x1d4df
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d4f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d511
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 0x1d55f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1d55f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d57a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d8e3
movb (%rsi,%rdi), %al
testb %al, %al
je 0x1d8e3
movb %al, (%rbx,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x1d8ce
movq %rdx, %rdi
subq %rdi, %rdx
jbe 0x1d8f2
addq %rbx, %rdi
xorl %esi, %esi
callq 0x72e0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x8(%rsi), %rsi
cmpb $0x2f, -0x1(%rax,%rsi)
jne 0x1d945
decq %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x7540
leaq 0x10(%rsp), %rdx
movb $0x2e, (%rdx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
callq 0xf3d7
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
cmpq %rsi, %rax
je 0x1dafc
leaq 0x10(%rsp), %rdx
movb $0x2f, (%rdx)
callq 0xf3d7
movq (%r14), %rcx
addq 0x8(%r14), %rcx
movq %r14, %rdi
cmpq %rcx, %rax
je 0x1dabb
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 0xf3d7
movq %rax, %r15
movq (%r12), %rdi
movq 0x8(%r12), %r12
addq %rdi, %r12
leaq 0x20(%rsp), %r13
cmpq %r13, %rdi
je 0x1d9fa
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
cmpq %r12, %r15
je 0x1dafc
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 0x1da5f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x74b0
testq %r15, %r15
je 0x1dafc
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 0x1daee
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7900
testq %rax, %rax
je 0x1dafc
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 0x1db15
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d291(%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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17e5c
movq %r14, 0x8(%rbx)
movl $0x10, %edi
callq 0x74a0
movq %rax, %r14
movq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x17e5c
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 0x1d159
leaq 0x3009a(%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 0x300aa(%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 0x1dd36
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 0x8a8a
leaq 0x1dbaa(%rip), %rsi     # 0x3b806
movq %rsp, %rdi
callq 0x78d0
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x1ae64
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dc86
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x8(%rbx), %rdi
leaq 0x1db88(%rip), %rsi     # 0x3b819
callq 0x1ae64
movq %rbx, %rdi
callq 0x1e342
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1dcae
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dce7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x1dce7
jmp 0x1dce4
movq %rax, %r15
jmp 0x1dd22
jmp 0x1dcd2
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x74b0
jmp 0x1dd2e
movq %rax, %r15
leaq 0x68(%rbx), %r12
leaq 0x88(%rbx), %r13
movq %r14, %rdi
callq 0x27b42
movq %r13, %rdi
callq 0x27a2e
movq %r12, %rdi
callq 0x27a86
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x1dd22
movq (%rax), %rsi
incq %rsi
callq 0x74b0
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x27b7a
movq %r15, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x26234(%rip), %rax     # 0x4dc70
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x27a60
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x27a5b
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
jmp 0x27a47
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x27a7d
movq (%rdi), %r14
movl $0x18, %esi
callq 0x74b0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x27a68
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c60e
leaq 0x68(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x2ca3c
movb 0x110(%r14), %al
movb %al, 0x110(%rbx)
cmpq %r14, %rbx
je 0x27f95
leaq 0x8(%r14), %rdx
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2d1a2
cmpq %r14, %rbx
je 0x27fab
leaq 0x50(%r14), %rdx
leaq 0x50(%rbx), %rdi
movq 0x50(%r14), %rsi
callq 0x2d314
cmpq %r14, %rbx
je 0x2800b
movl $0x98, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x98(%r14), %rsi
callq 0x2d1a2
movl $0xb0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xb0(%r14), %rsi
callq 0x2d506
movl $0xc8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x2cd60
movl $0xf8, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xf8(%r14), %rsi
callq 0x2d1a2
jmp 0x2801e
movl $0xc8, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x2cd60
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28c06
movq %rdx, %r14
movq %rsi, %r15
addq $0x20, %rsi
leaq 0x20(%rbx), %rdi
callq 0x2c60e
leaq 0x68(%r15), %rsi
leaq 0x68(%rbx), %rdi
callq 0x2ca3c
movb 0x110(%r15), %al
movb %al, 0x110(%rbx)
cmpq %r15, %rbx
je 0x28bb2
movl $0xb0, %edi
leaq (%r15,%rdi), %rdx
addq %rbx, %rdi
movq 0xb0(%r15), %rsi
callq 0x2d506
movl $0xc8, %edi
leaq (%r15,%rdi), %rsi
addq %rbx, %rdi
callq 0x2cd60
cmpq %r15, %rbx
je 0x28be0
movl $0xf8, %edi
leaq (%r15,%rdi), %rdx
addq %rbx, %rdi
movq 0xf8(%r15), %rsi
callq 0x2d1a2
leaq 0x98(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c9ea
movq %rax, %rdi
movq %r15, %rsi
callq 0x7090
incq 0xa8(%rbx)
jmp 0x28c57
movq %rbx, %rdi
callq 0x2ab90
leaq 0x25953(%rip), %r15     # 0x4e568
movq 0x70(%r15), %r12
addq $0x70, %r15
cmpq %r15, %r12
je 0x28c57
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 0x28c29
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ad86
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28cac
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 0x28cad
incq %rdx
cmpq %rdx, %rcx
jne 0x28c82
retq
movq %rdx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12bb5(%rip), %r12     # 0x3b88b
cmpq 0x8(%rbx), %rbp
jae 0x28d96
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 0x2c9ea
movq %rax, %rdi
movq %r15, %rsi
callq 0x7090
incq 0xa8(%r14)
cmpq 0x8(%rbx), %rbp
jae 0x28d4e
movq (%rbx), %rax
cmpb $0xa, (%rax,%rbp)
jne 0x28d53
xorl %r13d, %r13d
jmp 0x28d71
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 0x28d8d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
testb %r13b, %r13b
jne 0x28cd6
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 0x28dc4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7810
// File: /workspace/github_cpp_makefile_star2_O1/mbourand[P]webserv/srcs/Config/ConfigContext.cpp
// Function: ConfigContext::parse_autoindex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ConfigContext::parse_autoindex(const std::string& directive_value)
{
	std::list<std::string> words = ft::split(directive_value, " \t\n");
	std::string val = words.front();

	if (val != "on" && val != "off")
		throw std::invalid_argument("Bad value for autoindex in config");
	_autoIndex = (val == "on" ? true : false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x127fe(%rip), %rsi     # 0x3b88b
leaq 0x127fa(%rip), %rdx     # 0x3b88e
leaq 0x8(%rsp), %rdi
callq 0x80f4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x1c232
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x290c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
movq 0x28(%rsp), %rax
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x8a8a
leaq 0x1104c(%rip), %rsi     # 0x3a137
leaq 0x8(%rsp), %rdi
callq 0x7180
testl %eax, %eax
je 0x2910e
leaq 0x127ab(%rip), %rsi     # 0x3b8ab
leaq 0x8(%rsp), %rdi
callq 0x7180
testl %eax, %eax
jne 0x29154
leaq 0x11022(%rip), %rsi     # 0x3a137
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7180
testl %eax, %eax
sete 0x110(%rbx)
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x29140
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
leaq 0x28(%rsp), %rdi
callq 0x96d8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7260
movq %rax, %r14
leaq 0x13e15(%rip), %rsi     # 0x3cf7d
movq %rax, %rdi
callq 0x78c0
movq 0x24e51(%rip), %rsi     # 0x4dfc8
movq 0x24e32(%rip), %rdx     # 0x4dfb0
movq %r14, %rdi
callq 0x77d0
movq %rax, %rbx
jmp 0x29196
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x291b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x291b2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x96d8
jmp 0x291dd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x291dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x74b0
jmp 0x291dd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7810
nop