LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
leaq 0x20439(%rip), %rsi     # 0x437bb
xorl %eax, %eax
movl %eax, %edx
callq 0x5a70
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x234f8
movq -0x70(%rbp), %rax
cmpl $0x1, 0x124(%rax)
jne 0x23425
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x55a0
movq -0x80(%rbp), %rdi
callq 0x41610
movq %rax, -0x78(%rbp)
jmp 0x233ce
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movl %eax, 0xf4(%rdi)
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x50d0
jmp 0x233ef
movq -0x70(%rbp), %rax
movl $0x0, 0x124(%rax)
leaq -0x38(%rbp), %rdi
callq 0x5aa8
jmp 0x234f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5aa8
jmp 0x2350b
movq -0x70(%rbp), %rax
cmpl $0x0, 0x124(%rax)
jne 0x234f1
movq -0x70(%rbp), %rax
cmpl $0x0, 0xf4(%rax)
jne 0x2346d
movq -0x70(%rbp), %rdi
callq 0x5900
testb $0x1, %al
jne 0x23461
movq -0x70(%rbp), %rdi
callq 0x23690
movl %eax, -0x4(%rbp)
jmp 0x234ff
movl $0x1, -0x4(%rbp)
jmp 0x234ff
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x55a0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
addq $0xa0, %rdi
callq 0x5710
jmp 0x234a2
leaq -0x68(%rbp), %rdi
callq 0x5aa8
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x50d0
movq -0x70(%rbp), %rax
movl $0x0, 0xf4(%rax)
movl $0x1, 0x124(%rax)
jmp 0x234f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5aa8
jmp 0x2350b
jmp 0x234f3
jmp 0x23377
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5200
leaq -0x30(%rbp), %rdi
movl $0x2f, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5730
cmpq $-0x1, %rax
je 0x23653
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x2f, %esi
callq 0x5730
movq -0x88(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0x50(%rbp), %rdi
movq $-0x1, %rcx
callq 0x55a0
jmp 0x23597
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x56d0
leaq -0x50(%rbp), %rdi
callq 0x5aa8
leaq -0x30(%rbp), %rdi
callq 0x5900
testb $0x1, %al
jne 0x235bc
jmp 0x235db
jmp 0x23653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5aa8
jmp 0x2367a
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x2f, %esi
callq 0x5730
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, %rcx
leaq -0x80(%rbp), %rdi
callq 0x55a0
jmp 0x23617
leaq -0x80(%rbp), %rdi
leaq 0x20380(%rip), %rsi     # 0x439a2
xorl %eax, %eax
movl %eax, %edx
callq 0x5a70
cmpq $-0x1, %rax
je 0x2363c
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23645
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5aa8
jmp 0x23543
cmpl $0x0, -0xc(%rbp)
setge %al
movb %al, -0x99(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5aa8
movb -0x99(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: solaldunckel[P]webserv/srcs/HTTP/Request.cpp
// Function: Request::timeout()
bool Request::timeout() {
  if (status_ != COMPLETE) {
    status_ = ERROR;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x5, 0x120(%rax)
je 0x2393d
movq -0x18(%rbp), %rax
movl $0x6, 0x120(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x23941
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x356d0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0xac(%rdi)
addq $0xc0, %rdi
movq %rdi, -0x60(%rbp)
callq 0x57b0
movq -0x38(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x57b0
movq -0x38(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x50(%rbp)
callq 0x57b0
movq -0x38(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x30(%rbp)
callq 0x57b0
movq -0x38(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, -0x48(%rbp)
callq 0x29de0
movq -0x38(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
movq %rdi, -0x40(%rbp)
callq 0x18820
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl %ecx, 0xa8(%rax)
movl $0x0, 0xb8(%rax)
movq $0x0, 0xb0(%rax)
movq $0x0, 0x130(%rax)
movq $0x0, 0x138(%rax)
movl $0x0, 0x128(%rax)
movb $0x0, 0x100(%rax)
leaq 0x1f63d(%rip), %rsi     # 0x43a54
callq 0x5780
jmp 0x2441e
movq -0x38(%rbp), %rdi
callq 0x24490
jmp 0x24429
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xc420
movq -0x48(%rbp), %rdi
callq 0x29e00
movq -0x30(%rbp), %rdi
callq 0x5aa8
movq -0x50(%rbp), %rdi
callq 0x5aa8
movq -0x58(%rbp), %rdi
callq 0x5aa8
movq -0x60(%rbp), %rdi
callq 0x5aa8
movq -0x68(%rbp), %rdi
callq 0x358f0
movq -0x20(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0xa8(%rdi)
movl $0x0, 0xb8(%rdi)
movq $0x0, 0xb0(%rdi)
movq $0x0, 0x130(%rdi)
movq $0x0, 0x138(%rdi)
movb $0x0, 0x100(%rdi)
addq $0xc0, %rdi
callq 0x5740
movq -0x10(%rbp), %rdi
addq $0xe0, %rdi
callq 0x5740
movq -0x10(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x29e20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0xc8, -0xc(%rbp)
movq (%rax), %rdi
callq 0x13010
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0xe0, %rdi
callq 0x5050
leaq 0x37538(%rip), %rdi     # 0x5c5b8
callq 0x5800
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x36950
testb $0x1, %al
jne 0x250b6
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0xe0, %rsi
callq 0x35f70
movl $0xc9, -0xc(%rbp)
jmp 0x250d4
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0xe0, %rsi
callq 0x36430
movl $0xc8, -0xc(%rbp)
leaq 0x374dd(%rip), %rdi     # 0x5c5b8
callq 0x53f0
movq -0x70(%rbp), %rdi
addq $0xe0, %rdi
callq 0x5830
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x20f10
movq -0x70(%rbp), %rax
addq $0x190, %rax            # imm = 0x190
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5960
movq -0x78(%rbp), %rdx
leaq 0x1e4be(%rip), %rsi     # 0x435e0
leaq -0x50(%rbp), %rdi
callq 0x6be0
jmp 0x2512d
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x20e30
movq %rax, -0x88(%rbp)
jmp 0x25143
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x56d0
leaq -0x50(%rbp), %rdi
callq 0x5aa8
leaq -0x51(%rbp), %rdi
callq 0x55e0
leaq -0x30(%rbp), %rdi
callq 0x5aa8
movl -0xc(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2519d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5aa8
leaq -0x51(%rbp), %rdi
callq 0x55e0
leaq -0x30(%rbp), %rdi
callq 0x5aa8
movq -0x60(%rbp), %rdi
callq 0x5950
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0xcc, -0xc(%rbp)
leaq 0x373d3(%rip), %rdi     # 0x5c5b8
callq 0x5800
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x36950
testb $0x1, %al
jne 0x252c1
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
callq 0x13010
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x35f70
movq -0x50(%rbp), %rax
addq $0x190, %rax            # imm = 0x190
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5960
movq -0x58(%rbp), %rdx
leaq 0x1e398(%rip), %rsi     # 0x435e0
leaq -0x30(%rbp), %rdi
callq 0x6be0
jmp 0x25253
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20e30
movq %rax, -0x70(%rbp)
jmp 0x25266
movq -0x70(%rbp), %rdi
leaq 0x1e0d1(%rip), %rsi     # 0x43342
callq 0x5780
jmp 0x25278
leaq -0x30(%rbp), %rdi
callq 0x5aa8
leaq -0x31(%rbp), %rdi
callq 0x55e0
movl $0xc9, -0xc(%rbp)
jmp 0x252e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x252b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5aa8
leaq -0x31(%rbp), %rdi
callq 0x55e0
jmp 0x252fc
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x78(%rbp)
movq (%rax), %rdi
callq 0x13010
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x35f70
leaq 0x372cd(%rip), %rdi     # 0x5c5b8
callq 0x53f0
movl -0xc(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12f10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x210e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dc40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13de0
testb $0x1, %al
jne 0x25631
jmp 0x25665
leaq -0x28(%rbp), %rdi
callq 0x13e40
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x13770
testb $0x1, %al
jne 0x2564c
jmp 0x25652
movb $0x1, -0x1(%rbp)
jmp 0x25669
jmp 0x25654
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x13e60
movq %rax, -0x38(%rbp)
jmp 0x25611
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5960
movq -0xd8(%rbp), %rdx
leaq 0x1e0c5(%rip), %rsi     # 0x43787
leaq -0x30(%rbp), %rdi
callq 0x6be0
jmp 0x256cd
movq -0xe0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13050
movq %rax, -0xf0(%rbp)
jmp 0x256e6
movq -0xf0(%rbp), %rdi
callq 0x5900
movb %al, -0xf1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5aa8
leaq -0x31(%rbp), %rdi
callq 0x55e0
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x25716
jmp 0x25750
movb $0x0, -0x1(%rbp)
jmp 0x258f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x25742
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5aa8
leaq -0x31(%rbp), %rdi
callq 0x55e0
jmp 0x25906
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x5960
movq -0x100(%rbp), %rdx
leaq 0x1e005(%rip), %rsi     # 0x43787
leaq -0x88(%rbp), %rdi
callq 0x6be0
jmp 0x25790
movq -0x108(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x13050
movq %rax, -0x110(%rbp)
jmp 0x257ac
movq -0x110(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5200
jmp 0x257be
leaq -0x88(%rbp), %rdi
callq 0x5aa8
leaq -0x89(%rbp), %rdi
callq 0x55e0
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x118(%rbp)
movl $0x20, %esi
callq 0x5730
movq -0x118(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0xd0(%rbp), %rdi
movq $-0x1, %rcx
callq 0x55a0
jmp 0x25811
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x35610
jmp 0x25826
leaq -0xd0(%rbp), %rdi
callq 0x5aa8
movq -0xe8(%rbp), %rax
movq (%rax), %rdi
callq 0x12ed0
movq %rax, -0x120(%rbp)
jmp 0x2584a
movq -0x120(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x13770
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5aa8
leaq -0x68(%rbp), %rdi
callq 0x5aa8
jmp 0x258f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2589f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5aa8
leaq -0x89(%rbp), %rdi
callq 0x55e0
jmp 0x25906
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x258ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5aa8
jmp 0x258ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5aa8
leaq -0x68(%rbp), %rdi
callq 0x5aa8
jmp 0x25906
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5950
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12ff0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0xc1e0
movq -0x68(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x57b0
leaq -0x28(%rbp), %rdi
callq 0x9210
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9280
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9240
testb $0x1, %al
jne 0x2653d
jmp 0x265bc
leaq -0x38(%rbp), %rdi
callq 0x92b0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x5710
jmp 0x26554
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x13ae0
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9280
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9240
testb $0x1, %al
jne 0x26583
jmp 0x265b7
movq -0x68(%rbp), %rdi
leaq 0x1d2d4(%rip), %rsi     # 0x43862
callq 0x5520
jmp 0x26595
jmp 0x265b7
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x5aa8
leaq -0x28(%rbp), %rdi
callq 0x8ec0
jmp 0x265e2
jmp 0x2651d
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x265cf
movq -0x68(%rbp), %rdi
callq 0x5aa8
leaq -0x28(%rbp), %rdi
callq 0x8ec0
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5950
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0xc0, %rdi
callq 0x51f0
movq -0x20(%rbp), %rdi
addq 0xb0(%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0xc0, %rdi
callq 0x5830
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rax
subq 0xb0(%rax), %rdx
xorl %ecx, %ecx
callq 0x5260
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x29610
movq 0x329d8(%rip), %rdi     # 0x5bfa8
leaq 0x1a3ad(%rip), %rsi     # 0x43984
callq 0x5540
movq %rax, -0x38(%rbp)
callq 0x5060
movl (%rax), %edi
callq 0x5170
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5540
movq %rax, %rdi
movq 0x3297e(%rip), %rsi     # 0x5bf80
callq 0x55c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29659
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq 0xb0(%rdi), %rax
movq %rax, 0xb0(%rdi)
movq 0xb0(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0xc0, %rdi
callq 0x5830
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x29652
movl $0x0, -0x4(%rbp)
jmp 0x29659
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x2e2f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rax), %rdi
callq 0x2e550
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x2e5c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x2e5f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
addq $0x78, %rdi
movl $0x80, %edx
callq 0x5440
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1f8, %rsi            # imm = 0x1F8
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x2e620
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x210(%rcx), %ecx
movl %ecx, 0x210(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1f8, %rdi            # imm = 0x1F8
leaq -0xc(%rbp), %rsi
callq 0x2eb00
movq -0x20(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x2eb40
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
movq -0x18(%rbp), %rdx
cltq
orq 0x78(%rcx,%rax,8), %rdx
movq %rdx, 0x78(%rcx,%rax,8)
movl -0xc(%rbp), %eax
cmpl 0x210(%rcx), %eax
jle 0x2ca89
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x210(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl -0xc(%rbp), %esi
callq 0x2d0e0
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2ea70
movq -0x80(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x48, %rdi
callq 0x2eaa0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ea40
testb $0x1, %al
jne 0x2cfbe
jmp 0x2d0c3
movq -0x80(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
leaq 0x16a34(%rip), %rdx     # 0x43a04
leaq -0x40(%rbp), %rdi
callq 0x8f70
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5960
movq -0x88(%rbp), %rdx
leaq 0x169f4(%rip), %rsi     # 0x439eb
leaq -0x60(%rbp), %rdi
callq 0x6be0
jmp 0x2d002
leaq 0x2f5ef(%rip), %rdi     # 0x5c5f8
movl $0x1, %esi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
xorl %r8d, %r8d
callq 0x3b240
jmp 0x2d020
leaq -0x60(%rbp), %rdi
callq 0x5aa8
leaq -0x61(%rbp), %rdi
callq 0x55e0
leaq -0x40(%rbp), %rdi
callq 0x5aa8
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2e960
movq (%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x2d079
movq -0x90(%rbp), %rdi
callq 0x21690
movq -0x90(%rbp), %rdi
movl $0x50, %esi
callq 0x5580
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2ead0
jmp 0x2d0c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2d0af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5aa8
leaq -0x61(%rbp), %rdi
callq 0x55e0
leaq -0x40(%rbp), %rdi
callq 0x5aa8
jmp 0x2d0cc
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x2ef40
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x2efa0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ef70
testb $0x1, %al
jne 0x2d12e
jmp 0x2d17f
leaq -0x18(%rbp), %rdi
callq 0x2efd0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2d16c
movq -0x48(%rbp), %rax
addq $0x1f8, %rax            # imm = 0x1F8
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2f040
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2eff0
movq %rax, -0x30(%rbp)
jmp 0x2d17f
jmp 0x2d16e
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2f060
movq %rax, -0x38(%rbp)
jmp 0x2d107
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x48(%rbp), %rcx
xorq $-0x1, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
movq -0x58(%rbp), %rdx
cltq
andq 0x78(%rcx,%rax,8), %rdx
movq %rdx, 0x78(%rcx,%rax,8)
movl -0xc(%rbp), %eax
cmpl 0x210(%rcx), %eax
jne 0x2d1f4
movq -0x48(%rbp), %rsi
addq $0x1f8, %rsi            # imm = 0x1F8
leaq -0x40(%rbp), %rdi
callq 0x2f090
leaq -0x40(%rbp), %rdi
callq 0x2f0e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x210(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21be0
testb $0x1, %al
jne 0x2d907
jmp 0x2d921
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x198, %ecx            # imm = 0x198
callq 0x217b0
movq -0x10(%rbp), %rdi
callq 0x21c90
testb $0x1, %al
jne 0x2d930
jmp 0x2d94a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x1f7, %ecx            # imm = 0x1F7
callq 0x217b0
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5200
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x41780
jmp 0x3587e
movq -0x78(%rbp), %rdi
addq $0x80, %rdi
leaq -0x38(%rbp), %rsi
callq 0x56d0
leaq -0x38(%rbp), %rdi
callq 0x5aa8
leaq -0x58(%rbp), %rdi
callq 0x5aa8
testb $0x1, -0x11(%rbp)
je 0x358cc
movq -0x78(%rbp), %rdi
callq 0x359a0
jmp 0x358d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5aa8
jmp 0x358de
movq -0x78(%rbp), %rdi
callq 0x35ce0
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5950
nopw (%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::close()
void File::close() {
  if (fd_ <= 0)
    return ;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, (%rax)
jg 0x3597b
jmp 0x35990
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x5a50
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x90(%rbp)
addq $0x80, %rdi
leaq 0xd88b(%rip), %rsi      # 0x435a3
movq $-0x1, %rdx
callq 0x5500
movq -0x90(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
leaq -0x28(%rbp), %rdi
movq $-0x1, %rcx
callq 0x55a0
leaq -0x28(%rbp), %rdi
callq 0x5900
testb $0x1, %al
jne 0x35d51
jmp 0x35d5d
movl $0x1, -0x2c(%rbp)
jmp 0x35ebe
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5050
jmp 0x35d73
leaq 0xdc29(%rip), %rsi      # 0x439a3
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5a70
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
leaq -0x60(%rbp), %rdi
callq 0x55a0
jmp 0x35db1
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x56d0
movq -0xc0(%rbp), %rdi
callq 0x5aa8
leaq 0xdbc4(%rip), %rsi      # 0x439a3
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5a70
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
callq 0x50d0
jmp 0x35e12
leaq -0x28(%rbp), %rdi
leaq 0xdb86(%rip), %rsi      # 0x439a3
movq $-0x1, %rdx
callq 0x5500
cmpq $-0x1, %rax
je 0x35eb7
leaq 0xdb69(%rip), %rsi      # 0x439a3
leaq -0x28(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq $-0x1, %rdx
movq %rdx, -0xc8(%rbp)
callq 0x5500
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rcx
movl %eax, -0x64(%rbp)
movslq -0x64(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x55a0
jmp 0x35e7b
movq -0x98(%rbp), %rdi
addq $0x48, %rdi
leaq -0x88(%rbp), %rsi
callq 0x56d0
leaq -0x88(%rbp), %rdi
callq 0x5aa8
jmp 0x35eb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5aa8
jmp 0x35ed0
movl $0x0, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5aa8
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5950
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x35960
testb $0x1, -0x9(%rbp)
je 0x35f35
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0x51f0
movq %rax, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1ed, %edx            # imm = 0x1ED
movb $0x0, %al
callq 0x53c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x35f59
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0x51f0
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x53c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
setg %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/File.cpp
// Function: File::unlink()
void File::unlink() {
  if (!exists())
    return ;
  if (::unlink(path_.c_str()) == -1)
    Log.print(DEBUG, "unlink : " + std::string(strerror(errno)) + " of " + path_, RED, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x36950
testb $0x1, %al
jne 0x36718
jmp 0x36933
movq -0xd0(%rbp), %rdi
addq $0x80, %rdi
callq 0x51f0
movq %rax, %rdi
callq 0x5240
cmpl $-0x1, %eax
jne 0x36933
callq 0x5060
movl (%rax), %edi
callq 0x5170
movq %rax, -0xe0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5960
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x6be0
jmp 0x3677e
leaq 0xd6ef(%rip), %rsi      # 0x43e74
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x107f0
jmp 0x36797
leaq 0xd700(%rip), %rdx      # 0x43e9e
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6a80
jmp 0x367ad
movq -0xd0(%rbp), %rdx
subq $-0x80, %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6a30
jmp 0x367c7
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x5960
movq -0xe8(%rbp), %rdx
leaq 0xc838(%rip), %rsi      # 0x43020
leaq -0xc0(%rbp), %rdi
callq 0x6be0
jmp 0x367f6
leaq 0x25dfb(%rip), %rdi     # 0x5c5f8
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movl $0x1, %r8d
callq 0x3b240
jmp 0x3681a
leaq -0xc0(%rbp), %rdi
callq 0x5aa8
leaq -0xc1(%rbp), %rdi
callq 0x55e0
leaq -0x28(%rbp), %rdi
callq 0x5aa8
leaq -0x48(%rbp), %rdi
callq 0x5aa8
leaq -0x68(%rbp), %rdi
callq 0x5aa8
leaq -0x88(%rbp), %rdi
callq 0x5aa8
leaq -0x89(%rbp), %rdi
callq 0x55e0
jmp 0x36933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36919
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36907
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x368f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x5aa8
leaq -0xc1(%rbp), %rdi
callq 0x55e0
leaq -0x28(%rbp), %rdi
callq 0x5aa8
leaq -0x48(%rbp), %rdi
callq 0x5aa8
leaq -0x68(%rbp), %rdi
callq 0x5aa8
leaq -0x88(%rbp), %rdi
callq 0x5aa8
leaq -0x89(%rbp), %rdi
callq 0x55e0
jmp 0x3693c
addq $0xf0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5950
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x5830
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x57b0
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x369e2
movq $0x0, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x36a34
movq -0x48(%rbp), %rdi
leaq 0xce5d(%rip), %rsi      # 0x43863
callq 0x5520
jmp 0x36a0d
jmp 0x36a0f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x369ea
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5aa8
jmp 0x36a60
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x5710
jmp 0x36a43
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x36a56
movq -0x48(%rbp), %rdi
callq 0x5aa8
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5950
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
testb $0x1, 0x20(%rdi)
je 0x36aac
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x36aac
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x11070
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x36af9
movq -0x28(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x36ad4
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x36ad4
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x11070
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x36af9
jmp 0x36ad6
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x20(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
subq $-0x80, %rdi
callq 0x51f0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x54c0
leaq -0x48(%rbp), %rdi
callq 0x5470
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rcx
leaq 0xc7df(%rip), %rdx      # 0x43eed
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movl $0x20, %esi
callq 0x5430
movl %eax, -0xd4(%rbp)
movslq -0xd4(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xd5(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5960
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
callq 0x5630
jmp 0x37770
leaq -0xd5(%rbp), %rdi
callq 0x55e0
movq -0x110(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd5(%rbp), %rdi
callq 0x55e0
movq -0xe0(%rbp), %rdi
callq 0x5950
nopw %cs:(%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: ft_calloc(unsigned long, unsigned long)
void	*ft_calloc(size_t count, size_t size)
{
	void	*mem;

	if (!(mem = malloc(count * size)))
		return (NULL);
	memset(mem, 0, count * size);
	return (mem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0x5750
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3ac92
movq $0x0, -0x8(%rbp)
jmp 0x3acae
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
imulq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x52b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: ft_strjoin(char const*, char const*)
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*str;

	if (!(str = (char*)ft_calloc(strlen(s1) + strlen(s2)
		+ 1, sizeof(char))))
		return (NULL);
	strcpy(str, s1);
	strcat(str, s2);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5210
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5210
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3ac60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3ad0f
movq $0x0, -0x8(%rbp)
jmp 0x3ad31
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5970
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: ft_strlen_c(char*, char)
size_t		ft_strlen_c(char *s, char c)
{
	size_t	i;

	i = 0;
	while (s[i] && s[i] != c)
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x19(%rbp)
je 0x3ad81
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3ad8a
jmp 0x3ad98
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ad56
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: ft_substr(char const*, unsigned int, unsigned long)
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*str;
	int		i;

	i = 0;
	if (!s)
		return (NULL);
	if (start > strlen(s))
		return (NULL);
	if (!(str = (char*)ft_calloc(len + 1, sizeof(char))))
		return (NULL);
	while (s[start] && len)
	{
		str[i] = s[start];
		i++;
		start++;
		len--;
	}
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3adce
movq $0x0, -0x8(%rbp)
jmp 0x3ae90
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5210
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x3adf7
movq $0x0, -0x8(%rbp)
jmp 0x3ae90
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3ac60
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3ae1d
movq $0x0, -0x8(%rbp)
jmp 0x3ae90
jmp 0x3ae1f
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x39(%rbp)
je 0x3ae3e
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3ae47
jmp 0x3ae7c
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3ae1f
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: ft_is_in_stri(char, char*)
int		ft_is_in_stri(char c, char *str)
{
	int		i;

	i = 0;
	while (str[i])
	{
		if (str[i] == c)
			return (i);
		i++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3aeea
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3aedf
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3aef1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3aeb5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: get_next_line(int, char**)
int				get_next_line(int fd, char **line)
{
	static char		*s[10240];
	char			buf[BUFFER_SIZE + 1];
	int				ret;
	char			*tmp;

	if (fd < 0 || !line || BUFFER_SIZE < 1 || read(fd, buf, 0) < 0)
		return (-1);
	if (!s[fd] && !(s[fd] = (char*)ft_calloc(1, sizeof(char *))))
		return (-1);
	while ((ft_is_in_stri('\n', s[fd])) < 0 && (ret = read(fd, buf, BUFFER_SIZE)) > 0)
	{
		buf[ret] = '\0';
		tmp = s[fd];
		s[fd] = ft_strjoin(s[fd], buf);
		free(tmp);
	}
	if (s[fd])
		*line = ft_substr(s[fd], 0, ft_strlen_c(s[fd], '\n'));
	if (!handle_line(s, fd))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x3af38
cmpq $0x0, -0x10(%rbp)
je 0x3af38
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x57e0
cmpq $0x0, %rax
jge 0x3af44
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b0c5
movslq -0x8(%rbp), %rcx
leaq 0x21761(%rip), %rax     # 0x5c6b0
cmpq $0x0, (%rax,%rcx,8)
jne 0x3af86
movl $0x1, %edi
movl $0x8, %esi
callq 0x3ac60
movslq -0x8(%rbp), %rdx
leaq 0x21740(%rip), %rcx     # 0x5c6b0
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x3af86
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b0c5
jmp 0x3af88
movslq -0x8(%rbp), %rcx
leaq 0x2171d(%rip), %rax     # 0x5c6b0
movq (%rax,%rcx,8), %rsi
movl $0xa, %edi
callq 0x3aea0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb1(%rbp)
jge 0x3afd6
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0x57e0
movl %eax, -0xa4(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3afe2
jmp 0x3b045
movslq -0xa4(%rbp), %rax
movb $0x0, -0xa0(%rbp,%rax)
movslq -0x8(%rbp), %rcx
leaq 0x216b4(%rip), %rax     # 0x5c6b0
movq (%rax,%rcx,8), %rax
movq %rax, -0xb0(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x2169e(%rip), %rax     # 0x5c6b0
movq (%rax,%rcx,8), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3acc0
movq %rax, %rdx
movslq -0x8(%rbp), %rcx
leaq 0x21680(%rip), %rax     # 0x5c6b0
movq %rdx, (%rax,%rcx,8)
movq -0xb0(%rbp), %rdi
callq 0x56b0
jmp 0x3af88
movslq -0x8(%rbp), %rcx
leaq 0x21660(%rip), %rax     # 0x5c6b0
cmpq $0x0, (%rax,%rcx,8)
je 0x3b0a1
movslq -0x8(%rbp), %rcx
leaq 0x2164e(%rip), %rax     # 0x5c6b0
movq (%rax,%rcx,8), %rax
movq %rax, -0xc0(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x21638(%rip), %rax     # 0x5c6b0
movq (%rax,%rcx,8), %rdi
movl $0xa, %esi
callq 0x3ad40
movq -0xc0(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x3ada0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x8(%rbp), %esi
leaq 0x21605(%rip), %rdi     # 0x5c6b0
callq 0x3b0e0
cmpl $0x0, %eax
jne 0x3b0be
movl $0x0, -0x4(%rbp)
jmp 0x3b0c5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: solaldunckel[P]webserv/srcs/Utils/get_next_line.cpp
// Function: handle_line(char**, int)
static int		handle_line(char *s[], int fd)
{
	char	*tmp;

	if (ft_is_in_stri('\n', s[fd]) >= 0)
	{
		tmp = s[fd];
		s[fd] = ft_substr(s[fd], ft_is_in_stri('\n', s[fd]) + 1, strlen(s[fd]));
		free(tmp);
	}
	else if (strlen(s[fd]) > 0) {
    free(s[fd]);
    s[fd] = NULL;
  }
	else
	{
    free(s[fd]);
    s[fd] = NULL;
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0xa, %edi
callq 0x3aea0
cmpl $0x0, %eax
jl 0x3b180
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0xa, %edi
callq 0x3aea0
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5210
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq %rax, %rdx
callq 0x3ada0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x56b0
jmp 0x3b1e6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5210
cmpq $0x0, %rax
jbe 0x3b1ba
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x56b0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x3b1e4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x56b0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x3b1ed
jmp 0x3b1e6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)