LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setRoot(char const*)
void Location::setRoot(char const *r) 
{
	std::string cString = r;
	if (numberOfWords(r) != 1)
		throw std::runtime_error("Error : " + std::string(cString) + " - put only one root path\n");
	_root = *wsTrim(cString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x518a
movq %r14, %rdi
callq 0x9ffe
cmpq $0x1, %rax
jne 0x8f6a
leaq -0x48(%rbp), %rdi
callq 0xa0c9
addq $0x8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4240
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f58
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x67a2
leaq 0xc100(%rip), %rsi      # 0x1509d
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x51d5
leaq 0xc2b6(%rip), %rsi      # 0x1526d
leaq -0xa8(%rbp), %rdi
callq 0x4760
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8fe4
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x8fef
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x4620
xorl %r12d, %r12d
movq 0x13fc9(%rip), %rsi     # 0x1cfe8
movq 0x13f92(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x904e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x904e
movq %rax, %r14
movb $0x1, %r12b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9075
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9075
movq %rax, %r14
movb $0x1, %r12b
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x9095
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9095
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0x90a7
movq %rbx, %rdi
callq 0x42e0
jmp 0x90a7
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90c0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setCgiExe(char const*)
void Location::setCgiExe(char const *c) 
{
	std::vector<std::string> cgiTmp;
	setStringArray(c, cgiTmp);
	if (cgiTmp.size() != 2)
		throw std::runtime_error("Wrong cgi input in the config file\n"); 
	_cgi_exe.insert(std::pair<std::string, std::string>(cgiTmp[0], cgiTmp[1]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0xa123
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jne 0x9168
leaq 0x20(%rsi), %rdx
leaq -0x70(%rbp), %rdi
callq 0x9832
addq $0x98, %rbx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x9c64
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x913d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9156
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x30(%rbp), %rdi
callq 0x6396
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %r14
leaq 0xc14f(%rip), %rsi      # 0x152cb
movq %rax, %rdi
callq 0x41b0
movq 0x13e5d(%rip), %rsi     # 0x1cfe8
movq 0x13e26(%rip), %rdx     # 0x1cfb8
movq %r14, %rdi
callq 0x46a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x42e0
jmp 0x91ba
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x98a0
jmp 0x91ba
jmp 0x91b7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x6396
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setAutoIndex(char const*)
void Location::setAutoIndex(char const *i)
{
	std::string tmp(i);
	tmp = *wsTrim(tmp);
	if (tmp.compare("on") && tmp.compare("off"))
		throw std::runtime_error("Error autoIndex : " + std::string(i) + "isn't a good input\n");
	else if (!tmp.compare("on"))
		_autoindex = 1;
	else
		_autoindex = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %rdx
movq %r15, %rdi
callq 0x518a
movq %r15, %rdi
callq 0xa0c9
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4240
leaq 0xc726(%rip), %rsi      # 0x15935
leaq -0x48(%rbp), %rdi
callq 0x4130
testl %eax, %eax
je 0x9230
leaq 0xc0cc(%rip), %rsi      # 0x152ef
leaq -0x48(%rbp), %rdi
callq 0x4130
testl %eax, %eax
jne 0x9271
leaq 0xc6fe(%rip), %rsi      # 0x15935
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x4130
testl %eax, %eax
sete 0x4(%rbx)
movq (%r14), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9261
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r14, %rsi
callq 0x518a
leaq 0xc05b(%rip), %rsi      # 0x152f3
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x51d5
leaq 0xc054(%rip), %rsi      # 0x15306
leaq -0xa8(%rbp), %rdi
callq 0x4760
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x92e0
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x92eb
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x4620
xorl %r15d, %r15d
movq 0x13ccd(%rip), %rsi     # 0x1cfe8
movq 0x13c96(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x934a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x934a
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9371
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9371
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9392
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9392
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x93a4
movq %rbx, %rdi
callq 0x42e0
jmp 0x93a4
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93bd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setRedirect(char const*)
void Location::setRedirect(char const *r) 
{
	std::vector<std::string> v;
	setStringArray(r, v);
	if (v.size() != 1)
		throw std::runtime_error("Error : " + std::string(r) + " - too many input for redirect\n");
	_redirect = v[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0xa123
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x942e
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x4240
leaq -0x40(%rbp), %rdi
callq 0x6396
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r14, %rsi
callq 0x518a
leaq 0xbc4b(%rip), %rsi      # 0x1509d
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x51d5
leaq 0xbe42(%rip), %rsi      # 0x152ab
leaq -0xa0(%rbp), %rdi
callq 0x4760
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x9497
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x94a2
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
movq 0x8(%rax), %rdx
leaq -0x60(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x4620
xorl %r15d, %r15d
movq 0x13b16(%rip), %rsi     # 0x1cfe8
movq 0x13adf(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x9501
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9501
movq %rax, %r14
movb $0x1, %r15b
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9528
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9528
movq %rax, %r14
movb $0x1, %r15b
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9549
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9549
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x955b
movq %rbx, %rdi
callq 0x42e0
jmp 0x955b
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6396
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: cleanLineFromSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int	cleanLineFromSpaces(std::string &buf)
{
	int i = 0;
	while (isspace(buf[i]))
		buf.erase(0, 1);

	if (buf.size()){
		i = buf.size() - 1;
		while (isspace(buf[i]))
			buf.erase(i, 1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movsbl (%rax), %edi
callq 0x4060
testl %eax, %eax
je 0x9ed1
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40d0
movq (%rbx), %rax
jmp 0x9eb1
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x9f02
decl %eax
movslq %eax, %r14
movq (%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x9f02
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40d0
jmp 0x9edf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: bracketRegulator(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int	bracketRegulator(int &bracket, std::string const &buf)
{
	size_t pos = -1; 
	while ( (pos = buf.find_first_of('{', pos + 1)) != std::string::npos) 
		bracket++;
	
	pos = -1;
	while ( (pos = buf.find_first_of('}', pos + 1)) != std::string::npos)
		bracket--;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x7b, %esi
xorl %edx, %edx
callq 0x4500
cmpq $-0x1, %rax
je 0x9f3e
incl (%r14)
incq %rax
movq %rbx, %rdi
movl $0x7b, %esi
movq %rax, %rdx
jmp 0x9f20
movq %rbx, %rdi
movl $0x7d, %esi
xorl %edx, %edx
callq 0x4500
cmpq $-0x1, %rax
je 0x9f66
decl (%r14)
incq %rax
movq %rbx, %rdi
movl $0x7d, %esi
movq %rax, %rdx
jmp 0x9f48
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: errParseMessage[abi:cxx11](char const*, char const*, char const*)
std::string const &errParseMessage(char const *begErrMsg, char const *errorToAdd, char const *endErrMsg)
{
	static std::string fullErrMsg;

	fullErrMsg.clear();
	fullErrMsg = begErrMsg;
	fullErrMsg += errorToAdd;
	fullErrMsg += endErrMsg;

	return fullErrMsg;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movb 0x134a3(%rip), %al      # 0x1d430
testb %al, %al
je 0x9ff7
movq $0x0, 0x1347c(%rip) # 0x1d418
leaq 0x1346d(%rip), %r15     # 0x1d410
movq 0x13466(%rip), %rax     # 0x1d410
movb $0x0, (%rax)
movq 0x13464(%rip), %r13     # 0x1d418
movq %r12, %rdi
callq 0x41e0
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x45d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4760
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4760
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4872
jmp 0x9f91
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: numberOfWords(char const*)
size_t numberOfWords(char const *buf)
{
	int word = 0, index = 0;
	while (buf[index] != '\0'){
		while (isspace(buf[index]))
			index++;
		int tmp = index;
		while (isalnum(buf[index]) || ispunct(buf[index]))
			index++;
		if (tmp !=  index)
			word++;
	}
	return word;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, (%rdi)
je 0xa0c8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movabsq $0x100000000, %r15      # imm = 0x100000000
xorl %r13d, %r13d
movq %rdi, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq %r13, %rcx
shlq $0x20, %rcx
movslq %r13d, %r13
decq %r13
movq %rcx, %rbx
movsbl 0x1(%r12,%r13), %edi
callq 0x4060
incq %r13
leaq (%rbx,%r15), %rcx
testl %eax, %eax
jne 0xa03f
xorl %r14d, %r14d
movsbl (%r12,%r13), %r15d
movl %r15d, %edi
callq 0x43f0
testl %eax, %eax
jne 0xa078
movl %r15d, %edi
callq 0x4770
testl %eax, %eax
je 0xa08d
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbx
decq %r14
incq %r12
jmp 0xa05b
cmpq $0x1, %r14
movq -0x38(%rbp), %rax
sbbl $-0x1, %eax
sarq $0x20, %rbx
subq %r14, %r13
movq -0x30(%rbp), %r12
cmpb $0x0, (%r12,%rbx)
movabsq $0x100000000, %r15      # imm = 0x100000000
jne 0xa02e
movl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: wsTrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string *wsTrim(std::string &buf)
{
    if (buf.empty())
        return &buf;
    for (std::string::iterator it = buf.end(); it != buf.begin(); --it)
        if (isspace(*it))
            buf.erase(it);            
    return &buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xa117
movq (%rbx), %r12
addq %r12, %r14
movq %r14, %r15
movsbl (%r15), %edi
callq 0x4060
testl %eax, %eax
je 0xa109
movq %r14, %rsi
subq %r12, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4480
decq %r15
movq (%rbx), %r12
decq %r14
cmpq %r12, %r15
jne 0xa0e9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: setStringArray(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void setStringArray(char const *n, std::vector<std::string> &v) 
{
    char *tmp = strdup(n);
    char *token = strtok(tmp, "\t\v\f\r ");

    while (token){
		
        v.push_back(token);
        token = strtok(NULL, "\t\v\f\r ");
    }
    free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
callq 0x4730
leaq 0xb27e(%rip), %rsi      # 0x153c1
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x45f0
testq %rax, %rax
je 0xa1b3
movq %rax, %r13
leaq -0x40(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq 0xb25b(%rip), %r12      # 0x153c1
movq %r14, -0x50(%rbp)
movq %r13, %rdi
callq 0x41e0
leaq (%rax,%r13), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x5790
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa1ec
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa1a1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
xorl %edi, %edi
movq %r12, %rsi
callq 0x45f0
movq %rax, %r13
testq %rax, %rax
jne 0xa166
movq -0x30(%rbp), %rdi
callq 0x44a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa1e3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/HttpServer.cpp
// Function: swap(HttpServer&, HttpServer&)
void swap(HttpServer& a, HttpServer& b)
{
	std::swap(a._serverSocks, b._serverSocks);
	std::swap(a._clientSocks, b._clientSocks);
	std::swap(a._readFds, b._readFds);
	std::swap(a._writeFds, b._writeFds);
	std::swap(a._nbReadyFds, b._nbReadyFds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4710
movq 0x10(%rbx), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x4710
movq 0x28(%rbx), %rax
movq 0x28(%r14), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %rax
leaq 0x30(%rbx), %rdx
leaq -0x90(%rbp), %r8
movl $0x10, %ecx
movq %r8, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x10, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x10, %ecx
movq %rdx, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xb0, %eax
leaq (%r14,%rax), %rdx
addq %rbx, %rax
movl $0x10, %ecx
movq %r8, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x10, %ecx
movq %rdx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x10, %ecx
movq %rax, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x130(%r14), %eax
movl 0x130(%rbx), %ecx
movl %ecx, 0x130(%r14)
movl %eax, 0x130(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/HttpServer.cpp
// Function: HttpServer::etablishConnection(std::map<int, std::vector<ServerInfo, std::allocator<ServerInfo>>, std::less<int>, std::allocator<std::pair<int const, std::vector<ServerInfo, std::allocator<ServerInfo>>>>>&)
void HttpServer::etablishConnection(std::map<int, std::vector<ServerInfo> >& mSrv)
{
	struct timeval tv;

	while (true)
	{
		tv.tv_sec = MAX_SEC_TIMEOUT;
		tv.tv_usec = MAX_USEC_TIMEOUT;

		// Setting readFd with all passive accept sockets and all clients previously connected
		FD_ZERO(&_readFds);
		FD_ZERO(&_writeFds);
		
		addSocketsToReadFdSet<ServerSocket>(_serverSocks);
		addSocketsToReadFdSet<ClientSocket>(_clientSocks);
		addSocketsToWriteFdSet<ClientSocket>(_clientSocks);

		// Waiting for incoming connections on server sockets / client sockets
		if ((_nbReadyFds = select(FD_SETSIZE, &_readFds, &_writeFds, NULL, &tv)) < 0)
			throw std::runtime_error("Fatal error: select function failed\n");
		else if (!_nbReadyFds)
			throw std::runtime_error("Webserv timeout\n");

		// Send responses to clients
		sendToClients();
		// If a passive socket was activated, creates a new client connection
		connectNewClients(mSrv);
		// Receive from client
		requestHandler();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdi), %r15
leaq 0xb0(%rdi), %r12
leaq 0x18(%rdi), %r13
movq $0x3e8, -0x38(%rbp)     # imm = 0x3E8
movq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r15)
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movups %xmm0, 0x70(%r12)
movups %xmm0, 0x60(%r12)
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x40(%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq %r14, %rdi
movq %r14, %rsi
callq 0xb764
movq %r14, %rdi
movq %r13, %rsi
callq 0xb7dc
movq %r14, %rdi
movq %r13, %rsi
callq 0xb854
movl $0x400, %edi            # imm = 0x400
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
leaq -0x38(%rbp), %r8
callq 0x43a0
movl %eax, 0x130(%r14)
testl %eax, %eax
js 0xa7d5
je 0xa7f3
movq %r14, %rdi
callq 0xa83a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaf9c
movq %r14, %rdi
callq 0xb2b4
jmp 0xa708
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq 0xabde(%rip), %rsi      # 0x153c7
movq %rax, %rdi
callq 0x41b0
jmp 0xa80f
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq 0xabe5(%rip), %rsi      # 0x153ec
movq %rax, %rdi
callq 0x41b0
movq 0x127d2(%rip), %rsi     # 0x1cfe8
movq 0x1279b(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
jmp 0xa827
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/ClientSocket.cpp
// Function: swap(ClientSocket&, ClientSocket&)
void swap(ClientSocket& a, ClientSocket& b)
{
	std::swap(a._fd, b._fd);
	std::swap(a._infoVirServs, b._infoVirServs);
	std::swap(a._request, b._request);
	std::swap(a._response, b._response);
	std::swap(a._bytesSent, b._bytesSent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl %eax, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
addq $0x10, %rdi
addq $0x10, %rsi
callq 0xc54b
movl $0xf0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0xc612
movq 0x170(%r14), %rax
movq 0x170(%rbx), %rcx
movq %rcx, 0x170(%r14)
movq %rax, 0x170(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: swap(Request&, Request&)
void swap(Request& a, Request& b)
{
	std::swap(a._buffer, b._buffer);
	std::swap(a._index, b._index);
	std::swap(a._infoVirServs, b._infoVirServs);
	
	swap(a._reqLine, b._reqLine);
	std::swap(a._headers, b._headers);
	swap(a._body, b._body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x42d0
movq 0x20(%r14), %rax
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%r14)
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x28(%rbx)
movl 0x30(%r14), %eax
movl 0x30(%rbx), %ecx
movl %ecx, 0x30(%r14)
movl %eax, 0x30(%rbx)
leaq 0x38(%r14), %rdi
leaq 0x38(%rbx), %rsi
callq 0x42d0
leaq 0x58(%r14), %rdi
leaq 0x58(%rbx), %rsi
callq 0x42d0
leaq 0x78(%r14), %rdi
leaq 0x78(%rbx), %rsi
callq 0xe4de
movb 0xa8(%r14), %al
movb 0xa8(%rbx), %cl
movb %cl, 0xa8(%r14)
movb %al, 0xa8(%rbx)
movq 0xb0(%r14), %rax
movq 0xb0(%rbx), %rcx
movq %rcx, 0xb0(%r14)
movq %rax, 0xb0(%rbx)
movq 0xb8(%r14), %rax
movq 0xb8(%rbx), %rcx
movq %rcx, 0xb8(%r14)
movq %rax, 0xb8(%rbx)
movl $0xc0, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x42d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::newLineReceived(unsigned long)
bool Request::newLineReceived(size_t posCLRF)
{
    // Protecting against too long fields
    if (_reqLine.getPath().empty() && _buffer.size() - _index > MAX_URI_LEN)
        throw StatusLine(414, REASON_414);
    else if (!_body.isReceiving() && _buffer.size() - _index > MAX_HEADER_LEN)
        throw StatusLine(431, REASON_431);

	else if (posCLRF == std::string::npos)
		return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x40(%rdi)
jne 0xce58
movq 0x8(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1f41, %rax           # imm = 0x1F41
jae 0xcee4
cmpb $0x0, 0xa8(%rdi)
jne 0xce71
movq 0x8(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1f41, %rax           # imm = 0x1F41
jae 0xce85
cmpq $-0x1, %rsi
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x885f(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5790
movb $0x1, %r15b
leaq 0x87f3(%rip), %rdx      # 0x156ab
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1af, %esi            # imm = 0x1AF
callq 0xe106
xorl %r15d, %r15d
leaq 0xfe9d(%rip), %rsi      # 0x1cd70
leaq 0x129a(%rip), %rdx      # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xcf41
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x8800(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5790
movb $0x1, %r15b
leaq 0x8787(%rip), %rdx      # 0x1569e
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x19e, %esi            # imm = 0x19E
callq 0xe106
xorl %r15d, %r15d
leaq 0xfe3e(%rip), %rsi      # 0x1cd70
leaq 0x123b(%rip), %rdx      # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xcf45
jmp 0xcf5f
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xcf65
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0xcf65
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xcf72
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::findMaxSize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
long Request::findMaxSize(const std::string& hostValue)
{
	const ServerInfo* servMatch = findVirtServ(_infoVirServs, hostValue);

	// Case no match with host header, using default virtual server
	if (!servMatch)
		servMatch = &_infoVirServs->front();

	return servMatch->getMaxClientsBS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x13c8a
testq %rax, %rax
jne 0xd3b4
movq 0x28(%rbx), %rax
movq (%rax), %rax
movq %rax, %rdi
callq 0x5b90
movslq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::parseBody()
void Request::parseBody()
{
	size_t lenToRead = _buffer.size() - _index;
	
	// Ignoring end of buffer if we received the amount of octets expected
	if (lenToRead > _body.getSize())
		_body.setSize(lenToRead);
	
	// Storing the part of body received until content-length octects are received
	if (_body.recvBuffer(_buffer, _index, lenToRead) == -1)
		throw StatusLine(413, REASON_413, "received more octets than max body size limit");
	_index += lenToRead;

	if (!_body.getSize())
		throw StatusLine(200, REASON_200);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x20(%rdi), %rdx
subq %rdx, %r14
addq $0xa8, %rdi
cmpq 0xb0(%rbx), %r14
jbe 0xd84e
movq %r14, 0xb0(%rbx)
movq %rbx, %rsi
movq %r14, %rcx
callq 0xe250
cmpl $-0x1, %eax
je 0xd879
addq %r14, 0x20(%rbx)
cmpq $0x0, 0xb0(%rbx)
je 0xd8dc
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x7dda(%rip), %rsi      # 0x15670
leaq 0x7e00(%rip), %rdx      # 0x1569d
leaq -0x40(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x7dae(%rip), %rdx      # 0x1565e
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x19d, %esi            # imm = 0x19D
callq 0xe106
xorl %r15d, %r15d
leaq 0xf4a5(%rip), %rsi      # 0x1cd70
leaq 0x8a2(%rip), %rdx       # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xd939
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x7e08(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5790
movb $0x1, %r15b
leaq 0x7d14(%rip), %rdx      # 0x15623
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0xc8, %esi
callq 0xe106
xorl %r15d, %r15d
leaq 0xf446(%rip), %rsi      # 0x1cd70
leaq 0x843(%rip), %rdx       # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xd93d
jmp 0xd957
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xd95d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0xd95d
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xd96a
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::clear()
void Request::clear()
{
	_index = 0;
	_buffer.clear();
	
	_reqLine.clear();
	_headers.clear();
	_body.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x20(%rdi)
movq %r14, 0x8(%rdi)
movq (%rdi), %rax
movb %r14b, (%rax)
movl $0xffffffff, 0x30(%rdi) # imm = 0xFFFFFFFF
movq %r14, 0x40(%rdi)
movq 0x38(%rdi), %rax
movb %r14b, (%rax)
movq %r14, 0x60(%rdi)
movq 0x58(%rdi), %rax
movb %r14b, (%rax)
addq $0x78, %rdi
callq 0xe32c
movb %r14b, 0xa8(%rbx)
movq %r14, 0xb0(%rbx)
movq %r14, 0xc8(%rbx)
movq 0xc0(%rbx), %rax
movb %r14b, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::print() const
void Request::print() const
{
	_reqLine.print();

	std::cout << "-------- HEADERS ---------\n";
	for (std::map<std::string, std::string>::const_iterator it = _headers.begin();
			it != _headers.end(); ++it)
		std::cout << it->first << ":" << it->second << "\n";
	
	std::cout << "---------- BODY ----------\n" << _body.getBody();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
callq 0xe1ba
movq 0xf5cf(%rip), %rdi      # 0x1cfc8
leaq 0x7c26(%rip), %rsi      # 0x15626
movl $0x1b, %edx
callq 0x4460
movq 0x90(%rbx), %r14
movq %rbx, -0x30(%rbp)
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0xda86
leaq 0x7f70(%rip), %r12      # 0x15998
leaq 0x7990(%rip), %r13      # 0x153bf
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq 0xf58a(%rip), %rdi      # 0x1cfc8
callq 0x4460
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4460
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rbx, %rdi
callq 0x4460
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x4460
movq %r14, %rdi
callq 0x4470
movq %rax, %r14
cmpq %r15, %rax
jne 0xda2f
movq 0xf53b(%rip), %r14      # 0x1cfc8
leaq 0x7bae(%rip), %rsi      # 0x15642
movl $0x1b, %edx
movq %r14, %rdi
callq 0x4460
movq -0x30(%rbp), %rax
movq 0xc0(%rax), %rsi
movq 0xc8(%rax), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4460
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::parseURI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Request::parseURI(std::string token)
{
	if (token[0] != '/')
		throw StatusLine(400, REASON_400, "URI must begin with a /");
	
    // URI is case insensitive, transforming it to lowercase
    std::transform(token.begin(), token.end(), token.begin(), asciiToLower);
    
	// Case there is a query in the URI
	size_t querryChar = token.find("?");
	if (querryChar != std::string::npos)
	{
		_reqLine.setPath(token.substr(0, querryChar));
		_reqLine.setQuery(token.substr(querryChar + 1, token.size()));
	}

	// Case there is only path in the URI
	else
		_reqLine.setPath(token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r15
cmpb $0x2f, (%r15)
jne 0xdbd1
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0xdb10
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
callq 0x13774
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %r12
jne 0xdafa
leaq 0x7ca1(%rip), %rsi      # 0x157b8
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x46c0
cmpq $-0x1, %rax
je 0xdbb4
movq %rax, %r15
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4410
leaq 0x38(%rbx), %rdi
movq %r12, %rsi
callq 0x4240
leaq -0x38(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xdb6c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
incq %r15
movq 0x8(%r14), %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4410
addq $0x58, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4240
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xdba5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x38, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4240
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x7bb2(%rip), %rsi      # 0x157a0
leaq 0x7bc2(%rip), %rdx      # 0x157b7
leaq -0x48(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x79e4(%rip), %rdx      # 0x155ec
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
movl $0x190, %esi            # imm = 0x190
callq 0xe106
xorl %r15d, %r15d
leaq 0xf14d(%rip), %rsi      # 0x1cd70
leaq 0x54a(%rip), %rdx       # 0xe174
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdc52
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0xdc52
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xdc8b
movq %rbx, %rdi
callq 0x42e0
jmp 0xdc8b
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0xdc7f
jmp 0xdc8b
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdc8b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Request.cpp
// Function: Request::parseHTTPVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Request::parseHTTPVersion(const std::string& token)
{
	if (token.size() < 7 || token.compare(0, 5, "HTTP/") || token.compare(6, 1, ".") || 
			!isdigit(static_cast<int>(token[5])) || !isdigit(static_cast<int>(token[7])))
		throw StatusLine(400, REASON_400, "HTTP version not correct");
			
	else if (token.compare("HTTP/1.1"))
		throw StatusLine(505, REASON_505);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x7, 0x8(%rsi)
jb 0xdf4f
movq %rsi, %rbx
leaq 0x78d6(%rip), %rcx      # 0x157ba
movl $0x5, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x4510
testl %eax, %eax
jne 0xdf4f
leaq 0x78c2(%rip), %rcx      # 0x157c0
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4510
testl %eax, %eax
jne 0xdf4f
movq (%rbx), %rax
movsbl 0x5(%rax), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0xdf4f
movsbl 0x7(%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0xdf4f
leaq 0x7c7a(%rip), %rsi      # 0x15bb0
movq %rbx, %rdi
callq 0x4130
testl %eax, %eax
jne 0xdfb2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x7856(%rip), %rsi      # 0x157c2
leaq 0x7867(%rip), %rdx      # 0x157da
leaq -0x40(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x7666(%rip), %rdx      # 0x155ec
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x190, %esi            # imm = 0x190
callq 0xe106
xorl %r15d, %r15d
leaq 0xedcf(%rip), %rsi      # 0x1cd70
leaq 0x1cc(%rip), %rdx       # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xe00f
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x7732(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5790
movb $0x1, %r15b
leaq 0x77f6(%rip), %rdx      # 0x157db
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1f9, %esi            # imm = 0x1F9
callq 0xe106
xorl %r15d, %r15d
leaq 0xed70(%rip), %rsi      # 0x1cd70
leaq 0x16d(%rip), %rdx       # 0xe174
movq %rbx, %rdi
callq 0x46a0
jmp 0xe013
jmp 0xe02d
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe033
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0xe033
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xe040
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: swap(Response&, Response&)
void swap(Response& a, Response& b)
{
	std::swap(a._infoVirServs, b._infoVirServs);
	std::swap(a._req, b._req);
	swap(a._staLine, b._staLine);
	std::swap(a._buffer, b._buffer);
    std::swap(a._autoIndex, b._autoIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movl 0x10(%rdi), %eax
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
movl %eax, 0x10(%rsi)
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x42d0
leaq 0x38(%r14), %rdi
leaq 0x38(%rbx), %rsi
callq 0x42d0
leaq 0x58(%r14), %rdi
leaq 0x58(%rbx), %rsi
callq 0x42d0
movb 0x78(%r14), %al
movb 0x78(%rbx), %cl
movb %cl, 0x78(%r14)
movb %al, 0x78(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::replaceLocInUri(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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&)
void Response::replaceLocInUri(std::string* uri, const std::string& root, const std::string& locName)
{
	// Creating an iterator pointing just after the part that matched the location
	std::string::iterator it = uri->begin() + locName.size();

	// Going to the next '/' (for example, case "/authentificate/ok" matched location "/auth" with a root of "/test"
	//						  >> we need to replace "/authentificate" with "/test" in order to get "/test/ok")
	if (*it != '/' && locName.size() > 1)
		while (*it && *it != '/')
			++it;
	
	// Replacing beginning of the URI with the root path
	uri->erase(uri->begin(), it);

	// To correctly append indexs if last '/' is missing
	if (root[root.size() - 1] != '/')
		uri->insert(uri->begin(), '/');
		
	uri->insert(0, root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rcx), %rcx
leaq (%rax,%rcx), %rdx
cmpq $0x2, %rcx
jb 0xf5e1
cmpb $0x2f, (%rax,%rcx)
je 0xf5e1
movzbl (%rdx), %ecx
testl %ecx, %ecx
je 0xf5e1
cmpl $0x2f, %ecx
je 0xf5e1
incq %rdx
jmp 0xf5d0
movq 0x8(%rbx), %rcx
addq %rax, %rcx
cmpq %rdx, %rcx
je 0xf5fc
subq %rax, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4480
jmp 0xf607
movq $0x0, 0x8(%rbx)
movb $0x0, (%rax)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0xf62c
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x4750
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x4440
nop
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::execPost(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Response::execPost(const std::string& realUri)
{
    // Need to create file so changing code 200 ("OK") to 201 ("created")
    struct stat infoFile;
    if (stat(realUri.c_str(), &infoFile) == -1)
        _staLine = StatusLine(201, REASON_201);
    
    // Creating a new file or appending to existing file post request payload. If 
    // opening failed, throws StatusLine object with error 500 (internal error)
    postToFile(realUri);
    
    // Storing status line and some headers in buffer
    fillStatusLine(_staLine);
    fillServerHeader();
    fillDateHeader();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq -0x118(%rbp), %rsi
callq 0x4360
cmpl $-0x1, %eax
jne 0xff0b
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x5867(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5790
leaq 0x5c76(%rip), %rdx      # 0x15b26
leaq -0x88(%rbp), %rdi
movl $0xc9, %esi
movq %r15, %rcx
callq 0xe106
movl 0x10(%rbx), %eax
leaq -0x80(%rbp), %rsi
movl -0x8(%rsi), %ecx
movl %ecx, 0x10(%rbx)
movl %eax, -0x8(%rsi)
leaq 0x18(%rbx), %rdi
callq 0x42d0
leaq 0x38(%rbx), %rdi
leaq -0x60(%rbp), %rsi
callq 0x42d0
leaq -0x88(%rbp), %rdi
callq 0xe174
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xff0b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x123b2
leaq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1004e
leaq 0x58(%rbx), %rdi
leaq 0x59c8(%rip), %rsi      # 0x158f5
callq 0x4760
movq %rbx, %rdi
callq 0x10374
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xff62
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::execDelete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Response::execDelete(const std::string& realUri)
{
    if (remove(realUri.c_str()))
        throw (StatusLine(500, REASON_500, "remove function failed in DELETE method"));

    // Storing status line and some headers in buffer
    fillStatusLine(_staLine);
    fillServerHeader();
    fillDateHeader();    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x4700
testl %eax, %eax
jne 0xffb8
leaq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1004e
leaq 0x58(%rbx), %rdi
leaq 0x5956(%rip), %rsi      # 0x158f5
callq 0x4760
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10374
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x5b59(%rip), %rsi      # 0x15b2e
leaq 0x5b79(%rip), %rdx      # 0x15b55
leaq -0x40(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x5afe(%rip), %rdx      # 0x15aed
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0xe106
xorl %r15d, %r15d
leaq 0xcd66(%rip), %rsi      # 0x1cd70
leaq -0x1e9d(%rip), %rdx     # 0xe174
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x10039
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x10039
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x10046
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: printLoc(Location const*)
void printLoc(const Location* loc)
{
	std::cout << "root: " << loc->getRoot() << "\n";
	for (std::vector<std::string>::const_iterator it = loc->getMethods().begin(); it != loc->getMethods().end(); it++)
		std::cout << "methods: " << *it << "\n";
		
	for (std::vector<std::string>::const_iterator it = loc->getIndex().begin(); it != loc->getIndex().end(); it++)
		std::cout << "index: " << *it << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb084(%rip), %r14      # 0x1cfc8
leaq 0x3a5c(%rip), %rsi      # 0x159a7
movl $0x6, %edx
movq %r14, %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x8c28
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x4460
leaq 0x3449(%rip), %rsi      # 0x153bf
movl $0x1, %edx
movq %rax, %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x8c3c
movq (%rax), %r13
movq %rbx, %rdi
callq 0x8c3c
cmpq 0x8(%rax), %r13
je 0x11ff3
movq 0xb025(%rip), %r14      # 0x1cfc8
leaq 0x3a04(%rip), %r15      # 0x159ae
leaq 0x340e(%rip), %r12      # 0x153bf
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4460
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x4460
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4460
addq $0x20, %r13
movq %rbx, %rdi
callq 0x8c3c
cmpq 0x8(%rax), %r13
jne 0x11fb1
movq %rbx, %rdi
callq 0x8c46
movq (%rax), %r13
movq %rbx, %rdi
callq 0x8c46
cmpq 0x8(%rax), %r13
je 0x12063
movq 0xafb5(%rip), %r14      # 0x1cfc8
leaq 0x399e(%rip), %r15      # 0x159b8
leaq 0x339e(%rip), %r12      # 0x153bf
movl $0x7, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4460
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x4460
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4460
addq $0x20, %r13
movq %rbx, %rdi
callq 0x8c46
cmpq 0x8(%rax), %r13
jne 0x12021
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::addIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::string Response::addIndex(const std::string& uri, const std::vector<std::string>& indexs)
{
	struct stat infFile;
	
	for (std::vector<std::string>::const_iterator it = indexs.begin(); it != indexs.end(); ++it)
	{
		// Add each index to the uri
		std::string uriWithIndex(uri + *it);

		// And then try to access the URI resulting from this concatenation
		if (!stat(uriWithIndex.c_str(), &infFile))
			return uriWithIndex;
	}
	
	throw StatusLine(403, REASON_403, "trying to access a directory addIndex method");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq (%rcx), %r12
cmpq 0x8(%rcx), %r12
je 0x120db
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x125bf
movq (%r14), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x4360
testl %eax, %eax
je 0x1213c
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x120d1
movq (%r13), %rsi
incq %rsi
callq 0x43e0
addq $0x20, %r12
cmpq 0x8(%rbx), %r12
jne 0x1209c
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x38d2(%rip), %rsi      # 0x159ca
leaq 0x38f7(%rip), %rdx      # 0x159f6
leaq -0x48(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x38ae(%rip), %rdx      # 0x159c0
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
movl $0x193, %esi            # imm = 0x193
callq 0xe106
xorl %r15d, %r15d
leaq 0xac43(%rip), %rsi      # 0x1cd70
leaq -0x3fc0(%rip), %rdx     # 0xe174
movq %rbx, %rdi
callq 0x46a0
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x12171
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x12171
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1217e
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O1/llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::postToFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Response::postToFile(const std::string& uri)
{
	std::fstream postFile;

	postFile.open(uri.c_str(), std::ios::app);

	if (!postFile.is_open())
		throw (StatusLine(500, REASON_500, "failed to open file in post method"));
	
	postFile << _req->getBody().getBody();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x250(%rbp), %r15
movq %r15, %rdi
callq 0x4490
movq (%r14), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x4370
leaq -0x1d0(%rbp), %rdi
callq 0x40e0
testb %al, %al
je 0x12432
movq 0x8(%rbx), %rdi
callq 0xca7a
leaq -0x240(%rbp), %rdi
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0x4460
leaq -0x250(%rbp), %rdi
callq 0x40c0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x36b4(%rip), %rsi      # 0x15b03
leaq 0x36cf(%rip), %rdx      # 0x15b25
leaq -0x40(%rbp), %rdi
callq 0x5790
movb $0x1, %r15b
leaq 0x3684(%rip), %rdx      # 0x15aed
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0xe106
xorl %r15d, %r15d
leaq 0xa8ec(%rip), %rsi      # 0x1cd70
leaq -0x4317(%rip), %rdx     # 0xe174
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x124b3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x124b3
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x124c5
movq %rbx, %rdi
callq 0x42e0
jmp 0x124c5
movq %rax, %r14
leaq -0x250(%rbp), %rdi
callq 0x40c0
movq %r14, %rdi
callq 0x46d0
nop