LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/./socket.h
// Function: CSocket::SendLarge(unsigned char const*, unsigned long)
void SendLarge(const uint8_t* pBuf, uint64_t len) {
    int nBatches = (len + BLK_SIZE - 1) / BLK_SIZE;
    for (int i = 0; i < nBatches; i++) {
      int batchSize = BLK_SIZE;
      if (i == nBatches - 1) {
        batchSize = len % BLK_SIZE;
        if (batchSize == 0) {
          batchSize = BLK_SIZE;
        }
      }
      Send(pBuf + i * BLK_SIZE, batchSize);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7ffffffe(%rdx), %r14
movabsq $0x200000005, %rcx      # imm = 0x200000005
movq %rdx, %rax
movq %r14, %rdx
mulxq %rcx, %rdx, %rdx
subq %rdx, %r14
shrq %r14
addq %rdx, %r14
shrq $0x1e, %r14
testl %r14d, %r14d
jle 0x560c
movq %rax, %rdx
mulxq %rcx, %rcx, %rcx
movq %rax, %r13
leal -0x1(%r14), %r12d
movq %rsi, %rbx
movq %rdi, %r15
subq %rcx, %r13
shrq %r13
addq %rcx, %r13
shrq $0x1e, %r13
movq %r13, %rcx
shlq $0x1f, %rcx
subq %rcx, %r13
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rax, %r13
cmovel %ecx, %r13d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
cmpq %rbp, %r12
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq %r15, %rdi
movq %rbx, %rsi
cmovel %r13d, %edx
xorl %ecx, %ecx
callq 0x57a8
incq %rbp
addq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
cmpq %rbp, %r14
jne 0x55e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/./socket.h
// Function: CSocket::Receive(void*, int, int)
int Receive(void* pBuf, int nLen, int nFlags = 0) {
    struct timespec start, stop;
    clock_gettime( CLOCK_REALTIME, &start);

    bytesReceived += nLen;

    char* p = (char*) pBuf;
    int n = nLen;
    int ret = 0;
    while (n > 0) {
      ret = recv(m_hSock, p, n, 0);
      if (ret < 0) {
        if (errno == EAGAIN) {
          cout << "socket recv eror: EAGAIN" << endl;
          usleep(200);
          continue;
        } else {
          cout << "socket recv error: " << errno << endl;
          
          clock_gettime( CLOCK_REALTIME, &stop);
          networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
          return ret;
        }
      } else if (ret == 0) {
        clock_gettime( CLOCK_REALTIME, &stop);
        networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
        return ret;
      }
      p += ret;
      n -= ret;
    }
    clock_gettime( CLOCK_REALTIME, &stop);
    networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
    return nLen;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %rdi, %rbx
xorl %edi, %edi
movl %edx, %r12d
callq 0x21f0
movslq %r12d, %rax
addq %rax, 0x10(%rbx)
testl %eax, %eax
jle 0x576a
movq 0x3983(%rip), %r15      # 0x8fd8
movl %r12d, %r13d
movl %r12d, 0x4(%rsp)
movl (%rbx), %edi
movl %r13d, %r13d
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x20d0
movq %rax, %rbp
testl %ebp, %ebp
jns 0x56e5
callq 0x2050
movq %rax, %r12
cmpl $0xb, (%r12)
jne 0x56ff
movl $0x18, %edx
leaq 0xf02(%rip), %rsi       # 0x6593
movq %r15, %rdi
callq 0x22c0
movq (%r15), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2230
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movl $0xc8, %edi
callq 0x2330
movl (%rbx), %edi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x20d0
movq %rax, %rbp
testl %ebp, %ebp
js 0x567e
movl 0x4(%rsp), %r12d
movq %rbp, %rax
testl %ebp, %ebp
je 0x5767
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r14
subl %ebp, %r13d
jg 0x565d
jmp 0x576a
movq 0x38d2(%rip), %r14      # 0x8fd8
leaq 0xe9f(%rip), %rsi       # 0x65ac
movl $0x13, %edx
movq %r14, %rdi
callq 0x22c0
movl (%r12), %esi
movq %r14, %rdi
callq 0x23e0
movq %rax, %r14
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0x2230
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x21f0
movq (%r14), %rax
movl %ebp, %r12d
jmp 0x577c
xorl %r12d, %r12d
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x21f0
movq (%r14), %rax
subq 0x8(%rsp), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
addq 0x20(%rsp), %rax
subq 0x10(%rsp), %rax
addq %rax, 0x18(%rbx)
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/./socket.h
// Function: CSocket::Send(void const*, int, int)
int Send(const void* pBuf, int nLen, int nFlags = 0) {
    struct timespec start, stop;
    
    clock_gettime( CLOCK_REALTIME, &start);

    bytesSent += nLen;
    int ret = send(m_hSock, (char*)pBuf, nLen, nFlags);

    clock_gettime( CLOCK_REALTIME, &stop);
    networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;

    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %r12
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %ebp
movl %edx, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x21f0
movslq %r14d, %rdx
movq %r15, %rsi
movl %ebp, %ecx
addq %rdx, 0x8(%rbx)
movl (%rbx), %edi
callq 0x2130
movq %rsp, %r15
movq %rax, %r14
xorl %edi, %edi
movq %r15, %rsi
callq 0x21f0
movq (%r15), %rax
subq (%r12), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
addq 0x8(%r15), %rax
subq 0x8(%r12), %rax
addq %rax, 0x18(%rbx)
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/util.cpp
// Function: AESContext::FillBuffer(unsigned char*, unsigned int, unsigned long) const
void AESContext::FillBuffer(uint8_t* buf, uint32_t len, uint64_t tag) const {
  uint32_t nBlocks = len / sizeof(block);
  uint32_t bytesRemaining = len % sizeof(block);

  GetBlocks((block*) buf, nBlocks, tag);
  if (bytesRemaining != 0) {
    block lastBlock;
    GetBlock(lastBlock, tag, nBlocks);

    memcpy(buf + nBlocks * sizeof(block), &lastBlock, bytesRemaining);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r12d
shrl $0x4, %r12d
movl %edx, %ebp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %r12d, %edx
callq 0x5c74
andl $0xf, %ebp
je 0x5dd6
movl %r12d, %eax
vmovq %r15, %xmm0
vmovq %rax, %xmm1
movl 0xf0(%r14), %ecx
movl $0x1, %edx
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpxor (%r14), %xmm0, %xmm0
cmpq $0x2, %rcx
jb 0x5db5
movq %rcx, %rdx
shlq $0x4, %rdx
movl $0x10, %esi
vaesenc (%r14,%rsi), %xmm0, %xmm0
addq $0x10, %rsi
cmpq %rsi, %rdx
jne 0x5da3
movq %rcx, %rdx
shlq $0x4, %rdx
shll $0x4, %eax
movq %rsp, %rsi
vaesenclast (%r14,%rdx), %xmm0, %xmm0
addq %rax, %rbx
movl %ebp, %edx
movq %rbx, %rdi
vmovdqa %xmm0, (%rsi)
callq 0x21b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gty980218[P]ee450/hospitalC.cpp
// Function: main
int main(int argc, char *argv[]){
    if(argc!=4){
        fprintf(stderr,"Missing location,capacity or occupancy parameters!\n");
        exit(1);
    }

    int size=indice_map.size();
    Hospital hospital(atoi(argv[2]),atoi(argv[3]),init(atoi(argv[1])),atoi(argv[1]));
    //create socket 
	int sock;
	if((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0){
        fprintf(stderr,"Create socket failed!\n");
        exit(1);
    }                                                       //SOCK_DGRAM for UDP
	//initialize address
	struct  sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;                          //use IPv4
	servaddr.sin_port = htons(32188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);           //0.0.0.0 stands for all IPs in local host,listening all NIC's ports 
    //bind
	if(bind(sock, (struct sockaddr*)& servaddr, sizeof(servaddr)) < 0){
        fprintf(stderr,"Binding failed,check the availability of port!\n");
        exit(1);
    }
    //send initialized occpation and capacity
    ready(sock,hospital);
    //waiting for client
    serve(sock,hospital);
    close(sock);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x4, %edi
jne 0x2553
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x2290
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x2290
movl %eax, %r15d
movq 0x8(%rbx), %rdi
callq 0x2290
movl %eax, %edi
callq 0x25d3
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x2290
movl %r14d, -0x38(%rbp)
movl %r15d, -0x34(%rbp)
movq %r12, -0x28(%rbp)
movl %eax, -0x30(%rbp)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x20a0
testl %eax, %eax
jns 0x257d
movq 0x3a96(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1b10(%rip), %rdi      # 0x405c
movl $0x16, %esi
jmp 0x2569
movq 0x3a7e(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1ac4(%rip), %rdi      # 0x4028
movl $0x33, %esi
movl $0x1, %edx
callq 0x2320
movl $0x1, %edi
callq 0x2240
movl %eax, %ebx
leaq -0x48(%rbp), %rsi
movq $0x0, 0x8(%rsi)
movl $0xbc7d0002, %eax       # imm = 0xBC7D0002
movq %rax, (%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x2060
testl %eax, %eax
jns 0x25bb
movq 0x3a2e(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1abf(%rip), %rdi      # 0x4073
movl $0x2f, %esi
jmp 0x2569
leaq -0x38(%rbp), %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x2816
movl %ebx, %edi
movq %r14, %rsi
callq 0x2a7d
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/ServerInfo.cpp
// Function: ServerInfo::setServer(int, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	ServerInfo::setServer(int nb, int const &pos, std::string const &buf)
{
	typedef void (ServerInfo::*MemFuncPtr)(const char*);
	MemFuncPtr F[] = { &ServerInfo::setPort, &ServerInfo::setError, &ServerInfo::setNames, 
                        &ServerInfo::setMaxClientsBS, &ServerInfo::setHost };
                        
    const char *tmp = buf.c_str() + pos;
	int i = 0;

	while (isspace(tmp[i]))
        i++;
    
	(this->*F[nb])(tmp + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
leaq 0x7d(%rip), %rax        # 0x5c82
movq %rax, -0x70(%rbp)
leaq 0x2da(%rip), %rax       # 0x5eea
movq %rax, -0x60(%rbp)
leaq 0x45f(%rip), %rax       # 0x607a
movq %rax, -0x50(%rbp)
leaq 0x468(%rip), %rax       # 0x608e
movq %rax, -0x40(%rbp)
leaq 0x6c5(%rip), %rax       # 0x62f6
movq %rax, -0x30(%rbp)
movq (%rcx), %rax
movslq (%rdx), %rcx
leaq (%rcx,%rax), %r14
decq %r14
movsbl 0x1(%r14), %edi
incq %r14
callq 0x4060
testl %eax, %eax
jne 0x5c42
movslq %r15d, %rcx
shlq $0x4, %rcx
movq -0x70(%rbp,%rcx), %rax
addq -0x68(%rbp,%rcx), %rbx
testb $0x1, %al
je 0x5c70
movq (%rbx), %rcx
movq -0x1(%rcx,%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::FileParser(char const*, bool)
FileParser::FileParser(const char *filepath, bool s) : _bracket(0), _cli_srv(0), _filePath(filepath)
{
	#if DEBUG
		std::cout << "FileParser object trying to read file at path :|" << filepath << "|\n";
	#endif
	
	_file.open(filepath);
	parseRequestFile();
	(void)s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4450
leaq 0x218(%rbx), %r13
movq %r13, 0x208(%rbx)
xorl %eax, %eax
movq %rax, 0x210(%rbx)
movb %al, 0x218(%rbx)
movl %eax, 0x228(%rbx)
leaq 0x238(%rbx), %rcx
movl %eax, 0x238(%rbx)
movq %rax, 0x240(%rbx)
movq %rcx, 0x248(%rbx)
movq %rcx, 0x250(%rbx)
movq %rax, 0x258(%rbx)
leaq 0x268(%rbx), %rcx
movl %eax, 0x268(%rbx)
movq %rax, 0x270(%rbx)
movq %rcx, 0x278(%rbx)
movq %rcx, 0x280(%rbx)
movq %rax, 0x288(%rbx)
leaq 0x2a0(%rbx), %r15
movq %r15, 0x290(%rbx)
movq %rax, 0x298(%rbx)
movb %al, 0x2a0(%rbx)
movq %rax, 0x2b0(%rbx)
leaq 0x2b8(%rbx), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0x518a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x4270
movq %rbx, %rdi
callq 0x6c44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x38(%rbp)
jmp 0x6be5
movq %rax, -0x38(%rbp)
movq 0x2b8(%rbx), %rdi
leaq 0x2c8(%rbx), %rax
cmpq %rax, %rdi
je 0x6be5
movq (%rax), %rsi
incq %rsi
callq 0x43e0
leaq 0x230(%rbx), %r14
leaq 0x260(%rbx), %r12
movq 0x290(%rbx), %rdi
cmpq %r15, %rdi
je 0x6c0a
movq (%r15), %rsi
incq %rsi
callq 0x43e0
movq %r12, %rdi
callq 0x67ca
movq %r14, %rdi
callq 0x577e
movq 0x208(%rbx), %rdi
cmpq %r13, %rdi
je 0x6c32
movq (%r13), %rsi
incq %rsi
callq 0x43e0
movq %rbx, %rdi
callq 0x4100
movq -0x38(%rbp), %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::parseConfigFile()
void FileParser::parseConfigFile()
{
	// loop for each block server if there is something else, throw an error
	while (std::getline(_file, _buf)){
		
		if (!_buf.compare(0, 9, "server {")){
			_bracket = 0;
			bracketRegulator(_bracket, _buf);
			newServer();
		}
		else if (!_buf.compare(0, 1, "}") || !_buf.compare(0, 2, ""))
			continue;
		else throw std::runtime_error(errParseMessage("error line : ", _buf.c_str(), " not a good name for server block\n")); // ERREUR 
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x208(%rdi), %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x43b0
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4740
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7177
leaq 0x228(%r14), %r15
leaq 0xe04f(%rip), %r12      # 0x15125
leaq 0xe051(%rip), %r13      # 0x1512e
movl $0x9, %edx
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x4510
testl %eax, %eax
je 0x7125
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rcx
callq 0x4510
testl %eax, %eax
je 0x7143
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
leaq 0xe5e7(%rip), %rcx      # 0x15701
callq 0x4510
testl %eax, %eax
je 0x7143
jmp 0x7186
movl $0x0, 0x228(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9f80
movq %r14, %rdi
callq 0x71fa
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x43b0
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4740
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x70dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %r14
movq (%rbx), %rsi
leaq 0xdf93(%rip), %rdi      # 0x15130
leaq 0xdf9a(%rip), %rdx      # 0x1513e
callq 0x9fe7
movq %r14, %rdi
movq %rax, %rsi
callq 0x4620
movq 0x15e2d(%rip), %rsi     # 0x1cfe8
movq 0x15df6(%rip), %rdx     # 0x1cfb8
movq %r14, %rdi
callq 0x46a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::addNewLocationToMap(Location*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FileParser::addNewLocationToMap(Location *loc, std::string const &name)
{
	std::map<std::string, Location>::iterator it = _m_loc.find(name);
	
	if (it == _m_loc.end())
		_m_loc.insert(std::pair<std::string, Location>(name, *loc));
	else
		throw std::runtime_error(errParseMessage("Error : location ", name.c_str(), " already exist\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x260(%rdi), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x860e
addq $0x268, %r12            # imm = 0x268
cmpq %r12, %rax
jne 0x797f
leaq -0x108(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7bde
movq %rbx, %rdi
movq %r12, %rsi
callq 0x86ac
leaq -0xe8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8bce
movq -0x20(%rbx), %rdi
leaq -0xf8(%rbp), %rax
cmpq %rax, %rdi
je 0x796f
movq -0xf8(%rbp), %rsi
incq %rsi
callq 0x43e0
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0xd86f(%rip), %rdi      # 0x15205
leaq 0xd87a(%rip), %rdx      # 0x15217
callq 0x9fe7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4620
movq 0x15634(%rip), %rsi     # 0x1cfe8
movq 0x155fd(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
jmp 0x79df
movq %rax, %r14
leaq -0x108(%rbp), %rdi
callq 0x7c3c
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::addNewServerToMap(ServerInfo&)
void FileParser::addNewServerToMap(ServerInfo &srv)
{
	int s_port = srv.getPort();
	srv.setSrvLocation()->insert(_m_loc.begin(), _m_loc.end());
	std::map<int, std::vector<ServerInfo> >::iterator it = _m_srv.find(s_port);
		
	if (it == _m_srv.end()){
		std::vector<ServerInfo> v_srv(1, srv);
		_m_srv.insert(std::pair<int, std::vector<ServerInfo> >(s_port, v_srv));
	}
	else
		it->second.push_back(srv);
	_m_loc.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5bb6
movl (%rax), %r13d
movq %r14, %rdi
callq 0x6334
movq 0x278(%rbx), %rsi
leaq 0x268(%rbx), %rdx
movq %rax, %rdi
callq 0x7e34
movq 0x240(%rbx), %rax
testq %rax, %rax
je 0x7a60
leaq 0x238(%rbx), %rcx
movq %rcx, %rdi
xorl %edx, %edx
cmpl %r13d, 0x20(%rax)
setl %dl
cmovgeq %rax, %rdi
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x7a3e
cmpq %rcx, %rdi
je 0x7a60
cmpl 0x20(%rdi), %r13d
jge 0x7acd
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %r12
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x7afc
movl %r13d, (%r12)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5620
leaq 0x230(%rbx), %rdi
leaq -0x60(%rbp), %rsi
callq 0x81d8
movq %r14, %rdi
callq 0x55c6
leaq -0x40(%rbp), %rdi
callq 0x55c6
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
callq 0x85d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %rdi
movq %r14, %rsi
callq 0x7ba0
jmp 0x7aaf
movq %rax, %rbx
movq %r14, %rdi
callq 0x55c6
jmp 0x7aeb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x55c6
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setLocation(int, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	Location::setLocation(int nb, int const &pos, std::string const &buf)
{
	typedef void (Location::*MemFuncPtr)(const char*);
	MemFuncPtr F[] = { &Location::setMethods, &Location::setIndex,
						&Location::setUploadStore, &Location::setRoot, &Location::setCgiExe, 
						&Location::setAutoIndex, &Location::setRedirect};

	const char *tmp = buf.c_str() + pos;
	int i = 0;

	while (isspace(tmp[i]))
		i++;

	(this->*F[nb])(tmp + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq (%rcx), %rax
movslq (%rdx), %rcx
leaq (%rcx,%rax), %r14
decq %r14
movsbl 0x1(%r14), %edi
incq %r14
callq 0x4060
testl %eax, %eax
jne 0x8cc3
movslq %r15d, %rax
shlq $0x4, %rax
leaq 0x1401e(%rip), %rcx     # 0x1cd00
movq (%rax,%rcx), %rax
testb $0x1, %al
je 0x8cf2
movq (%rbx), %rcx
movq -0x1(%rcx,%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setMethods(char const*)
void Location::setMethods(char const *n) 
{
	_allow_methd.clear();
	setStringArray(n, _allow_methd);
	const char *method_checking[] = { "POST", "GET", "HEAD", "DELETE"};
	for (size_t i = 0; i < _allow_methd.size(); i++){
		for (size_t j = 0; j < 4; j++){
			if (!strcmp(method_checking[j], _allow_methd[i].c_str()))
				break;
			if (j == 4)
				throw std::runtime_error("Error : method " + std::string(_allow_methd[i]) + " is not accepted\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x68(%rdi), %rsi
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x9c86
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xa1aa
nop
// File: /workspace/github_cpp_makefile_star2_O3/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setUploadStore(char const*)
void Location::setUploadStore(char const *u) 
{
	std::string cString = u;
	if (numberOfWords(u) != 1)
		throw std::runtime_error("Error : " + std::string(cString) + " - put only one upload_path input\n");
	_upload_path = *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 -0x88(%rbp), %rdx
callq 0x518a
movq %r14, %rdi
callq 0xa075
cmpq $0x1, %rax
jne 0x8dc1
leaq -0x48(%rbp), %rdi
callq 0xa150
addq $0x28, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4240
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8daf
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 -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x67e2
leaq 0xc2ac(%rip), %rsi      # 0x1509d
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x51d5
leaq 0xc480(%rip), %rsi      # 0x15288
leaq -0xa8(%rbp), %rdi
callq 0x4760
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8e35
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x8e43
movq %rdx, -0x88(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
movq 0x8(%rax), %rdx
leaq -0x88(%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 0x14172(%rip), %rsi     # 0x1cfe8
movq 0x1413b(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ea8
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x8ea8
movq %rax, %r14
movb $0x1, %r12b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ec7
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x43e0
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x8edc
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r12b, %r12b
jne 0x8f00
jmp 0x8f0d
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x8f00
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x8f00
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
jmp 0x8f0d
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f26
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x88(%rbp), %rdx
callq 0x518a
movq %r14, %rdi
callq 0xa075
cmpq $0x1, %rax
jne 0x8fa9
leaq -0x48(%rbp), %rdi
callq 0xa150
addq $0x8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4240
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f97
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 -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x67e2
leaq 0xc0c4(%rip), %rsi      # 0x1509d
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x51d5
leaq 0xc27d(%rip), %rsi      # 0x1526d
leaq -0xa8(%rbp), %rdi
callq 0x4760
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x901d
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x902b
movq %rdx, -0x88(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
movq 0x8(%rax), %rdx
leaq -0x88(%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 0x13f8a(%rip), %rsi     # 0x1cfe8
movq 0x13f53(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x9090
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9090
movq %rax, %r14
movb $0x1, %r12b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90af
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x43e0
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x90c4
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r12b, %r12b
jne 0x90e8
jmp 0x90f5
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x90e8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x90e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
jmp 0x90f5
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x910e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa1aa
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jne 0x91b6
leaq 0x20(%rsi), %rdx
leaq -0x70(%rbp), %rdi
callq 0x98a6
addq $0x98, %rbx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x9cd8
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x918b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91a4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x30(%rbp), %rdi
callq 0x63d2
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %r14
leaq 0xc101(%rip), %rsi      # 0x152cb
movq %rax, %rdi
callq 0x41b0
movq 0x13e0f(%rip), %rsi     # 0x1cfe8
movq 0x13dd8(%rip), %rdx     # 0x1cfb8
movq %r14, %rdi
callq 0x46a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x42e0
jmp 0x9208
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x9914
jmp 0x9208
jmp 0x9205
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x63d2
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa150
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4240
leaq 0xc6d8(%rip), %rsi      # 0x15935
leaq -0x48(%rbp), %rdi
callq 0x4130
testl %eax, %eax
je 0x927e
leaq 0xc07e(%rip), %rsi      # 0x152ef
leaq -0x48(%rbp), %rdi
callq 0x4130
testl %eax, %eax
jne 0x92bf
leaq 0xc6b0(%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 0x92af
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 0xc00d(%rip), %rsi      # 0x152f3
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x51d5
leaq 0xc006(%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 0x932e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x9339
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 0x13c7f(%rip), %rsi     # 0x1cfe8
movq 0x13c48(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x9398
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9398
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93b7
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93d0
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r15b, %r15b
jne 0x93f8
jmp 0x9405
movq %rax, %r14
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93f8
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x93f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
jmp 0x9405
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x941e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa1aa
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x948e
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x4240
leaq -0x40(%rbp), %rdi
callq 0x63d2
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r14, %rsi
callq 0x518a
leaq 0xbbeb(%rip), %rsi      # 0x1509d
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x51d5
leaq 0xbde2(%rip), %rsi      # 0x152ab
leaq -0xa0(%rbp), %rdi
callq 0x4760
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x94f7
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x9502
movq %rdx, -0x80(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x70(%rbp)
movq 0x8(%rax), %rdx
leaq -0x80(%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 0x13ab6(%rip), %rsi     # 0x1cfe8
movq 0x13a7f(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x9561
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x9561
movq %rax, %r14
movb $0x1, %r15b
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9580
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x43e0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9599
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r15b, %r15b
jne 0x95c1
jmp 0x95ce
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x95c1
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x43e0
jmp 0x95c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
jmp 0x95ce
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x63d2
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movsbl (%r15), %edi
callq 0x4060
testl %eax, %eax
je 0x9f3d
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40d0
movq (%rbx), %r15
jmp 0x9f1c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x9f73
decl %eax
movslq %eax, %r14
movsbl (%r15,%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x9f73
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40d0
movq (%rbx), %rax
movsbl (%rax,%r14), %edi
jmp 0x9f50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9fb5
incl (%r14)
incq %rax
movq %rbx, %rdi
movl $0x7b, %esi
movq %rax, %rdx
jmp 0x9f97
movq %rbx, %rdi
movl $0x7d, %esi
xorl %edx, %edx
callq 0x4500
cmpq $-0x1, %rax
je 0x9fdd
decl (%r14)
incq %rax
movq %rbx, %rdi
movl $0x7d, %esi
movq %rax, %rdx
jmp 0x9fbf
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1342c(%rip), %al      # 0x1d430
testb %al, %al
je 0xa06e
movq $0x0, 0x13405(%rip) # 0x1d418
leaq 0x133f6(%rip), %r15     # 0x1d410
movq 0x133ef(%rip), %rax     # 0x1d410
movb $0x0, (%rax)
movq 0x133ed(%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 0xa008
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa14f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
leaq 0x1(%rdi), %rcx
movq %rcx, -0x30(%rbp)
xorl %ecx, %ecx
movq %rdi, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movslq %ecx, %r13
shlq $0x20, %rcx
movq -0x30(%rbp), %rax
leaq (%rax,%r13), %rdx
decq %r13
movq %rcx, %rbx
movq %rdx, %r14
movb 0x1(%r12,%r13), %r15b
movsbl %r15b, %edi
callq 0x4060
incq %r13
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rbx, %rcx
leaq 0x1(%r14), %rdx
testl %eax, %eax
jne 0xa0b8
xorl %r12d, %r12d
movsbl %r15b, %r15d
movl %r15d, %edi
callq 0x43f0
testl %eax, %eax
jne 0xa103
movl %r15d, %edi
callq 0x4770
testl %eax, %eax
je 0xa11b
movb (%r14), %r15b
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbx
decq %r12
incq %r14
jmp 0xa0e7
cmpq $0x1, %r12
movq -0x40(%rbp), %rax
sbbl $-0x1, %eax
sarq $0x20, %rbx
subq %r12, %r13
movq -0x38(%rbp), %r12
cmpb $0x0, (%r12,%rbx)
movq %r13, %rcx
jne 0xa0a2
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_O3/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 0xa19e
movq (%rbx), %r12
addq %r12, %r14
movq %r14, %r15
movsbl (%r15), %edi
callq 0x4060
testl %eax, %eax
je 0xa193
movq %r14, %rsi
subq %r12, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4480
movq (%rbx), %r12
decq %r15
decq %r14
cmpq %r12, %r15
jne 0xa170
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb1f7(%rip), %rsi      # 0x153c1
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x45f0
testq %rax, %rax
je 0xa23a
movq %rax, %r13
leaq -0x40(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq 0xb1d4(%rip), %r12      # 0x153c1
movq %r14, -0x50(%rbp)
movq %r13, %rdi
callq 0x41e0
leaq (%rax,%r13), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x5796
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa272
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa228
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
xorl %edi, %edi
movq %r12, %rsi
callq 0x45f0
movq %rax, %r13
testq %rax, %rax
jne 0xa1ed
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 0xa26a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x43e0
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x4250
movq %r14, %rdi
movq %r14, %rsi
callq 0xb7a0
movq %r14, %rdi
movq %r13, %rsi
callq 0xb818
movq %r14, %rdi
movq %r13, %rsi
callq 0xb890
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 0xa814
je 0xa832
movq %r14, %rdi
callq 0xa87a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xafd8
movq %r14, %rdi
callq 0xb2f0
jmp 0xa794
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq 0xab9f(%rip), %rsi      # 0x153c7
movq %rax, %rdi
callq 0x41b0
jmp 0xa84e
movl $0x10, %edi
callq 0x41f0
movq %rax, %rbx
leaq 0xaba6(%rip), %rsi      # 0x153ec
movq %rax, %rdi
callq 0x41b0
movq 0x12793(%rip), %rsi     # 0x1cfe8
movq 0x1275c(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x46a0
jmp 0xa866
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xce96
movq 0x8(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1f41, %rax           # imm = 0x1F41
jae 0xcf21
cmpb $0x0, 0xa8(%rdi)
jne 0xceaf
movq 0x8(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1f41, %rax           # imm = 0x1F41
jae 0xcec3
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), %r15
movq %r15, -0x10(%r15)
leaq 0x8822(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5796
movb $0x1, %r12b
leaq 0x87b6(%rip), %rdx      # 0x156ab
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1af, %esi            # imm = 0x1AF
callq 0xe0d4
xorl %r12d, %r12d
leaq 0xfe60(%rip), %rsi      # 0x1cd70
leaq 0x122b(%rip), %rdx      # 0xe142
movq %rbx, %rdi
callq 0x46a0
jmp 0xcf7d
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x87c4(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5796
movb $0x1, %r12b
leaq 0x874b(%rip), %rdx      # 0x1569e
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x19e, %esi            # imm = 0x19E
callq 0xe0d4
xorl %r12d, %r12d
leaq 0xfe02(%rip), %rsi      # 0x1cd70
leaq 0x11cd(%rip), %rdx      # 0xe142
movq %rbx, %rdi
callq 0x46a0
jmp 0xcf81
jmp 0xcfa0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xcf99
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r12b, %r12b
jne 0xcfa3
jmp 0xcfab
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13b82
testq %rax, %rax
jne 0xd3dc
movq 0x28(%rbx), %rax
movq (%rax), %rax
movq %rax, %rdi
callq 0x5b98
movslq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd84a
movq %r14, 0xb0(%rbx)
movq %rbx, %rsi
movq %r14, %rcx
callq 0xe21e
cmpl $-0x1, %eax
je 0xd875
addq %r14, 0x20(%rbx)
cmpq $0x0, 0xb0(%rbx)
je 0xd8d7
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), %r15
movq %r15, -0x10(%r15)
leaq 0x7ddf(%rip), %rsi      # 0x15670
leaq 0x7e05(%rip), %rdx      # 0x1569d
leaq -0x40(%rbp), %rdi
callq 0x5796
movb $0x1, %r12b
leaq 0x7db3(%rip), %rdx      # 0x1565e
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x19d, %esi            # imm = 0x19D
callq 0xe0d4
xorl %r12d, %r12d
leaq 0xf4aa(%rip), %rsi      # 0x1cd70
leaq 0x875(%rip), %rdx       # 0xe142
movq %rbx, %rdi
callq 0x46a0
jmp 0xd933
movl $0x48, %edi
callq 0x41f0
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x7e0e(%rip), %rdx      # 0x15701
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x5796
movb $0x1, %r12b
leaq 0x7d1a(%rip), %rdx      # 0x15623
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0xc8, %esi
callq 0xe0d4
xorl %r12d, %r12d
leaq 0xf44c(%rip), %rsi      # 0x1cd70
leaq 0x817(%rip), %rdx       # 0xe142
movq %rbx, %rdi
callq 0x46a0
jmp 0xd937
jmp 0xd956
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xd94f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43e0
testb %r12b, %r12b
jne 0xd959
jmp 0xd961
movq %rax, %r14
movq %rbx, %rdi
callq 0x42e0
movq %r14, %rdi
callq 0x46d0
nop