LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::setup(InputArgs&)
void RequestConfig::setup(InputArgs &options) {
  ServerConfig *server = getServerForRequest(servers_);
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server, request_.target_);

  server_ = server;
  location_ = server;

  target_ = request_.target_;

  if (location) {
    location_ = location;
    if (!options.location() && request_.target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
callq 0x88ce
movq %rax, %r12
movq (%rbx), %rdi
callq 0xf3ea
cmpl $0x3, %eax
jl 0x8856
movq (%rbx), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8ae0
movq %rax, %r15
jmp 0x8859
xorl %r15d, %r15d
movq %r12, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq (%rbx), %rsi
addq $0x40, %rsi
leaq 0x30(%rbx), %r12
movq %r12, %rdi
callq 0x4240
testq %r15, %r15
je 0x88c1
movq %r15, 0x28(%rbx)
movq %r14, %rdi
callq 0x80c2
testb %al, %al
jne 0x88c1
movq (%rbx), %rdi
addq $0x40, %rdi
addq $0x50, %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x4880
cmpq $-0x1, %rax
je 0x88c1
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r12, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::getLocationForRequest(ServerConfig*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ServerConfig *RequestConfig::getLocationForRequest(ServerConfig *server, std::string &target) {
  ServerConfig *location = NULL;

  std::vector<ServerConfig*> reg_locations;

  for (std::vector<ServerConfig>::iterator it = server->locations_.begin(); it != server->locations_.end(); it++) {
    if (it->modifier_ != 2 && it->modifier_ != 3) {
      if (it->modifier_ == 1 && it->uri_ == target)
        return &(*it);
      else if (target.find(it->uri_) == 0) {
        if (location && location->uri_.length() < it->uri_.length())
          location = &(*it);
        else if (!location)
          location = &(*it);
      }
    }
    else
      reg_locations.push_back(&(*it));
  }

  if (location && location->modifier_ == 4)
    return location;

  if (location && !location->locations_.empty()) {
    for (std::vector<ServerConfig>::iterator it = location->locations_.begin(); it != location->locations_.end(); it++) {
      if (it->modifier_ == 2 || it->modifier_ == 3) {
        reg_locations.insert(reg_locations.begin(), &(*it));
      }
    }
  }

  ServerConfig *reg = match_regexp(reg_locations, target);

  if (reg)
    return reg;

  return location;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0x38(%rsi), %r12
addq $0x50, %r12
xorl %ebp, %ebp
leaq -0x50(%r12), %rbx
cmpq 0x40(%r15), %rbx
je 0x8b85
movl 0x20(%r12), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8b3c
movq %rbx, 0x8(%rsp)
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9312
jmp 0x8b7c
cmpl $0x1, %eax
jne 0x8b54
movq %r12, %rdi
movq %r14, %rsi
callq 0x91d1
testb %al, %al
jne 0x8bef
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4880
testq %rax, %rax
jne 0x8b7c
testq %rbp, %rbp
je 0x8b79
movq 0x58(%rbp), %rax
cmpq 0x8(%r12), %rax
jb 0x8b79
movq %rbp, %rbx
movq %rbx, %rbp
addq $0x198, %r12            # imm = 0x198
jmp 0x8b10
testq %rbp, %rbp
je 0x8bd9
cmpl $0x4, 0x70(%rbp)
je 0x8bf6
movq 0x38(%rbp), %rbx
movq 0x40(%rbp), %rax
cmpq %rax, %rbx
je 0x8bd9
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %rax, %rbx
je 0x8bd9
movl 0x70(%rbx), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x8bd0
movq 0x10(%rsp), %rsi
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x9906
movq 0x40(%rbp), %rax
addq $0x198, %rbx            # imm = 0x198
jmp 0x8ba7
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x8cb6
testq %rax, %rax
cmovneq %rax, %rbp
jmp 0x8bf6
addq $-0x50, %r12
movq %r12, %rbp
leaq 0x10(%rsp), %rdi
callq 0x92de
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c16
jmp 0x8c16
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x92de
movq %rbx, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::redirectLocation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RequestConfig::redirectLocation(std::string target) {
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server_, target);

  target_ = target;
  if (location) {
    location_ = location;
    if (target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xf3ea
cmpl $0x3, %eax
jl 0x8c5b
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ae0
movq %rax, %r12
jmp 0x8c5e
xorl %r12d, %r12d
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4240
testq %r12, %r12
je 0x8caa
movq %r12, 0x28(%rbx)
addq $0x50, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4880
cmpq $-0x1, %rax
je 0x8caa
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::match_regexp(std::vector<ServerConfig*, std::allocator<ServerConfig*>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ServerConfig *RequestConfig::match_regexp(std::vector<ServerConfig*> &locations, std::string &target) {
  regex_t reg;

  for (std::vector<ServerConfig*>::iterator it = locations.begin(); it != locations.end(); it++) {
    int flag = REG_NOSUB | REG_EXTENDED;

    if ((*it)->modifier_ == 3)
      flag |= REG_ICASE;

    int err = regcomp(&reg, (*it)->uri_.c_str(), flag);

    if (err == 0) {
      int match = regexec(&reg, target.c_str(), 0, NULL, 0);
      regfree(&reg);
      if (match == 0)
        return *it;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %r13
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
cmpq 0x8(%r15), %r13
je 0x8d28
movq (%r13), %rax
xorl %ecx, %ecx
cmpl $0x3, 0x70(%rax)
sete %cl
leal 0x9(,%rcx,2), %edx
movq 0x50(%rax), %rsi
movq %r12, %rdi
callq 0x44e0
testl %eax, %eax
jne 0x8d1e
movq (%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4570
movl %eax, %ebp
movq %r12, %rdi
callq 0x4470
testl %ebp, %ebp
je 0x8d24
addq $0x8, %r13
jmp 0x8cd4
movq (%r13), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::methodAccepted(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool RequestConfig::methodAccepted(std::string &method) {
  std::vector<std::string> methods = location_->methods_;

  if (methods.empty())
    return true;
  if (std::find(methods.begin(), methods.end(), method) != methods.end())
    return true;
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl $0xe8, %esi
addq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x6e58
movq (%r14), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0x8d76
movq %rbx, %rdx
callq 0x99a2
cmpq 0x8(%rsp), %rax
setne %bl
jmp 0x8d78
movb $0x1, %bl
movq %rsp, %rdi
callq 0x608e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x608e
movq %rbx, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::operator=(ServerConfig const&)
ServerConfig	&ServerConfig::operator=(const ServerConfig &copy) {
  client_max_body_size_ = copy.client_max_body_size_;
  root_ = copy.root_;
  error_codes_ = copy.error_codes_;
  index_ = copy.index_;
  cgi_ = copy.cgi_;
  cgi_bin_ = copy.cgi_bin_;
  autoindex_ = copy.autoindex_;
  credentials_ = copy.credentials_;
  return (*this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movl $0xa8, %edi
addq %rdi, %rsi
addq %rbx, %rdi
callq 0x4240
movl $0x100, %edi            # imm = 0x100
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xb26e
movl $0x130, %edi            # imm = 0x130
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xb01e
movl $0x148, %edi            # imm = 0x148
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xb4fa
movl $0x178, %edi            # imm = 0x178
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x4240
movb 0x98(%r14), %al
movb %al, 0x98(%rbx)
addq $0x78, %r14
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x4240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::error_page(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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 ServerConfig::error_page(std::vector<std::string>::iterator &it) {
  std::vector<int> codes;

  while (it->find_first_not_of("0123456789") == std::string::npos) {
    codes.push_back(ft::stoi(*it++));
  }
  for (std::vector<int>::iterator it2 = codes.begin(); it2 != codes.end(); it2++) {
    error_codes_[*it2] = *it;
  }
  if (*++it != ";")
    throw std::runtime_error("double value in 'listen'");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x11b0b(%rip), %r12     # 0x1c1db
pushq $0xa
popq %rbp
leaq 0xc(%rsp), %r13
movq (%rbx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4270
cmpq $-0x1, %rax
jne 0xa70f
movq (%rbx), %rdi
leaq 0x20(%rdi), %rax
movq %rax, (%rbx)
xorl %esi, %esi
movl %ebp, %edx
callq 0x1b536
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xc168
jmp 0xa6d8
movq 0x10(%rsp), %r15
addq $0x100, %r14            # imm = 0x100
movq (%rbx), %r12
cmpq 0x18(%rsp), %r15
je 0xa741
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1ba
movq %rax, %rdi
movq %r12, %rsi
callq 0x4240
addq $0x4, %r15
jmp 0xa71b
addq $0x20, %r12
movq %r12, (%rbx)
leaq 0x121db(%rip), %rsi     # 0x1c92a
movq %r12, %rdi
callq 0x61cb
testb %al, %al
jne 0xa774
leaq 0x10(%rsp), %rdi
callq 0xc134
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %r14
leaq 0x11ca4(%rip), %rsi     # 0x1c42a
movq %rax, %rdi
callq 0x4170
movq 0x2085b(%rip), %rsi     # 0x2aff0
movq 0x20814(%rip), %rdx     # 0x2afb0
movq %r14, %rdi
callq 0x4730
movq %rax, %rbx
movq %r14, %rdi
callq 0x4310
jmp 0xa7b8
jmp 0xa7b5
jmp 0xa7b5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc134
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::client_max_body_size(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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 ServerConfig::client_max_body_size(std::vector<std::string>::iterator &it) {
  if (it->find_first_not_of("0123456789") != std::string::npos)
      throw std::runtime_error("unexpected symbols in client_max_body_size");
  client_max_body_size_ = ft::stoi(*it);
  if (*++it != ";")
    throw std::runtime_error("double value in 'client_max_body_size_'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x11985(%rip), %rsi     # 0x1c1db
xorl %edx, %edx
callq 0x4270
cmpq $-0x1, %rax
jne 0xa89b
movq (%rbx), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x1b536
cltq
movq %rax, 0xa0(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x120a0(%rip), %rsi     # 0x1c92a
callq 0x61cb
testb %al, %al
jne 0xa8b7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x11b96(%rip), %rsi     # 0x1c443
movq %rax, %rdi
callq 0x4170
jmp 0xa8d1
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x11ba5(%rip), %rsi     # 0x1c46e
movq %rax, %rdi
callq 0x4170
movq 0x20718(%rip), %rsi     # 0x2aff0
movq 0x206d1(%rip), %rdx     # 0x2afb0
movq %rbx, %rdi
callq 0x4730
jmp 0xa8e9
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::autoindex(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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 ServerConfig::autoindex(std::vector<std::string>::iterator &it) {
  if (*it == "on")
    autoindex_ = true;
  else if (*it == "off")
    autoindex_ = false;
  else
    throw std::runtime_error("unknown value in 'autoindex'");

  if (*++it != ";")
    throw std::runtime_error("double value in 'autoindex'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x126c0(%rip), %rsi     # 0x1d08e
callq 0x610b
movb $0x1, %cl
testb %al, %al
jne 0xa9ee
movq (%rbx), %rdi
leaq 0x126e4(%rip), %rsi     # 0x1d0c7
callq 0x610b
testb %al, %al
je 0xaa33
xorl %ecx, %ecx
movb %cl, 0x98(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x11f24(%rip), %rsi     # 0x1c92a
callq 0x61cb
testb %al, %al
jne 0xaa17
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x11ab8(%rip), %rsi     # 0x1c4e1
movq %rax, %rdi
callq 0x4170
jmp 0xaa4d
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x11a7f(%rip), %rsi     # 0x1c4c4
movq %rax, %rdi
callq 0x4170
movq 0x2059c(%rip), %rsi     # 0x2aff0
movq 0x20555(%rip), %rdx     # 0x2afb0
movq %rbx, %rdi
callq 0x4730
jmp 0xaa65
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::cgi(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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 ServerConfig::cgi(std::vector<std::string>::iterator &it) {
  std::string &ext = *it++;
  std::string &exec = *it++;
  cgi_[ext] = exec;
  if (*it != ";")
    throw std::runtime_error("triple value in 'cgi'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
leaq 0x20(%rsi), %r14
leaq 0x40(%rsi), %rax
movq %rax, (%rbx)
addq $0x148, %rdi            # imm = 0x148
callq 0xb208
movq %rax, %rdi
movq %r14, %rsi
callq 0x4240
movq (%rbx), %rdi
leaq 0x11dbe(%rip), %rsi     # 0x1c92a
callq 0x61cb
testb %al, %al
jne 0xab7d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x119d4(%rip), %rsi     # 0x1c563
movq %rax, %rdi
callq 0x4170
movq 0x20452(%rip), %rsi     # 0x2aff0
movq 0x2040b(%rip), %rdx     # 0x2afb0
movq %rbx, %rdi
callq 0x4730
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::server(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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 ServerConfig::server(std::vector<std::string>::iterator &it) {
  if (*it != "{")
    throw std::runtime_error("missing opening bracket in server block");
  while (*(++it) != "}") {
    if (ServerConfig::directive_[*it])
      (this->*(ServerConfig::directive_[*it]))(++it);
    else
      throw std::runtime_error("invalid directive '" + *it + "' in 'server'");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x1143b(%rip), %rsi     # 0x1c093
callq 0x61cb
testb %al, %al
jne 0xad2d
leaq 0x11429(%rip), %r15     # 0x1c095
leaq 0x20885(%rip), %r12     # 0x2b4f8
movq (%r14), %rdi
addq $0x20, %rdi
movq %rdi, (%r14)
movq %r15, %rsi
callq 0x61cb
testb %al, %al
je 0xacc7
movq (%r14), %rsi
movq %r12, %rdi
callq 0xb154
cmpq $0x0, (%rax)
je 0xacd4
movq (%r14), %rsi
movq %r12, %rdi
callq 0xb154
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0xacbc
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
addq $0x20, (%r14)
movq %r14, %rsi
callq *%rcx
jmp 0xac73
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x116f4(%rip), %rsi     # 0x1c3dd
movq %rsp, %rdi
callq 0x52b1
leaq 0x116f9(%rip), %rdx     # 0x1c3f1
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5292
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x46e0
xorl %ebp, %ebp
movq 0x202d2(%rip), %rsi     # 0x2aff0
movq 0x2028b(%rip), %rdx     # 0x2afb0
movq %rbx, %rdi
callq 0x4730
pushq $0x10
popq %rdi
callq 0x41e0
movq %rax, %rbx
leaq 0x11676(%rip), %rsi     # 0x1c3b5
movq %rax, %rdi
callq 0x4170
movq 0x202a2(%rip), %rsi     # 0x2aff0
movq 0x2025b(%rip), %rdx     # 0x2afb0
movq %rbx, %rdi
callq 0x4730
jmp 0xad83
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4898
jmp 0xad74
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x4898
testb %bpl, %bpl
jne 0xad86
jmp 0xad8e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: is_loc_modifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool is_loc_modifier(std::string &str) {
  return (str == "=" ||
          str == "~" ||
          str == "~*" ||
          str == "^~");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x11aed(%rip), %rsi     # 0x1c88e
callq 0x610b
testb %al, %al
jne 0xadd0
leaq 0x11783(%rip), %rsi     # 0x1c534
movq %rbx, %rdi
callq 0x610b
testb %al, %al
jne 0xadd0
leaq 0x1176c(%rip), %rsi     # 0x1c530
movq %rbx, %rdi
callq 0x610b
testb %al, %al
je 0xadd4
movb $0x1, %al
popq %rbx
retq
leaq 0x11758(%rip), %rsi     # 0x1c533
movq %rbx, %rdi
popq %rbx
jmp 0x610b
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/CGI.cpp
// Function: CGI::CGI(File&, RequestConfig&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::comp, std::allocator<std::pair<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>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
CGI::CGI(File &file, RequestConfig &config, std::map<std::string, std::string, ft::comp> &req_headers, std::string &req_body) : file_(file), config_(config), req_headers_(req_headers) {
  if (req_body.empty() && config_.getMethod() != "POST")
    req_body_ = file_.getContent();
  else
    req_body_ = req_body;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
movb %al, 0x88(%rdi)
leaq 0xa8(%rdi), %rcx
movq %rcx, 0x98(%rdi)
andq $0x0, 0xa0(%rdi)
movb %al, 0xa8(%rdi)
leaq 0xc8(%rdi), %rcx
movq %rcx, 0xb8(%rdi)
andq $0x0, 0xc0(%rdi)
movb %al, 0xc8(%rdi)
leaq 0xe8(%rdi), %rcx
movq %rcx, 0xd8(%rdi)
andq $0x0, 0xe0(%rdi)
movq %r8, %r12
leaq 0xd8(%rdi), %r14
movb %al, 0xe8(%rdi)
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x164bc
leaq 0x1a0(%rbx), %rax
andl $0x0, 0x1a0(%rbx)
andq $0x0, 0x1a8(%rbx)
movq %rax, 0x1b0(%rbx)
movq %rax, 0x1b8(%rbx)
andq $0x0, 0x1c0(%rbx)
xorl %eax, %eax
cmpq %rax, 0x8(%r12)
jne 0xcb58
movq 0x8(%rbx), %rdi
callq 0x8e4e
leaq 0xfa54(%rip), %rsi      # 0x1c579
movq %rax, %rdi
callq 0x61cb
testb %al, %al
je 0xcb58
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x17a2e
leaq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4560
movq %rbx, %rdi
callq 0x4898
jmp 0xcb63
movq %r14, %rdi
movq %r12, %rsi
callq 0x4240
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcb7b
movq %rax, 0x8(%rsp)
jmp 0xcb94
movq %rax, 0x8(%rsp)
leaq 0x198(%rbx), %rdi
callq 0x778e
movq %r15, %rdi
callq 0x1668a
leaq 0x18(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rbx), %r13
leaq 0x58(%rbx), %rbp
leaq 0x78(%rbx), %r12
leaq 0x98(%rbx), %r15
addq $0xb8, %rbx
movq %r14, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4898
movq %r12, %rdi
callq 0x4898
movq %rbp, %rdi
callq 0x4898
movq %r13, %rdi
callq 0x4898
movq 0x10(%rsp), %rdi
callq 0x4898
movq 0x8(%rsp), %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/CGI.cpp
// Function: CGI::~CGI()
CGI::~CGI() {
  free(argv_[0]);
  free(argv_[1]);
  if (env_)
    ft::free_tab(env_);
  tmp_file_.close();
  tmp_file_.unlink();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d0(%rdi), %rdi
callq 0x4540
movq 0x1d8(%rbx), %rdi
callq 0x4540
movq 0x1c8(%rbx), %rdi
testq %rdi, %rdi
je 0xd038
callq 0x1b9ac
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x166d0
movq %r14, %rdi
callq 0x16e72
leaq 0x198(%rbx), %rdi
callq 0x778e
movq %r14, %rdi
callq 0x1668a
leaq 0xd8(%rbx), %rdi
callq 0x4898
leaq 0xb8(%rbx), %rdi
callq 0x4898
leaq 0x98(%rbx), %rdi
callq 0x4898
leaq 0x78(%rbx), %rdi
callq 0x4898
leaq 0x58(%rbx), %rdi
callq 0x4898
leaq 0x38(%rbx), %rdi
callq 0x4898
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4898
movq %rax, %rdi
callq 0x539c
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Client.cpp
// Function: Client::timeout()
bool Client::timeout() {
  if (request_) {
    time_t current_time = ft::get_current_time_in_sec();
    if (current_time - request_->get_start_timer_in_sec() > START_TIMEOUT
      || current_time - request_->get_last_timer_in_sec() > LAST_TIMEOUT) {
      if (request_->timeout())
        return true;
    }
  }
  return false;
}

// Assembly:
cmpq $0x0, 0x38(%rdi)
je 0xe404
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ba38
movq %rax, %r14
movq 0x38(%rbx), %rdi
callq 0xf3f2
movq %r14, %rcx
subq %rax, %rcx
cmpq $0x12c, %rcx            # imm = 0x12C
jg 0xe3e9
movq 0x38(%rbx), %rdi
callq 0xf3fa
subq %rax, %r14
cmpq $0x97, %r14
jl 0xe3fa
movq 0x38(%rbx), %rdi
callq 0xf3ce
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xe3fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::Request()
Request::Request() {
  body_offset_ = 0;
  chunk_size_ = 0;
  status_ = FIRST_LINE;
  protocol_ = "HTTP/1.1";
  gettimeofday(&start_timer_, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x40(%rdi), %r15
movb %al, 0x70(%rdi)
leaq 0x90(%rdi), %rcx
movq %rcx, 0x80(%rdi)
andq $0x0, 0x88(%rdi)
leaq 0x60(%rdi), %r12
movb %al, 0x90(%rdi)
leaq 0xb0(%rdi), %rcx
movq %rcx, 0xa0(%rdi)
andq $0x0, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
leaq 0xc8(%rdi), %rax
andl $0x0, 0xc8(%rdi)
andq $0x0, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
andl $0x0, 0x120(%rdi)
leaq 0x80(%rdi), %rbp
leaq 0xa0(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rdi)
leaq 0xe180(%rip), %rsi      # 0x1c711
movq %rbp, %rdi
callq 0x4830
addq $0xf8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x46d0
movq %rax, (%rsp)
leaq 0xc0(%rbx), %rdi
callq 0xf41c
movq %r13, %rdi
callq 0x4898
movq %rbp, %rdi
callq 0x4898
movq %r12, %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4898
movq %r14, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
movq (%rsp), %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int Request::parse(std::string &buffer) {
  size_t ret = 0;

  gettimeofday(&last_timer_, NULL);

  buffer_ += buffer;
  buffer.clear();

  if (status_ == FIRST_LINE)
    ret = method_line();
  if (status_ == HEADERS)
    ret = headers();
  if (status_ == PREBODY)
    ret = prebody();
  if (status_ == BODY)
    ret = body();
  if (status_ == CHUNK)
    ret = chunk();
  if (status_ == COMPLETE || ret == 1) {
    status_ = COMPLETE;
    return ret;
  }
  else if (status_ == ERROR || ret > 1) {
    status_ = ERROR;
    return ret;
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x108, %rdi            # imm = 0x108
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x46d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4840
andq $0x0, 0x8(%r15)
movq (%r15), %rax
movb $0x0, (%rax)
movl 0x120(%rbx), %eax
testl %eax, %eax
jne 0xe69b
movq %rbx, %rdi
callq 0xe71e
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x1, %eax
jne 0xe6b1
movq %rbx, %rdi
callq 0xe98e
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x2, %eax
jne 0xe6c7
movq %rbx, %rdi
callq 0xec70
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x3, %eax
jne 0xe6dd
movq %rbx, %rdi
callq 0xef7c
movl %eax, %r14d
movl 0x120(%rbx), %eax
cmpl $0x4, %eax
jne 0xe6f3
movq %rbx, %rdi
callq 0xefd6
movl %eax, %r14d
movl 0x120(%rbx), %eax
pushq $0x5
popq %rcx
cmpl $0x5, %eax
je 0xe70f
cmpl $0x1, %r14d
je 0xe70f
pushq $0x6
popq %rcx
cmpl $0x6, %eax
je 0xe70f
cmpl $0x2, %r14d
jb 0xe715
movl %ecx, 0x120(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::body()
int Request::body() {
  if (buffer_.length() >= length_) {
    req_body_.insert(body_offset_, buffer_, 0, length_);
    body_offset_ += buffer_.length();
    buffer_.clear();

    if (req_body_.length() == length_)
      return 1;
    else
      return 400;
  }
  return 0;
}

// Assembly:
movq 0x118(%rdi), %r8
xorl %eax, %eax
cmpq %r8, 0x8(%rdi)
jb 0xefd5
pushq %rbx
movq %rdi, %rbx
addq $0xa0, %rdi
movslq 0xf0(%rbx), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x44c0
movl 0x8(%rbx), %eax
addl %eax, 0xf0(%rbx)
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xa8(%rbx), %rax
cmpq 0x118(%rbx), %rax
pushq $0x1
popq %rcx
movl $0x190, %eax            # imm = 0x190
cmovel %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: check_validity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool check_validity(std::string &uri) {
  int count = 0;

  std::string tmp = uri;

  while (tmp.find('/') != std::string::npos) {
    tmp = tmp.substr(tmp.find('/') + 1);
    if (tmp.empty())
      break;
    std::string tmp2 = tmp.substr(0, tmp.find('/'));

    if (tmp2.find("..", 0) != std::string::npos)
      count--;
    else
      count++;
  }
  return count >= 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x45e0
xorl %r13d, %r13d
pushq $0x2f
popq %rbp
leaq 0x28(%rsp), %r14
pushq $-0x1
popq %r15
leaq 0xd835(%rip), %r12      # 0x1c965
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x45a0
cmpq $-0x1, %rax
je 0xf1bf
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x45a0
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x44a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4560
movq %r14, %rdi
callq 0x4898
cmpq $0x0, 0x10(%rsp)
je 0xf1bf
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x45a0
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x44a0
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4870
xorl %ecx, %ecx
cmpq $-0x1, %rax
sete %cl
leal -0x1(%r13,%rcx,2), %r13d
movq %r14, %rdi
callq 0x4898
jmp 0xf130
testl %r13d, %r13d
setns %bl
leaq 0x8(%rsp), %rdi
callq 0x4898
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf1e2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::chunk_trailer()
int Request::chunk_trailer() {
  size_t end, last;
  std::string header;
  std::string value;

  while ((end = buffer_.find("\r\n")) != std::string::npos) {
    if (buffer_.find("\r\n") == 0) {
      buffer_.erase(0, end + 2);
      break;
    }
    if ((last = buffer_.find(':', 0)) != std::string::npos) {
      header = buffer_.substr(0, last);
      value = buffer_.substr(last + 1, end - last - 1);
      headers_[header] = ft::trim_left(value, ' ');
    }
    else
      return 400;
    buffer_.erase(0, end + 2);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq 0xc0(%rdi), %rax
movq %rax, (%rsp)
leaq 0xd53e(%rip), %r12      # 0x1c77e
leaq 0x68(%rsp), %r13
leaq 0x48(%rsp), %rbx
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4870
cmpq $-0x1, %rax
je 0xf341
movq %rax, %rbp
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4870
testq %rax, %rax
je 0xf346
movq %r14, %rdi
pushq $0x3a
popq %rsi
xorl %edx, %edx
callq 0x45a0
cmpq $-0x1, %rax
je 0xf35c
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x44a0
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4560
movq %r13, %rdi
callq 0x4898
leaq 0x1(%r15), %rdx
notq %r15
addq %rbp, %r15
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x44a0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x4560
movq %r13, %rdi
callq 0x4898
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45e0
movq %r13, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x1b386
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9266
movq %rax, %rdi
movq %r13, %rsi
callq 0x4560
movq %r13, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
addq $0x2, %rbp
movq %r14, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x40a0
jmp 0xf24a
pushq $0x1
popq %rbx
jmp 0xf361
addq $0x2, %rbp
movq %r14, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x40a0
pushq $0x1
popq %rbx
jmp 0xf361
movl $0x190, %ebx            # imm = 0x190
leaq 0x28(%rsp), %rdi
callq 0x4898
leaq 0x8(%rsp), %rdi
callq 0x4898
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf3af
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4898
jmp 0xf39d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4898
jmp 0xf3b2
jmp 0xf3af
jmp 0xf3af
jmp 0xf3af
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4898
leaq 0x8(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::Response(RequestConfig&, int, int)
Response::Response(RequestConfig &config, int worker_id, int error_code) : config_(config), worker_id_(worker_id) {
  error_code_ = error_code;
  status_code_ = 0;
  total_sent_ = 0;
  header_size_ = 0;
  body_size_ = 0;
  redirect_code_ = 0;
  redirect_ = false;
  charset_ = "";
  initMethodMap();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x164bc
movl %r15d, 0xac(%r14)
leaq 0xd0(%r14), %rax
movq %rax, 0xc0(%r14)
andq $0x0, 0xc8(%r14)
xorl %eax, %eax
movb %al, 0xd0(%r14)
leaq 0xf0(%r14), %rcx
movq %rcx, 0xe0(%r14)
andq $0x0, 0xe8(%r14)
movb %al, 0xf0(%r14)
leaq 0x118(%r14), %rcx
movq %rcx, 0x108(%r14)
andq $0x0, 0x110(%r14)
leaq 0xc0(%r14), %r15
movb %al, 0x118(%r14)
leaq 0x150(%r14), %rcx
movq %rcx, 0x140(%r14)
andq $0x0, 0x148(%r14)
movb %al, 0x150(%r14)
leaq 0x168(%r14), %rcx
andl $0x0, 0x168(%r14)
andq $0x0, 0x170(%r14)
movq %rcx, 0x178(%r14)
movq %rcx, 0x180(%r14)
andq $0x0, 0x188(%r14)
leaq 0x198(%r14), %rcx
andl $0x0, 0x198(%r14)
andq $0x0, 0x1a0(%r14)
movq %rcx, 0x1a8(%r14)
movq %rcx, 0x1b0(%r14)
andq $0x0, 0x1b8(%r14)
movl %ebp, 0xa8(%r14)
andl $0x0, 0xb8(%r14)
leaq 0xe0(%r14), %r12
andq $0x0, 0xb0(%r14)
leaq 0x108(%r14), %r13
andl $0x0, 0x128(%r14)
leaq 0x140(%r14), %rbp
movb %al, 0x100(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%r14)
leaq 0xd1b9(%rip), %rsi      # 0x1ca2a
movq %rbp, %rdi
callq 0x4830
movq %r14, %rdi
callq 0xf8e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
leaq 0x190(%r14), %rdi
addq $0x160, %r14            # imm = 0x160
callq 0x778e
movq %r14, %rdi
callq 0x129a2
movq %rbp, %rdi
callq 0x4898
movq %r13, %rdi
callq 0x4898
movq %r12, %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x1668a
movq (%rsp), %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::initMethodMap()
void Response::initMethodMap() {
  methods_["GET"] = &Response::GET;
  methods_["HEAD"] = &Response::GET;
  methods_["POST"] = &Response::POST;
  methods_["PUT"] = &Response::PUT;
  methods_["DELETE"] = &Response::DELETE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xce49(%rip), %rsi      # 0x1c73a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
addq $0x160, %rbx            # imm = 0x160
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12894
leaq 0x1dd(%rip), %r14       # 0xfaf8
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4898
leaq 0xce0a(%rip), %rsi      # 0x1c73e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12894
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4898
leaq 0xcc10(%rip), %rsi      # 0x1c579
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12894
leaq 0x48c(%rip), %rcx       # 0xfe18
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4898
leaq 0xcd91(%rip), %rsi      # 0x1c736
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12894
leaq 0x54a(%rip), %rcx       # 0xff12
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4898
leaq 0xcd62(%rip), %rsi      # 0x1c743
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12894
leaq 0x5ca(%rip), %rcx       # 0xffce
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4898
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xfa2e
jmp 0xfa3d
jmp 0xfa2e
jmp 0xfa3d
jmp 0xfa2e
jmp 0xfa3d
jmp 0xfa2e
jmp 0xfa3d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4898
jmp 0xfa40
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::clear()
void Response::clear() {
  error_code_ = 0;
  status_code_ = 0;
  total_sent_ = 0;
  header_size_ = 0;
  body_size_ = 0;
  redirect_ = false;
  response_.clear();
  body_.clear();
  headers_.clear();
}

// Assembly:
andl $0x0, 0xa8(%rdi)
andl $0x0, 0xb8(%rdi)
andq $0x0, 0xb0(%rdi)
xorl %eax, %eax
movb %al, 0x100(%rdi)
andq $0x0, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rdi)
movq 0xc0(%rdi), %rcx
movb %al, (%rcx)
andq $0x0, 0xe8(%rdi)
movq 0xe0(%rdi), %rcx
movb %al, (%rcx)
addq $0x190, %rdi            # imm = 0x190
jmp 0x12a06
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::POST()
int Response::POST() {
  int status_code = 200;

  body_ = config_.getBody();

  pthread_mutex_lock(&g_write);

  if (!file_.exists()) {
    file_.create(body_);
    status_code = 201;
  }
  else {
    file_.append(body_);
    status_code = 200;
  }

  pthread_mutex_unlock(&g_write);

  headers_["Content-Length"] = ft::to_string(body_.length());
  return status_code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8e44
leaq 0xe0(%rbx), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4240
leaq 0x1b662(%rip), %rdi     # 0x2b4a8
callq 0x4630
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x16fcc
movq %r15, %rdi
movq %r14, %rsi
testb %al, %al
je 0xfe6d
callq 0x16cf4
movl $0xc8, %ebp
jmp 0xfe77
callq 0x16aa2
movl $0xc9, %ebp
leaq 0x1b62a(%rip), %rdi     # 0x2b4a8
callq 0x4350
movq 0xe8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0xddbc
leaq 0xc720(%rip), %rsi      # 0x1c5bb
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5328
addq $0x190, %rbx            # imm = 0x190
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xdd56
leaq 0x28(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4560
leaq 0x8(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4898
jmp 0xfeff
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::PUT()
int Response::PUT() {
  int status_code = 204;

  pthread_mutex_lock(&g_write);

  if (!file_.exists()) {
    file_.create(config_.getBody());
    headers_["Content-Length"] = "0";
    status_code = 201;
  }
  else
    file_.create(config_.getBody());

  pthread_mutex_unlock(&g_write);

  return status_code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1b582(%rip), %rdi     # 0x2b4a8
callq 0x4630
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x16fcc
movl %eax, %r15d
movq (%rbx), %rdi
callq 0x8e44
movq %r14, %rdi
movq %rax, %rsi
callq 0x16aa2
movl $0xcc, %ebp
testb %r15b, %r15b
jne 0xffa0
leaq 0xc65d(%rip), %rsi      # 0x1c5bb
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5328
addq $0x190, %rbx            # imm = 0x190
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdd56
leaq 0xc3a7(%rip), %rsi      # 0x1c330
movq %rax, %rdi
callq 0x4830
leaq 0x8(%rsp), %rdi
callq 0x4898
movl $0xc9, %ebp
leaq 0x1b501(%rip), %rdi     # 0x2b4a8
callq 0x4350
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::DELETE()
int Response::DELETE() {
  if (!file_.exists())
    return 404;

  file_.unlink();

  body_ += "<!DOCTYPE html>\n\
            <html>\n\
            <body>\n\
              <h1>File deleted</h1>\n\
            </body>\n\
            </html>";
  headers_["Content-Type"] = g_mimes.getType(".html");
  headers_["Content-Length"] = ft::to_string(body_.length());
  return 200;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x16fcc
movl %eax, %ecx
movl $0x194, %eax            # imm = 0x194
testb %cl, %cl
je 0x100ed
movq %r14, %rdi
callq 0x16e72
leaq 0xe0(%rbx), %rdi
leaq 0xc885(%rip), %rsi      # 0x1c890
callq 0x4820
leaq 0xc7af(%rip), %rsi      # 0x1c7c6
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x5328
leaq 0x1b53b(%rip), %rsi     # 0x2b568
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1ab78
leaq 0xc587(%rip), %rsi      # 0x1c5ca
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x190(%rbx), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xdd56
leaq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4560
leaq 0x10(%rsp), %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4898
leaq 0x50(%rsp), %rdi
callq 0x4898
movq 0xe8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
callq 0xddbc
leaq 0xc511(%rip), %rsi      # 0x1c5bb
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xdd56
leaq 0x30(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4560
leaq 0x10(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
movl $0xc8, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4898
jmp 0x10109
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x10136
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4898
jmp 0x10122
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4898
jmp 0x10131
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
movq %rax, %rbx
jmp 0x1013b
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::isCGI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Response::isCGI(std::string extension) {
  std::map<std::string, std::string> &cgi = config_.getCGI();

  for (std::map<std::string, std::string>::iterator it = cgi.begin(); it != cgi.end(); it++) {
    if (it->first == extension)
      return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
callq 0x8df2
movq %rax, %r14
movq 0x18(%rax), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x10185
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x91d1
testb %al, %al
jne 0x10185
movq %r15, %rdi
callq 0x42e0
movq %rax, %r15
jmp 0x10163
cmpq %r14, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::checkAuth()
bool Response::checkAuth() {
  if (config_.getHeader("Authorization").empty())
    return false;
  std::string auth_cred = config_.getHeader("Authorization");
  std::string token = ft::b64decode(auth_cred.substr(auth_cred.find(' ') + 1));
  return (token == config_.getAuth());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0xc5a1(%rip), %rsi      # 0x1c74a
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5328
leaq 0x88(%rsp), %rsi
movq %r14, %rdi
callq 0x8e56
movq 0x8(%rax), %r14
leaq 0x88(%rsp), %rdi
callq 0x4898
testq %r14, %r14
je 0x1028f
movq (%rbx), %r14
leaq 0xc55b(%rip), %rsi      # 0x1c74a
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x5328
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x8e56
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x45e0
leaq 0x68(%rsp), %rdi
callq 0x4898
leaq 0x8(%rsp), %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x45a0
leaq 0x1(%rax), %rdx
leaq 0x28(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x44a0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16494
leaq 0x28(%rsp), %rdi
callq 0x4898
movq (%rbx), %rdi
callq 0x8dde
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x91d1
movl %eax, %ebx
movq %r14, %rdi
callq 0x4898
leaq 0x8(%rsp), %rdi
callq 0x4898
jmp 0x10291
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x102b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4898
jmp 0x102ba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x102dd
jmp 0x102d0
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x102dd
movq %rax, %rbx
jmp 0x102e2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::buildMethodList[abi:cxx11]()
std::string Response::buildMethodList() {
  std::vector<std::string> methods = config_.getMethods();
  std::string list;

  std::vector<std::string>::iterator it = methods.begin();

  while (it != methods.end()) {
    list += *it;
    it++;
    if (it != methods.end())
      list += ", ";
  }
  return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x8e3a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6e58
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %r14
leaq 0xbea3(%rip), %r15      # 0x1c825
cmpq 0x10(%rsp), %r14
je 0x109ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4840
addq $0x20, %r14
cmpq 0x10(%rsp), %r14
je 0x10982
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4820
jmp 0x10982
leaq 0x8(%rsp), %rdi
callq 0x608e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4898
leaq 0x8(%rsp), %rdi
callq 0x608e
movq %r14, %rdi
callq 0x4750