LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x189dd(%rip), %rsi     # 0x250a9
callq 0x40f0
testl %eax, %eax
jne 0xc7fc
movq (%r14), %rdi
addq $0x20, %rdi
movq %rdi, (%r14)
leaq 0x189c1(%rip), %rsi     # 0x250ab
callq 0x40f0
testl %eax, %eax
je 0xc753
leaq 0x25dee(%rip), %r15     # 0x324e8
leaq 0x189aa(%rip), %r12     # 0x250ab
movq (%r14), %rsi
movq %r15, %rdi
callq 0xcda8
cmpq $0x0, (%rax)
je 0xc760
movq (%r14), %rsi
movq %r15, %rdi
callq 0xcda8
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0xc734
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
addq $0x20, (%r14)
movq %r14, %rsi
callq *%rcx
movq (%r14), %rdi
addq $0x20, %rdi
movq %rdi, (%r14)
movq %r12, %rsi
callq 0x40f0
testl %eax, %eax
jne 0xc701
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x18c7c(%rip), %rsi     # 0x253f3
leaq 0x20(%rsp), %rdi
callq 0x567a
leaq 0x18c7f(%rip), %rsi     # 0x25407
leaq 0x20(%rsp), %rdi
callq 0x4830
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc7b3
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xc7bf
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x46d0
xorl %ebp, %ebp
movq 0x25803(%rip), %rsi     # 0x31ff0
movq 0x257b4(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4750
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x18bbb(%rip), %rsi     # 0x253cb
movq %rax, %rdi
callq 0x4170
movq 0x257d1(%rip), %rsi     # 0x31ff0
movq 0x25782(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4750
movq %rax, %r14
jmp 0xc87c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc854
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0xc854
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc877
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0xc877
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc884
movq %rbx, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19056(%rip), %rsi     # 0x258ef
callq 0x40f0
movb $0x1, %bpl
testl %eax, %eax
je 0xc8e0
leaq 0x18c9e(%rip), %rsi     # 0x2554a
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
je 0xc8e0
leaq 0x18c87(%rip), %rsi     # 0x25546
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
je 0xc8e0
leaq 0x18c77(%rip), %rsi     # 0x25549
movq %rbx, %rdi
callq 0x40f0
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf27e
callq 0x24ab0
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x1c81c
movq %r14, %rdi
callq 0x1d582
leaq 0x198(%rbx), %rdi
callq 0x82ae
movq %r14, %rdi
callq 0x1c78c
movq 0xd8(%rbx), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0xf2c7
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0xb8(%rbx), %rdi
leaq 0xc8(%rbx), %rax
cmpq %rax, %rdi
je 0xf2e5
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0xf303
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0xf31e
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0xf336
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0xf34e
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0xf36d
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4460
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5783
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10d80
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24b49
movq %rax, %r14
movq 0x38(%rbx), %rdi
callq 0x122f0
movq %r14, %rcx
subq %rax, %rcx
cmpq $0x12c, %rcx            # imm = 0x12C
jg 0x10d65
movq 0x38(%rbx), %rdi
callq 0x122f8
subq %rax, %r14
cmpq $0x97, %r14
jl 0x10d76
movq 0x38(%rbx), %rdi
callq 0x122cc
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10d78
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %r12
movq %r12, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r15
movq %r15, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x80(%rdi), %r14
leaq 0x90(%rdi), %rbp
movq %rbp, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movb %al, 0x90(%rdi)
leaq 0xb0(%rdi), %r13
movq %r13, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
leaq 0xc8(%rdi), %rcx
movl %eax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rcx, 0xe0(%rdi)
movl %eax, 0x120(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rdi)
leaq 0x14868(%rip), %rcx     # 0x25772
movl $0x8, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4680
addq $0xf8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x46c0
movq %r15, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %rax, %r15
leaq 0xc0(%rbx), %rdi
callq 0x12300
movq 0xa0(%rbx), %rdi
cmpq %r13, %rdi
je 0x10f6c
movq (%r13), %rsi
incq %rsi
callq 0x4460
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x10f80
movq (%rbp), %rsi
incq %rsi
callq 0x4460
movq 0x60(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x10f9b
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x40(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x10fb6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x20(%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x10fd1
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x10feb
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq %r15, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x46c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4100
movq $0x0, 0x8(%r15)
movq (%r15), %rax
movb $0x0, (%rax)
cmpl $0x0, 0x120(%rbx)
jne 0x110ef
movq %rbx, %rdi
callq 0x11174
movl %eax, %r14d
cmpl $0x1, 0x120(%rbx)
jne 0x11103
movq %rbx, %rdi
callq 0x11470
movl %eax, %r14d
cmpl $0x2, 0x120(%rbx)
jne 0x11117
movq %rbx, %rdi
callq 0x11864
movl %eax, %r14d
cmpl $0x3, 0x120(%rbx)
jne 0x1112b
movq %rbx, %rdi
callq 0x11cb6
movl %eax, %r14d
cmpl $0x4, 0x120(%rbx)
jne 0x1113f
movq %rbx, %rdi
callq 0x11d16
movl %eax, %r14d
movl 0x120(%rbx), %ecx
movl $0x5, %eax
cmpl $0x5, %ecx
je 0x11165
cmpl $0x1, %r14d
je 0x11165
movl $0x6, %eax
cmpl $0x6, %ecx
je 0x11165
cmpl $0x2, %r14d
jb 0x1116b
movl %eax, 0x120(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11d14
pushq %rbx
movq %rdi, %rbx
addq $0xa0, %rdi
movslq 0xf0(%rbx), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x44a0
movl 0x8(%rbx), %eax
addl %eax, 0xf0(%rbx)
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xa8(%rbx), %rax
cmpq 0x118(%rbx), %rax
movl $0x1, %ecx
movl $0x190, %eax            # imm = 0x190
cmovel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::chunk()
int Request::chunk() {
  size_t end;

  while ((end = buffer_.find("\r\n")) != std::string::npos) {
    if (chunk_status_ == CHUNK_SIZE) {
      std::string hex = buffer_.substr(0, end);
      chunk_size_ = ft::to_hex(hex);
      buffer_.erase(0, end + 2);
      chunk_status_ = CHUNK_BODY;
    } else if (chunk_status_ == CHUNK_BODY) {
      if (chunk_size_ == 0) {
        if (!buffer_.empty())
          return chunk_trailer();
        return 1;
      }
      req_body_ += buffer_.substr(0, end);
      buffer_.erase(0, end + 2);
      chunk_size_ = 0;
      chunk_status_ = CHUNK_SIZE;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x13ab1(%rip), %rsi     # 0x257df
xorl %ebp, %ebp
movl $0x2, %ecx
xorl %edx, %edx
callq 0x4770
cmpq $-0x1, %rax
je 0x11e57
movq %rax, %r13
leaq 0xa0(%rbx), %r14
leaq 0x8(%rsp), %r15
leaq 0x13a83(%rip), %r12     # 0x257df
movl 0x124(%rbx), %eax
testl %eax, %eax
je 0x11dc6
cmpl $0x1, %eax
jne 0x11e36
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4480
movq %r15, %rdi
callq 0x24368
movl %eax, 0xf4(%rbx)
addq $0x2, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x40b0
movl $0x0, 0x124(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11e36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x11e36
cmpl $0x0, 0xf4(%rbx)
je 0x11e68
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4480
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x4100
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11e11
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
addq $0x2, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x40b0
movl $0x0, 0xf4(%rbx)
movl $0x1, 0x124(%rbx)
xorl %ebp, %ebp
movl $0x2, %ecx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4770
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x11d5c
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
je 0x11e7b
movq %rbx, %rdi
callq 0x1202c
movl %eax, %ebp
jmp 0x11e57
movl $0x1, %ebp
jmp 0x11e57
jmp 0x11e84
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11ea3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1c51c
movl %r15d, 0xac(%r14)
leaq 0xd0(%r14), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0xc0(%r14)
xorl %eax, %eax
movq %rax, 0xc8(%r14)
movb %al, 0xd0(%r14)
leaq 0xf0(%r14), %r13
movq %r13, 0xe0(%r14)
movq %rax, 0xe8(%r14)
movb %al, 0xf0(%r14)
leaq 0x118(%r14), %rbx
movq %rbx, 0x108(%r14)
movq %rax, 0x110(%r14)
movb %al, 0x118(%r14)
leaq 0x140(%r14), %r12
leaq 0x150(%r14), %r15
movq %r15, 0x140(%r14)
movq %rax, 0x148(%r14)
movb %al, 0x150(%r14)
leaq 0x160(%r14), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x168(%r14), %rcx
movl %eax, 0x168(%r14)
movq %rax, 0x170(%r14)
movq %rcx, 0x178(%r14)
movq %rcx, 0x180(%r14)
movq %rax, 0x188(%r14)
leaq 0x190(%r14), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x198(%r14), %rcx
movl %eax, 0x198(%r14)
movq %rax, 0x1a0(%r14)
movq %rcx, 0x1a8(%r14)
movq %rcx, 0x1b0(%r14)
movq %rax, 0x1b8(%r14)
movl %ebp, 0xa8(%r14)
movl %eax, 0xb8(%r14)
movq %rax, 0xb0(%r14)
movl %eax, 0x128(%r14)
movb %al, 0x100(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%r14)
leaq 0x13357(%rip), %rcx     # 0x25a78
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x4680
movq %r14, %rdi
callq 0x127d2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq 0x10(%rsp), %rdi
callq 0x82ae
movq 0x18(%rsp), %rdi
callq 0x17c40
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x12772
movq (%r15), %rsi
incq %rsi
callq 0x4460
movq 0x108(%r14), %rdi
cmpq %rbx, %rdi
je 0x12789
movq (%rbx), %rsi
incq %rsi
callq 0x4460
movq 0xe0(%r14), %rdi
cmpq %r13, %rdi
je 0x127a1
movq (%r13), %rsi
incq %rsi
callq 0x4460
movq 0xc0(%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x127bf
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4460
movq 0x20(%rsp), %rdi
callq 0x1c78c
movq %rbp, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12fad(%rip), %rsi     # 0x2579b
leaq 0x12fa9(%rip), %rdx     # 0x2579e
movq %rsp, %rdi
callq 0x578e
addq $0x160, %rbx            # imm = 0x160
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17aee
leaq 0x27e(%rip), %r15       # 0x12a94
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12837
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12f5b(%rip), %rsi     # 0x2579f
leaq 0x12f58(%rip), %rdx     # 0x257a3
callq 0x578e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17aee
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1287c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12d06(%rip), %rsi     # 0x2558f
leaq 0x12d03(%rip), %rdx     # 0x25593
callq 0x578e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17aee
leaq 0x6d5(%rip), %rcx       # 0x12f7c
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x128c8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12ec2(%rip), %rsi     # 0x25797
leaq 0x12ebe(%rip), %rdx     # 0x2579a
callq 0x578e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17aee
leaq 0x7c1(%rip), %rcx       # 0x130b4
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12914
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x12e83(%rip), %rsi     # 0x257a4
leaq 0x12e82(%rip), %rdx     # 0x257aa
callq 0x578e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17aee
leaq 0x863(%rip), %rcx       # 0x131a2
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12960
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1297a
jmp 0x12995
jmp 0x1297a
jmp 0x12995
jmp 0x1297a
jmp 0x12995
jmp 0x1297a
jmp 0x12995
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x12998
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x12998
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, 0xa8(%rdi)
movl %eax, 0xb8(%rdi)
movq %rax, 0xb0(%rdi)
movb %al, 0x100(%rdi)
movq %rax, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rdi)
movq 0xc0(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0xe8(%rdi)
movq 0xe0(%rdi), %rcx
movb %al, (%rcx)
addq $0x190, %rdi            # imm = 0x190
jmp 0x17cb8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x9efa
leaq 0xe0(%r14), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4230
leaq 0x1f4ef(%rip), %rdi     # 0x32498
callq 0x4600
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x1d880
movq %r15, %rdi
movq %rbx, %rsi
testb %al, %al
je 0x12fd0
callq 0x1d270
movl $0xc8, %ebx
jmp 0x12fda
callq 0x1cd54
movl $0xc9, %ebx
leaq 0x1f4b7(%rip), %rdi     # 0x32498
callq 0x4340
movq 0xe8(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x10556
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x125ca(%rip), %rsi     # 0x255d1
leaq 0x125d1(%rip), %rdx     # 0x255df
movq %rsp, %rdi
callq 0x578e
addq $0x190, %r14            # imm = 0x190
movq %rsp, %rsi
movq %r14, %rdi
callq 0x104da
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4560
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1304b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13066
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x13090
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x13090
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x130ab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f3d0(%rip), %rdi     # 0x32498
callq 0x4600
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x1d880
movl %eax, %r15d
movq (%rbx), %rdi
callq 0x9efa
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cd54
movl $0xcc, %ebp
testb %r15b, %r15b
jne 0x13166
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x124c8(%rip), %rsi     # 0x255d1
leaq 0x124cf(%rip), %rdx     # 0x255df
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x578e
addq $0x190, %rbx            # imm = 0x190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x104da
movq 0x8(%rax), %rdx
leaq 0x1220c(%rip), %rcx     # 0x25346
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x4680
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x13161
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movl $0xc9, %ebp
leaq 0x1f32b(%rip), %rdi     # 0x32498
callq 0x4340
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x13199
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1d880
movl %eax, %ecx
movl $0x194, %eax            # imm = 0x194
testb %cl, %cl
je 0x1331a
movq %r14, %rdi
callq 0x1d582
leaq 0xe0(%rbx), %rdi
leaq 0x1270e(%rip), %rsi     # 0x258f1
callq 0x4830
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1262f(%rip), %rsi     # 0x25827
leaq 0x1262d(%rip), %rdx     # 0x2582c
leaq 0x40(%rsp), %rdi
callq 0x578e
leaq 0x1f348(%rip), %rsi     # 0x32558
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x237e0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x123b0(%rip), %rsi     # 0x255e0
leaq 0x123b5(%rip), %rdx     # 0x255ec
movq %rsp, %rdi
callq 0x578e
leaq 0x190(%rbx), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x104da
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4560
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13274
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0x30(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1328f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x132a6
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4460
movq 0xe8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x10556
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1230d(%rip), %rsi     # 0x255d1
leaq 0x12314(%rip), %rdx     # 0x255df
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x104da
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4560
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x132fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x13315
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
movl $0xc8, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13346
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x13346
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x133b1
movq 0x30(%rsp), %rsi
jmp 0x133a4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13375
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x13375
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13395
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x13395
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x133b1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x133b1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
callq 0x9ea8
movq %rax, %r14
movq 0x18(%rax), %r15
addq $0x8, %r14
cmpq %r14, %r15
setne %bpl
je 0x13417
movq 0x8(%rbx), %r12
movq 0x28(%r15), %rdx
cmpq %r12, %rdx
jne 0x13403
testq %rdx, %rdx
je 0x13417
movq (%rbx), %rsi
movq 0x20(%r15), %rdi
callq 0x4470
testl %eax, %eax
je 0x13417
movq %r15, %rdi
callq 0x42d0
movq %rax, %r15
cmpq %r14, %rax
setne %bpl
jne 0x133e5
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1235d(%rip), %rsi     # 0x257ab
leaq 0x12363(%rip), %rdx     # 0x257b8
leaq 0x88(%rsp), %r15
movq %r15, %rdi
callq 0x578e
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f0c
movq 0x8(%rax), %r14
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x13491
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x4460
testq %r14, %r14
je 0x13582
movq (%rbx), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x122fd(%rip), %rsi     # 0x257ab
leaq 0x12303(%rip), %rdx     # 0x257b8
leaq 0x28(%rsp), %rdi
callq 0x578e
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x9f0c
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x6bac
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x13500
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x4580
leaq 0x1(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4480
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1c4f2
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13556
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4460
movq (%rbx), %rdi
callq 0x9e94
movq 0x10(%rsp), %rdx
cmpq 0x8(%rax), %rdx
jne 0x13586
testq %rdx, %rdx
je 0x1358a
movq (%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x4470
testl %eax, %eax
sete %bl
jmp 0x1358c
xorl %ebx, %ebx
jmp 0x135be
xorl %ebx, %ebx
jmp 0x1358c
movb $0x1, %bl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x135a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x135be
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4460
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1360a
movq 0x18(%rsp), %rsi
jmp 0x135fd
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1360a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x1360a
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13654
movq 0x58(%rsp), %rsi
jmp 0x1364c
movq %rax, %rbx
jmp 0x13654
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x13654
movq 0x98(%rsp), %rsi
jmp 0x1364c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x13654
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x9ef0
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x799c
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x14337
leaq 0x1157d(%rip), %r14     # 0x25886
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x4100
addq $0x20, %r12
cmpq 0x8(%rsp), %r12
je 0x14330
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4830
cmpq 0x8(%rsp), %r12
jne 0x14309
movq %rsp, %rdi
callq 0x69ba
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x14364
movq (%r15), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
callq 0x69ba
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Response.cpp
// Function: Response::send(int)
int Response::send(int fd) {
  int ret = ::send(fd, response_.c_str() + total_sent_, response_.length() - total_sent_, 0);

  if (ret <= 0) {
    std::cout << "send : " << strerror(errno) << std::endl;
    return -1;
  }
  total_sent_ += ret;
  if (total_sent_ >= response_.length())
    return 0;
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movq 0xb0(%rdi), %rcx
movq 0xc8(%rdi), %rdx
movq 0xc0(%rdi), %rsi
addq %rcx, %rsi
subq %rcx, %rdx
movl %eax, %edi
xorl %ecx, %ecx
callq 0x41e0
testl %eax, %eax
jle 0x17013
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq 0xb0(%rbx), %rax
movq %rax, 0xb0(%rbx)
xorl %ecx, %ecx
cmpq 0xc8(%rbx), %rax
setb %cl
jmp 0x170a1
movq 0x1af9e(%rip), %rbx     # 0x31fb8
leaq 0xe987(%rip), %rsi      # 0x259a8
movl $0x7, %edx
movq %rbx, %rdi
callq 0x44d0
callq 0x4050
movl (%rax), %edi
callq 0x4140
testq %rax, %rax
je 0x1705e
movq %rax, %r14
movq %rax, %rdi
callq 0x4190
movq 0x1af67(%rip), %rdi     # 0x31fb8
movq %r14, %rsi
movq %rax, %rdx
callq 0x44d0
jmp 0x17075
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x4730
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4420
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x42b0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Server.cpp
// Function: Server::operator=(Server const&)
Server	&Server::operator=(const Server &copy) {
  servers_ = copy.servers_;
  options_ = copy.options_;
  running_server_ = copy.running_server_;
  clients_ = copy.clients_;
  master_fds_ = copy.master_fds_;
  fd_set_ = copy.fd_set_;
  max_fd_ = copy.max_fd_;
  return (*this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x8(%rdi), %rdi
callq 0x1a8e0
movq 0x10(%r14), %r15
movq 0x10(%rbx), %r12
movups (%r15), %xmm0
movups %xmm0, (%r12)
leaq 0x10(%r12), %rdi
leaq 0x10(%r15), %rsi
callq 0x4230
movl 0x30(%r15), %eax
movl %eax, 0x30(%r12)
addq $0x38, %r12
addq $0x38, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1b002
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x1b332
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x1b668
leaq 0x78(%r14), %rsi
leaq 0x78(%rbx), %rdi
movl $0x10, %ecx
rep  movsq (%rsi), %es:(%rdi)
cmpq %r14, %rbx
je 0x18469
movl $0x1f8, %edi            # imm = 0x1F8
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x1f8(%r14), %rsi
callq 0x1ba00
movl 0x210(%r14), %eax
movl %eax, 0x210(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Server.cpp
// Function: Server::add_to_fd_set(int)
void Server::add_to_fd_set(int fd) {
  fd_set_.push_back(fd);
  fd_set_.sort();

  FD_SET(fd, &master_fds_);

  if (fd > max_fd_)
    max_fd_ = fd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1f8(%rdi), %r15
movl $0x18, %edi
callq 0x4430
movl %ebx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4060
incq 0x208(%r14)
movq %r15, %rdi
callq 0x1aca4
leal 0x3f(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %ebx, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x78(%r14,%rax,8)
cmpl %ebx, 0x210(%r14)
jge 0x192a9
movl %ebx, 0x210(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Server.cpp
// Function: Server::clientDisconnect(int)
void Server::clientDisconnect(int fd) {
  remove_from_fd_set(fd);
  if (clients_.find(fd) != clients_.end()) {
    Log.print(INFO, head_ + "connection closed", GREEN);
    delete clients_[fd];
    clients_.erase(fd);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
callq 0x19a32
movq 0x58(%rbx), %rdx
leaq 0x50(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x198df
movl 0xc(%rsp), %esi
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x198c8
movq %rax, %rdx
cmpq %rax, %rcx
je 0x198f5
movl 0xc(%rsp), %edx
cmpl 0x20(%rcx), %edx
cmovlq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x199e7
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6bac
leaq 0xc0fc(%rip), %rsi      # 0x25a28
movq %r14, %rdi
callq 0x4830
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc0cb(%rip), %rsi      # 0x25a0f
leaq 0xc0c9(%rip), %rdx      # 0x25a14
leaq 0x30(%rsp), %rdi
callq 0x578e
leaq 0x18b7c(%rip), %rdi     # 0x324d8
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movl $0x1, %esi
xorl %r8d, %r8d
callq 0x20fae
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x1998a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4460
addq $0x48, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x199a5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac40
movq (%rax), %r14
testq %r14, %r14
je 0x199cf
movq %r14, %rdi
callq 0x10850
movl $0x50, %esi
movq %r14, %rdi
callq 0x4460
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c1ea
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c262
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x19a12
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x19a12
jmp 0x19a0f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x19a29
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Server.cpp
// Function: Server::remove_from_fd_set(int)
void Server::remove_from_fd_set(int fd) {
  for (std::list<int>::iterator it = fd_set_.begin(); it != fd_set_.end(); it++) {
    if (*it == fd) {
      fd_set_.erase(it);
      break ;
    }
  }

  FD_CLR(fd, &master_fds_);

  if (fd == max_fd_)
    max_fd_ = *fd_set_.rbegin();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x1f8(%rdi), %rax
movq %rax, %r15
movq (%r15), %r15
cmpq %rax, %r15
je 0x19a71
cmpl %r14d, 0x10(%r15)
jne 0x19a47
decq 0x208(%rbx)
movq %r15, %rdi
callq 0x4700
movl $0x18, %esi
movq %r15, %rdi
callq 0x4460
movq $-0x2, %rax
movl %r14d, %ecx
rolq %cl, %rax
leal 0x3f(%r14), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
andq %rax, 0x78(%rbx,%rcx,8)
cmpl %r14d, 0x210(%rbx)
jne 0x19aad
movq 0x200(%rbx), %rax
movl 0x10(%rax), %eax
movl %eax, 0x210(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/HTTP/Server.cpp
// Function: Server::check_timeout_disconnect(Client*)
void Server::check_timeout_disconnect(Client *client) {
  if (client->timeout()) {
    client->setupResponse(servers_, options_, 408);
  }

  if (client->disconnect()) {
    client->setupResponse(servers_, options_, 503);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x10d22
testb %al, %al
je 0x1a19b
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl $0x198, %ecx            # imm = 0x198
callq 0x10924
movq %rbx, %rdi
callq 0x10d84
testb %al, %al
je 0x1a1c3
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl $0x1f7, %ecx            # imm = 0x1F7
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10924
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/Base64.cpp
// Function: ft::b64decode[abi:cxx11](void const*, unsigned long const&)
const std::string b64decode(const void *data, const size_t &len) {
    if (len == 0) return "";

    unsigned char *p = (unsigned char*)data;
    size_t j = 0,
      pad1 = len % 4 || p[len - 1] == '=',
      pad2 = pad1 && (len % 4 > 2 || p[len - 2] != '=');
    const size_t last = (len - pad1) / 4 << 2;
    std::string result(last / 4 * 3 + pad1 + pad2, '\0');
    unsigned char *str = (unsigned char*) &result[0];

    for (size_t i = 0; i < last; i += 4) {
      int n = ft::B64index[p[i]] << 18 | ft::B64index[p[i + 1]] << 12 | ft::B64index[p[i + 2]] << 6 | ft::B64index[p[i + 3]];
      str[j++] = n >> 16;
      str[j++] = n >> 8 & 0xFF;
      str[j++] = n & 0xFF;
    }
    if (pad1) {
      int n = ft::B64index[p[last]] << 18 | ft::B64index[p[last + 1]] << 12;
      str[j++] = n >> 16;
      if (pad2) {
        n |= ft::B64index[p[last + 2]] << 6;
        str[j++] = n >> 8 & 0xFF;
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movq (%rdx), %r15
testq %r15, %r15
je 0x1c3e8
movq %rsi, %r14
movq %r15, %rax
movb $0x1, %cl
andq $0x3, %rax
jne 0x1c3cd
cmpb $0x3d, -0x1(%r14,%r15)
sete %cl
movzbl %cl, %r12d
testb %r12b, %r12b
je 0x1c407
movb $0x1, %cl
cmpl $0x3, %eax
je 0x1c409
cmpb $0x3d, -0x2(%r14,%r15)
setne %cl
jmp 0x1c409
leaq 0x10(%r13), %rax
movq %rax, (%r13)
leaq 0x9681(%rip), %rdx      # 0x25a78
movq %r13, %rdi
movq %rdx, %rsi
callq 0x578e
jmp 0x1c4e0
xorl %ecx, %ecx
movl %ecx, 0x4(%rsp)
movzbl %cl, %esi
subq %r12, %r15
movq %r15, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rax
addq %r12, %rsi
addq %rax, %rsi
leaq 0x10(%r13), %rax
movq %rax, (%r13)
xorl %ebp, %ebp
movq %r13, %rdi
xorl %edx, %edx
callq 0x4500
movq (%r13), %rax
andq $-0x4, %r15
je 0x1c49b
xorl %ecx, %ecx
leaq 0x9635(%rip), %rdx      # 0x25a80
xorl %ebp, %ebp
movzbl (%r14,%rcx), %esi
movl (%rdx,%rsi,4), %esi
shll $0x12, %esi
movzbl 0x1(%r14,%rcx), %edi
movl (%rdx,%rdi,4), %edi
shll $0xc, %edi
orl %esi, %edi
movzbl 0x2(%r14,%rcx), %esi
movl (%rdx,%rsi,4), %ebx
shll $0x6, %ebx
orl %edi, %ebx
movzbl 0x3(%r14,%rcx), %esi
orl (%rdx,%rsi,4), %ebx
movl %ebx, %esi
shrl $0x10, %esi
movb %sil, (%rax,%rbp)
movb %bh, 0x1(%rax,%rbp)
movb %bl, 0x2(%rax,%rbp)
addq $0x3, %rbp
addq $0x4, %rcx
cmpq %r15, %rcx
jb 0x1c44d
testq %r12, %r12
je 0x1c4e0
movzbl (%r14,%r15), %edx
leaq 0x95d4(%rip), %rcx      # 0x25a80
movl (%rcx,%rdx,4), %esi
shll $0x12, %esi
movzbl 0x1(%r14,%r15), %edx
movl (%rcx,%rdx,4), %edx
shll $0xc, %edx
orl %edx, %esi
shrl $0x10, %esi
movb %sil, (%rax,%rbp)
cmpb $0x0, 0x4(%rsp)
je 0x1c4e0
movzbl 0x2(%r14,%r15), %esi
movl (%rcx,%rsi,4), %ecx
shll $0x6, %ecx
orl %edx, %ecx
movb %ch, 0x1(%rax,%rbp)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::set_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void File::set_path(std::string path, bool negociation) {
  path_ = ft::unique_char(path);

  if (negociation)
    parseExtensionsNegociation();
  else
    parseExtensions();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6bac
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x24444
leaq 0x80(%rbx), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x4560
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1c733
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4460
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c74a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
testb %bpl, %bpl
je 0x1c759
callq 0x1c834
jmp 0x1c75e
callq 0x1cb5c
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c783
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::close()
void File::close() {
  if (fd_ <= 0)
    return ;

  ::close(fd_);
  fd_ = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
jle 0x1c831
callq 0x4840
movl $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::parseExtensions()
void File::parseExtensions() {
  std::string file = path_.substr(path_.find_last_of("/") + 1);

  if (file.empty())
    return;

  file_name_full_ = file;

  file_name_ = file.substr(0, file.find("."));
  file.erase(0, file.find("."));
  if (file.find_last_of(".") != std::string::npos) {
    int last = file.find_last_of(".");
    mime_ext_ = file.substr(last);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
leaq 0x8a1e(%rip), %rsi      # 0x25594
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x4860
leaq 0x1(%rax), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4480
cmpq $0x0, 0x8(%r15)
je 0x1ccb5
leaq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x4230
leaq 0x8e06(%rip), %rsi      # 0x259c7
movq %rsp, %r14
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4770
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4480
leaq 0x8(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x4560
movq (%r14), %rdi
leaq 0x30(%rsp), %r15
cmpq %r15, %rdi
je 0x1cc10
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0x8db0(%rip), %rsi      # 0x259c7
movq %rsp, %r14
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4770
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40b0
leaq 0x8d8a(%rip), %rsi      # 0x259c7
movq %rsp, %rdi
movl $0x1, %ecx
movq $-0x1, %rdx
callq 0x4860
cmpq $-0x1, %rax
je 0x1ccb5
leaq 0x8d69(%rip), %rsi      # 0x259c7
movq %rsp, %r14
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x4860
movslq %eax, %rdx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4480
addq $0x48, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4560
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1ccb5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4460
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ccd0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ccde
jmp 0x1ccde
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ccfc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::open(bool)
bool File::open(bool create) {
  close();

  if (create)
    fd_ = ::open(path_.c_str(), O_CREAT | O_RDWR | O_TRUNC, 00755);
  else
    fd_ = ::open(path_.c_str(), O_RDONLY);
  return fd_ > 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
jle 0x1cd1d
callq 0x4840
movl $0x0, (%rbx)
movq 0x80(%rbx), %rdi
testb %bpl, %bpl
je 0x1cd3c
movl $0x242, %esi            # imm = 0x242
movl $0x1ed, %edx            # imm = 0x1ED
xorl %eax, %eax
callq 0x4310
jmp 0x1cd45
xorl %esi, %esi
xorl %eax, %eax
callq 0x4310
movl %eax, (%rbx)
testl %eax, %eax
setg %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: set_width(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string set_width(size_t width, std::string str) {
  size_t len = str.length();
  std::string w;

  if (len > width)
    width = 0;

  for (size_t i = 0; i < width - len; i++) {
    w += " ";
  }
  w += str;
  return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rax
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rsi, %rax
cmovaq %rcx, %r15
subq %rax, %r15
je 0x1d8ef
leaq 0x7fa8(%rip), %r12      # 0x25887
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4830
decq %r15
jne 0x1d8df
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x4100
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1d90d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x1d924
movq (%r13), %rsi
incq %rsi
callq 0x4460
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: sort_auto_listing(auto_listing, auto_listing)
bool sort_auto_listing(auto_listing i, auto_listing j) {
  if (i.is_dir_ && j.is_dir_) {
    return (i.name_ < j.name_);
  } else if (!i.is_dir_ && !j.is_dir_)
    return (i.name_ < j.name_);
  return (i.is_dir_ > j.is_dir_);
}

// Assembly:
pushq %rax
movb 0x20(%rdi), %al
cmpb $0x1, %al
jne 0x1d945
cmpb $0x1, 0x20(%rsi)
jne 0x1d941
callq 0x4040
jmp 0x1d958
testb %al, %al
jne 0x1d94b
cmpb $0x0, 0x20(%rsi)
je 0x1d953
cmpb 0x20(%rsi), %al
seta %al
jmp 0x1d95b
callq 0x4040
shrl $0x1f, %eax
popq %rcx
retq
jmp 0x1d95f
movq %rax, %rdi
callq 0x5783
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::last_modified[abi:cxx11]()
std::string File::last_modified() {
  struct stat statbuf;
  struct tm	*tm;
  char buf[32];

  stat(path_.c_str(), &statbuf);
  tm = gmtime(&statbuf.st_mtime);
  int ret = strftime(buf, 32, "%a, %d %b %Y %T GMT", tm);
  return std::string(buf, ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq 0x80(%rsi), %rdi
leaq 0x28(%rsp), %rsi
callq 0x43d0
leaq 0x80(%rsp), %rdi
callq 0x4390
leaq 0x7689(%rip), %rdx      # 0x25f0d
movq %rsp, %r14
movl $0x20, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x4370
cltq
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x578e
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
nop