LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x97f0
movq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x12490
jmp 0x10180
leaq -0x28(%rbp), %rdi
callq 0xaa60
cmpq $0x2, %rax
je 0x10201
movl $0x10, %edi
callq 0x5290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0x13129(%rip), %rsi     # 0x232d6
callq 0x5210
jmp 0x101b4
movq -0xa0(%rbp), %rdi
movq 0x20e2e(%rip), %rsi     # 0x30ff0
movq 0x20dff(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0x102ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x102bc
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x53f0
jmp 0x102bc
movq -0x98(%rbp), %rax
addq $0x98, %rax
movq %rax, -0xb8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x10b10
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movl $0x1, %esi
callq 0x10b10
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
leaq -0x78(%rbp), %rdi
callq 0x10b70
jmp 0x10256
movq -0xb8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10b30
movb %dl, -0xc1(%rbp)
movq %rax, -0xc0(%rbp)
jmp 0x10275
movb -0xc1(%rbp), %al
movq -0xc0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x10bd0
leaq -0x28(%rbp), %rdi
callq 0x9950
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x10bd0
leaq -0x28(%rbp), %rdi
callq 0x9950
movq -0x30(%rbp), %rdi
callq 0x58e0
nop
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x58f0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0x10322
leaq -0x31(%rbp), %rdi
callq 0x55c0
leaq -0x30(%rbp), %rdi
callq 0x123e0
movq %rax, -0xd0(%rbp)
jmp 0x1033d
movq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5060
jmp 0x1034f
leaq -0x30(%rbp), %rdi
leaq 0x13596(%rip), %rsi     # 0x238f0
callq 0x51b0
cmpl $0x0, %eax
je 0x104e7
leaq -0x30(%rbp), %rdi
leaq 0x12f87(%rip), %rsi     # 0x232fa
callq 0x51b0
cmpl $0x0, %eax
je 0x104e7
movb $0x1, -0xaa(%rbp)
movl $0x10, %edi
callq 0x5290
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x58f0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x63e0
jmp 0x103d3
leaq 0x12f24(%rip), %rsi     # 0x232fe
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x6700
jmp 0x103ef
leaq 0x12f1b(%rip), %rdx     # 0x23311
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x66b0
jmp 0x10408
movq -0xe8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5830
jmp 0x1041a
movq -0xe8(%rbp), %rdi
movb $0x0, -0xaa(%rbp)
movq 0x20bc1(%rip), %rsi     # 0x30ff0
movq 0x20b92(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0x1053a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x55c0
jmp 0x10531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10528
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x104c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x104b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x104aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5a08
leaq -0x88(%rbp), %rdi
callq 0x5a08
leaq -0xa8(%rbp), %rdi
callq 0x5a08
leaq -0xa9(%rbp), %rdi
callq 0x55c0
testb $0x1, -0xaa(%rbp)
jne 0x104d9
jmp 0x104e5
movq -0xe8(%rbp), %rdi
callq 0x53f0
jmp 0x10528
leaq -0x30(%rbp), %rdi
leaq 0x133fe(%rip), %rsi     # 0x238f0
callq 0x51b0
cmpl $0x0, %eax
jne 0x10509
movq -0xc8(%rbp), %rax
movb $0x1, 0x4(%rax)
jmp 0x10514
movq -0xc8(%rbp), %rax
movb $0x0, 0x4(%rax)
jmp 0x10516
leaq -0x30(%rbp), %rdi
callq 0x5a08
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5a08
movq -0x40(%rbp), %rdi
callq 0x58e0
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x97f0
movq -0xa8(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x12490
jmp 0x10580
leaq -0x28(%rbp), %rdi
callq 0xaa60
cmpq $0x1, %rax
je 0x106d6
movb $0x1, -0x9a(%rbp)
movl $0x10, %edi
callq 0x5290
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x58f0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x63e0
jmp 0x105e5
leaq 0x12a95(%rip), %rsi     # 0x23081
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x6700
jmp 0x105fe
leaq 0x12cb1(%rip), %rdx     # 0x232b6
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x66b0
jmp 0x10614
movq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5830
jmp 0x10626
movq -0xc8(%rbp), %rdi
movb $0x0, -0x9a(%rbp)
movq 0x209b5(%rip), %rsi     # 0x30ff0
movq 0x20986(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0x1071c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1070a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x106b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x106a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1069c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5a08
leaq -0x78(%rbp), %rdi
callq 0x5a08
leaq -0x98(%rbp), %rdi
callq 0x5a08
leaq -0x99(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x9a(%rbp)
jne 0x106c8
jmp 0x106d4
movq -0xc8(%rbp), %rdi
callq 0x53f0
jmp 0x1070a
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x10b10
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x48, %rdi
callq 0x5060
jmp 0x106f8
leaq -0x28(%rbp), %rdi
callq 0x9950
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x9950
movq -0x30(%rbp), %rdi
callq 0x58e0
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x59f0
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x12171
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x5130
jmp 0x12143
movq -0x8(%rbp), %rdi
callq 0x53b0
cmpq $0x0, %rax
je 0x121c0
movq -0x8(%rbp), %rdi
callq 0x53b0
subq $0x1, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x59f0
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x121be
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movl $0x1, %edx
callq 0x5130
jmp 0x12190
jmp 0x121c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $-0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movl $0x7b, %esi
callq 0x5350
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x12215
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x121e8
movq $-0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movl $0x7d, %esi
callq 0x5350
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x1224a
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x1221d
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpb $0x0, 0x1f2e5(%rip)     # 0x31560
jne 0x122c0
leaq 0x1f2dc(%rip), %rdi     # 0x31560
callq 0x5950
cmpl $0x0, %eax
je 0x122c0
leaq 0x1f2ab(%rip), %rdi     # 0x31540
callq 0x5770
movq 0x1ed17(%rip), %rdi     # 0x30fb8
leaq 0x1f298(%rip), %rsi     # 0x31540
leaq 0x1f259(%rip), %rdx     # 0x31508
callq 0x5490
leaq 0x1f2a5(%rip), %rdi     # 0x31560
callq 0x5380
leaq 0x1f279(%rip), %rdi     # 0x31540
callq 0x5700
movq -0x8(%rbp), %rsi
leaq 0x1f269(%rip), %rdi     # 0x31540
callq 0x5730
movq -0x10(%rbp), %rsi
leaq 0x1f259(%rip), %rdi     # 0x31540
callq 0x5520
movq -0x18(%rbp), %rsi
leaq 0x1f249(%rip), %rdi     # 0x31540
callq 0x5520
leaq 0x1f23d(%rip), %rax     # 0x31540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x123c9
jmp 0x12341
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x12362
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12341
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5580
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x1239f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x59a0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x123a8
jmp 0x123b3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12368
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x123c4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1232a
movslq -0xc(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5870
testb $0x1, %al
jne 0x123fb
jmp 0x12405
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12483
movq -0x10(%rbp), %rdi
callq 0x5320
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5480
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12580
testb $0x1, %al
jne 0x12432
jmp 0x1247b
leaq -0x18(%rbp), %rdi
callq 0x125c0
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x1246e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x125e0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5680
movq %rax, -0x30(%rbp)
jmp 0x12470
leaq -0x18(%rbp), %rdi
callq 0x12620
jmp 0x12412
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5960
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x10f14(%rip), %rsi     # 0x233cc
callq 0x5800
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12561
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x58f0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x63e0
jmp 0x124fc
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x12640
jmp 0x1250b
leaq -0x40(%rbp), %rdi
callq 0x5a08
leaq -0x41(%rbp), %rdi
callq 0x55c0
xorl %eax, %eax
movl %eax, %edi
leaq 0x10ea4(%rip), %rsi     # 0x233cc
callq 0x5800
movq %rax, -0x20(%rbp)
jmp 0x124c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a08
leaq -0x41(%rbp), %rdi
callq 0x55c0
jmp 0x12570
movq -0x18(%rbp), %rdi
callq 0x5640
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x58e0
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14970
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x149a0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x149d0
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
addq $0xb0, %rsi
callq 0x149d0
movq -0x8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq -0x10(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x14a30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14a30
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x16e10
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x16e50
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movq -0x10(%rbp), %rsi
addq $0xf0, %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0x17070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19f30
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x17070
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x16e10
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x19f60
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x19fb0
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
addq $0xa8, %rsi
callq 0x19fe0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x30, %rdi
callq 0x19890
movq %rax, %rdi
callq 0x5870
testb $0x1, %al
jne 0x17c15
jmp 0x17cf6
movq -0x80(%rbp), %rdi
callq 0x53b0
movq -0x80(%rbp), %rcx
subq 0x20(%rcx), %rax
cmpq $0x1f40, %rax           # imm = 0x1F40
jbe 0x17cf6
movb $0x1, -0x4d(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x58f0
movq -0x88(%rbp), %rdx
leaq 0xbaa7(%rip), %rsi      # 0x2370c
leaq -0x38(%rbp), %rdi
callq 0x63e0
jmp 0x17c70
movq -0x90(%rbp), %rdi
leaq 0xba2b(%rip), %rdx      # 0x236a9
movl $0x19e, %esi            # imm = 0x19E
leaq -0x38(%rbp), %rcx
callq 0x199d0
jmp 0x17c8e
movq -0x90(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x190f0(%rip), %rsi     # 0x30d90
leaq 0x1dd9(%rip), %rdx      # 0x19a80
callq 0x58a0
jmp 0x17e15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17cd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5a08
leaq -0x39(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x4d(%rbp)
jne 0x17ce5
jmp 0x17cf1
movq -0x90(%rbp), %rdi
callq 0x53f0
jmp 0x17e0c
movq -0x80(%rbp), %rdi
addq $0xa8, %rdi
callq 0x19900
testb $0x1, %al
jne 0x17de9
movq -0x80(%rbp), %rdi
callq 0x53b0
movq -0x80(%rbp), %rcx
subq 0x20(%rcx), %rax
cmpq $0x1f40, %rax           # imm = 0x1F40
jbe 0x17de9
movb $0x1, -0x72(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0xa0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x58f0
movq -0x98(%rbp), %rdx
leaq 0xb9ae(%rip), %rsi      # 0x2370c
leaq -0x70(%rbp), %rdi
callq 0x63e0
jmp 0x17d69
movq -0xa0(%rbp), %rdi
leaq 0xb93f(%rip), %rdx      # 0x236b6
movl $0x1af, %esi            # imm = 0x1AF
leaq -0x70(%rbp), %rcx
callq 0x199d0
jmp 0x17d87
movq -0xa0(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x18ff7(%rip), %rsi     # 0x30d90
leaq 0x1ce0(%rip), %rdx      # 0x19a80
callq 0x58a0
jmp 0x17e15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17dca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5a08
leaq -0x71(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x72(%rbp)
jne 0x17ddb
jmp 0x17de7
movq -0xa0(%rbp), %rdi
callq 0x53f0
jmp 0x17e0c
cmpq $-0x1, -0x18(%rbp)
jne 0x17df6
movb $0x0, -0x1(%rbp)
jmp 0x17dfe
jmp 0x17df8
jmp 0x17dfa
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x58e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x21300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x183f1
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x19f00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8d10
movslq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x53b0
movq -0x80(%rbp), %rdi
subq 0x20(%rdi), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0xa8, %rdi
callq 0x19cb0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jbe 0x189cc
movq -0x80(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
callq 0x19b00
movq -0x80(%rbp), %rsi
movq %rsi, %rdi
addq $0xa8, %rdi
movq 0x20(%rsi), %rdx
movq -0x10(%rbp), %rcx
callq 0x19cd0
cmpl $-0x1, %eax
jne 0x18ab4
movb $0x1, -0x45(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x90(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x58f0
movq -0x88(%rbp), %rdx
leaq 0xac58(%rip), %rsi      # 0x2367b
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0x18a2e
movq -0x90(%rbp), %rdi
leaq 0xac2d(%rip), %rdx      # 0x23669
movl $0x19d, %esi            # imm = 0x19D
leaq -0x30(%rbp), %rcx
callq 0x199d0
jmp 0x18a4c
movq -0x90(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x18332(%rip), %rsi     # 0x30d90
leaq 0x101b(%rip), %rdx      # 0x19a80
callq 0x58a0
jmp 0x18baa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x18a92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5a08
leaq -0x31(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x45(%rbp)
jne 0x18aa3
jmp 0x18aaf
movq -0x90(%rbp), %rdi
callq 0x53f0
jmp 0x18ba1
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
addq 0x20(%rdi), %rax
movq %rax, 0x20(%rdi)
addq $0xa8, %rdi
callq 0x19cb0
cmpq $0x0, %rax
jne 0x18b98
movb $0x1, -0x6a(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0xa0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x58f0
movq -0x98(%rbp), %rdx
leaq 0xabff(%rip), %rsi      # 0x2370c
leaq -0x68(%rbp), %rdi
callq 0x63e0
jmp 0x18b18
movq -0xa0(%rbp), %rdi
leaq 0xab08(%rip), %rdx      # 0x2362e
movl $0xc8, %esi
leaq -0x68(%rbp), %rcx
callq 0x199d0
jmp 0x18b36
movq -0xa0(%rbp), %rdi
movb $0x0, -0x6a(%rbp)
leaq 0x18248(%rip), %rsi     # 0x30d90
leaq 0xf31(%rip), %rdx       # 0x19a80
callq 0x58a0
jmp 0x18baa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x18b79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5a08
leaq -0x69(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x6a(%rbp)
jne 0x18b8a
jmp 0x18b96
movq -0xa0(%rbp), %rdi
callq 0x53f0
jmp 0x18ba1
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58e0
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x20(%rdi)
callq 0x5700
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x19b40
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x19b80
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0x19ba0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0x19bd0
movq 0x1839c(%rip), %rdi     # 0x30fd0
leaq 0xa9f6(%rip), %rsi      # 0x23631
callq 0x5540
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x10c20
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x10c80
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10c50
testb $0x1, %al
jne 0x18c75
jmp 0x18cd6
leaq -0x10(%rbp), %rdi
callq 0x10cb0
movq %rax, %rsi
movq 0x18348(%rip), %rdi     # 0x30fd0
callq 0x54a0
movq %rax, %rdi
leaq 0xacbc(%rip), %rsi      # 0x23953
callq 0x5540
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x10cb0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x54a0
movq %rax, %rdi
leaq 0xa707(%rip), %rsi      # 0x233ca
callq 0x5540
leaq -0x10(%rbp), %rdi
callq 0x19c60
jmp 0x18c51
movq 0x182f3(%rip), %rdi     # 0x30fd0
leaq 0xa969(%rip), %rsi      # 0x2364d
callq 0x5540
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0xa8, %rdi
callq 0x19c90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x54a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x53b0
cmpq $0x7, %rax
jb 0x19549
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x5, %edx
leaq 0xa2da(%rip), %rcx      # 0x237c0
callq 0x5710
cmpl $0x0, %eax
jne 0x19549
movq -0x10(%rbp), %rdi
movl $0x6, %esi
movl $0x1, %edx
leaq 0xa2c1(%rip), %rcx      # 0x237c6
callq 0x5710
cmpl $0x0, %eax
jne 0x19549
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x55e0
movsbl (%rax), %edi
callq 0x54b0
cmpl $0x0, %eax
je 0x19549
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x55e0
movsbl (%rax), %edi
callq 0x54b0
cmpl $0x0, %eax
jne 0x195fb
movb $0x1, -0x45(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x58f0
movq -0x78(%rbp), %rdx
leaq 0xa255(%rip), %rsi      # 0x237c8
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0x1957e
movq -0x80(%rbp), %rdi
leaq 0xa06e(%rip), %rdx      # 0x235f7
movl $0x190, %esi            # imm = 0x190
leaq -0x30(%rbp), %rcx
callq 0x199d0
jmp 0x19599
movq -0x80(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x177e8(%rip), %rsi     # 0x30d90
leaq 0x4d1(%rip), %rdx       # 0x19a80
callq 0x58a0
jmp 0x196e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x195dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5a08
leaq -0x31(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x45(%rbp)
jne 0x195ed
jmp 0x195f6
movq -0x80(%rbp), %rdi
callq 0x53f0
jmp 0x196dd
movq -0x10(%rbp), %rdi
leaq 0xa57c(%rip), %rsi      # 0x23b82
callq 0x51b0
cmpl $0x0, %eax
je 0x196d2
movb $0x1, -0x6a(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x90(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x58f0
movq -0x88(%rbp), %rdx
leaq 0xa0c5(%rip), %rsi      # 0x2370c
leaq -0x68(%rbp), %rdi
callq 0x63e0
jmp 0x19652
movq -0x90(%rbp), %rdi
leaq 0xa181(%rip), %rdx      # 0x237e1
movl $0x1f9, %esi            # imm = 0x1F9
leaq -0x68(%rbp), %rcx
callq 0x199d0
jmp 0x19670
movq -0x90(%rbp), %rdi
movb $0x0, -0x6a(%rbp)
leaq 0x1770e(%rip), %rsi     # 0x30d90
leaq 0x3f7(%rip), %rdx       # 0x19a80
callq 0x58a0
jmp 0x196e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x196b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5a08
leaq -0x69(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x6a(%rbp)
jne 0x196c4
jmp 0x196d0
movq -0x90(%rbp), %rdi
callq 0x53f0
jmp 0x196dd
jmp 0x196d4
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58e0
nopw %cs:(%rax,%rax)
// File: llefranc[P]42_webserv/srcs/server/./msg_format/Body.hpp
// Function: Body::recvBuffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)
int recvBuffer(const std::string& buffer, size_t index, size_t lenToRead)
		{
			// maxSize will be evaluated only if previously set using setMaxSize before, because 
			// default constructor initilized it to -1
			if (_maxSize >= 0 && (_maxSize -= lenToRead) < 0)
				return -1;

			_buff.append(buffer, index, _size);
			_size -= lenToRead;
			return 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
jl 0x19d19
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq 0x10(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jge 0x19d19
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19d4f
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x8(%rax), %rcx
callq 0x5760
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: llefranc[P]42_webserv/srcs/server/./msg_format/Body.hpp
// Function: swap(Body&, Body&)
void swap(Body& a, Body& b)
		{
			std::swap(a._recv, b._recv);
			std::swap(a._size, b._size);
			std::swap(a._maxSize, b._maxSize);
			std::swap(a._buff, b._buff);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a050
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x17070
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1a090
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x19f30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16e10
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1f270
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1f2b0
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
callq 0x19f30
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x1a050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5480
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x53b0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1f190
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x125c0
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x1bc74
movq -0x20(%rbp), %rdi
callq 0x53b0
cmpq $0x1, %rax
jbe 0x1bc74
jmp 0x1bc33
leaq -0x28(%rbp), %rdi
callq 0x125c0
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x69(%rbp)
je 0x1bc5e
leaq -0x28(%rbp), %rdi
callq 0x125c0
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x1bc67
jmp 0x1bc72
leaq -0x28(%rbp), %rdi
callq 0x1a290
jmp 0x1bc33
jmp 0x1bc74
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5480
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x125e0
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x125e0
movq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x5110
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x53b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x55e0
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x1bd1f
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5480
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x125e0
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl $0x2f, %edx
callq 0x5980
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x5820
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5240
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x54c0
cmpl $-0x1, %eax
jne 0x1ca2e
leaq -0x109(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x58f0
movq -0x130(%rbp), %rdx
leaq 0x6dac(%rip), %rsi      # 0x2370c
leaq -0x108(%rbp), %rdi
callq 0x63e0
jmp 0x1c96e
leaq 0x716c(%rip), %rdx      # 0x23ae1
leaq -0xe8(%rbp), %rdi
movl $0xc9, %esi
leaq -0x108(%rbp), %rcx
callq 0x199d0
jmp 0x1c98f
movq -0x128(%rbp), %rdi
addq $0x10, %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1efe0
jmp 0x1c9a8
leaq -0xe8(%rbp), %rdi
callq 0x19a80
leaq -0x108(%rbp), %rdi
callq 0x5a08
leaq -0x109(%rbp), %rdi
callq 0x55c0
jmp 0x1ca2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x1ca20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x1ca14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x19a80
leaq -0x108(%rbp), %rdi
callq 0x5a08
leaq -0x109(%rbp), %rdi
callq 0x55c0
jmp 0x1ca72
movq -0x128(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ed40
movq -0x128(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
callq 0x1cb90
movq -0x128(%rbp), %rdi
callq 0x1cdc0
movq -0x128(%rbp), %rdi
callq 0x1cdf0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x58e0
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5920
cmpl $0x0, %eax
je 0x1cb5e
movb $0x1, -0x45(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x58f0
movq -0x58(%rbp), %rdx
leaq 0x700d(%rip), %rsi      # 0x23ae9
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0x1cae7
movq -0x60(%rbp), %rdi
leaq 0x6fb6(%rip), %rdx      # 0x23aa8
movl $0x1f4, %esi            # imm = 0x1F4
leaq -0x30(%rbp), %rcx
callq 0x199d0
jmp 0x1cb02
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1427f(%rip), %rsi     # 0x30d90
leaq -0x3098(%rip), %rdx     # 0x19a80
callq 0x58a0
jmp 0x1cb8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1cb42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5a08
leaq -0x31(%rbp), %rdi
callq 0x55c0
testb $0x1, -0x45(%rbp)
jne 0x1cb53
jmp 0x1cb5c
movq -0x60(%rbp), %rdi
callq 0x53f0
jmp 0x1cb86
movq -0x50(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
callq 0x1cb90
movq -0x50(%rbp), %rdi
callq 0x1cdc0
movq -0x50(%rbp), %rdi
callq 0x1cdf0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58e0
nop
// File: llefranc[P]42_webserv/srcs/server/Response.cpp
// Function: Response::fillStatusLine(StatusLine const&)
void Response::fillStatusLine(const StatusLine& staLine)
{
	_buffer = "HTTP/1.1 " + convertNbToString(staLine.getCode()) + " " + staLine.getReason();
	if (!staLine.getAdditionalInfo().empty())
		_buffer += " (" + staLine.getAdditionalInfo() + ")";
	_buffer += CLRF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f010
movslq %eax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x20c10
movq -0xe8(%rbp), %rdx
leaq 0x6d7a(%rip), %rsi      # 0x23955
leaq -0x70(%rbp), %rdi
callq 0x6700
jmp 0x1cbe6
leaq 0x6afb(%rip), %rdx      # 0x236e8
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x66b0
jmp 0x1cbfc
movq -0x10(%rbp), %rdi
callq 0x1f110
movq %rax, -0xf8(%rbp)
jmp 0x1cc0e
movq -0xf8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x16dc0
jmp 0x1cc24
movq -0xf0(%rbp), %rdi
addq $0x58, %rdi
leaq -0x30(%rbp), %rsi
callq 0x5670
leaq -0x30(%rbp), %rdi
callq 0x5a08
leaq -0x50(%rbp), %rdi
callq 0x5a08
leaq -0x70(%rbp), %rdi
callq 0x5a08
leaq -0x90(%rbp), %rdi
callq 0x5a08
movq -0x10(%rbp), %rdi
callq 0x1f130
movq %rax, %rdi
callq 0x5870
testb $0x1, %al
jne 0x1cd8a
movq -0x10(%rbp), %rdi
callq 0x1f130
movq %rax, %rdx
leaq 0x6cd4(%rip), %rsi      # 0x2395f
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x9a60
movq -0x100(%rbp), %rsi
leaq 0x658e(%rip), %rdx      # 0x2323a
leaq -0xc0(%rbp), %rdi
callq 0x66b0
jmp 0x1ccba
movq -0xf0(%rbp), %rdi
addq $0x58, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x56b0
jmp 0x1ccd3
leaq -0xc0(%rbp), %rdi
callq 0x5a08
leaq -0xe0(%rbp), %rdi
callq 0x5a08
jmp 0x1cd8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x1cd3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x1cd33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5a08
leaq -0x70(%rbp), %rdi
callq 0x5a08
leaq -0x90(%rbp), %rdi
callq 0x5a08
jmp 0x1cdaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x1cd7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x5a08
leaq -0xe0(%rbp), %rdi
callq 0x5a08
jmp 0x1cdaa
movq -0xf0(%rbp), %rdi
addq $0x58, %rdi
leaq 0x6ed9(%rip), %rsi      # 0x23c75
callq 0x5520
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x58e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x12a5d(%rip), %rdi     # 0x30fd0
leaq 0x53e8(%rip), %rsi      # 0x23962
callq 0x5540
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf890
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x54a0
movq %rax, %rdi
leaq 0x4e28(%rip), %rsi      # 0x233ca
callq 0x5540
movq -0x8(%rbp), %rdi
callq 0xf8d0
movq %rax, %rdi
callq 0xab80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf8d0
movq %rax, %rdi
callq 0xabb0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xaee0
testb $0x1, %al
jne 0x1e5e4
jmp 0x1e630
movq 0x129e5(%rip), %rdi     # 0x30fd0
leaq 0x5377(%rip), %rsi      # 0x23969
callq 0x5540
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xaf50
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x54a0
movq %rax, %rdi
leaq 0x4db0(%rip), %rsi      # 0x233ca
callq 0x5540
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1f150
movq %rax, -0x20(%rbp)
jmp 0x1e5bc
movq -0x8(%rbp), %rdi
callq 0xf8f0
movq %rax, %rdi
callq 0xab80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf8f0
movq %rax, %rdi
callq 0xabb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaee0
testb $0x1, %al
jne 0x1e66d
jmp 0x1e6b9
movq 0x1295c(%rip), %rdi     # 0x30fd0
leaq 0x52f8(%rip), %rsi      # 0x23973
callq 0x5540
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaf50
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x54a0
movq %rax, %rdi
leaq 0x4d27(%rip), %rsi      # 0x233ca
callq 0x5540
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1f150
movq %rax, -0x38(%rbp)
jmp 0x1e645
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xab80
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rdi
callq 0xabb0
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xaee0
testb $0x1, %al
jne 0x1e728
jmp 0x1e7d2
movb $0x0, -0xc1(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xaf50
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdi
movq %rax, %rdx
callq 0x1f1d0
movq -0x110(%rbp), %rdi
callq 0x5240
movq %rax, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x54c0
cmpl $0x0, %eax
jne 0x1e78f
movb $0x1, -0xc1(%rbp)
movl $0x1, -0xc8(%rbp)
jmp 0x1e799
movl $0x0, -0xc8(%rbp)
testb $0x1, -0xc1(%rbp)
jne 0x1e7ae
movq -0x110(%rbp), %rdi
callq 0x5a08
movl -0xc8(%rbp), %eax
testl %eax, %eax
je 0x1e7bf
jmp 0x1e7ba
jmp 0x1e8b4
jmp 0x1e7c1
leaq -0xb8(%rbp), %rdi
callq 0xaf70
jmp 0x1e6fc
movb $0x1, -0xfd(%rbp)
movl $0x48, %edi
callq 0x5290
movq %rax, -0x128(%rbp)
leaq -0xe9(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x58f0
movq -0x120(%rbp), %rdx
leaq 0x517a(%rip), %rsi      # 0x23985
leaq -0xe8(%rbp), %rdi
callq 0x63e0
jmp 0x1e819
movq -0x128(%rbp), %rdi
leaq 0x5154(%rip), %rdx      # 0x2397b
movl $0x193, %esi            # imm = 0x193
leaq -0xe8(%rbp), %rcx
callq 0x199d0
jmp 0x1e83a
movq -0x128(%rbp), %rdi
movb $0x0, -0xfd(%rbp)
leaq 0x12541(%rip), %rsi     # 0x30d90
leaq -0x4dd6(%rip), %rdx     # 0x19a80
callq 0x58a0
jmp 0x1e8d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1e88f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x5a08
leaq -0xe9(%rbp), %rdi
callq 0x55c0
testb $0x1, -0xfd(%rbp)
jne 0x1e8a6
jmp 0x1e8b2
movq -0x128(%rbp), %rdi
callq 0x53f0
jmp 0x1e8c4
movq -0x108(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x58e0