LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::get_route(cordpp::Request const&)
RestRoute& RestClient::get_route(const Request &req) {
  const std::string index = req.method + ";" + req.endpoint;
  if (routes.find(index) == routes.end())
    routes[index] = RestRoute();
  return routes[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq 0x44b90(%rip), %rdx     # 0x93f2d
leaq -0x50(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x54060
movq -0xd8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x30, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1eb10
jmp 0x4f3c7
leaq -0x50(%rbp), %rdi
callq 0xcfb8
movq -0xe0(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x30(%rbp), %rsi
callq 0x54110
movq %rax, -0xe8(%rbp)
jmp 0x4f3f0
movq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x148, %rdi            # imm = 0x148
callq 0x54140
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x540e0
testb $0x1, %al
jne 0x4f428
jmp 0x4f4e4
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
movq $0x0, -0x80(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x54170
jmp 0x4f464
movq -0xe0(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x30(%rbp), %rsi
callq 0x54190
movq %rax, -0xf0(%rbp)
jmp 0x4f484
movq -0xf0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x54270
leaq -0xd0(%rbp), %rdi
callq 0x15670
jmp 0x4f4e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcfb8
jmp 0x4f526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4f51d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x15670
jmp 0x4f51d
movq -0xe0(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x30(%rbp), %rsi
callq 0x54190
movq %rax, -0xf8(%rbp)
jmp 0x4f504
leaq -0x30(%rbp), %rdi
callq 0xcfb8
movq -0xf8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xcfb8
movq -0x58(%rbp), %rdi
callq 0xc8c0
nop
// File: king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::perform_task(cordpp::RestTask const&)
void RestClient::perform_task(const RestTask &task) {
  RestRoute& route = get_route(task.req);
  if (route.rate_limited) {
    route.pending.push_back(task);
  } else if (global_route.rate_limited) {
    global_route.pending.push_back(task);
  } else {
    conn->write(to_string(task.req));
    tasks.push_back(task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4f370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x4f574
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x54450
jmp 0x4f60b
movq -0x50(%rbp), %rax
testb $0x1, 0x80(%rax)
je 0x4f59b
movq -0x50(%rbp), %rdi
addq $0x80, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x54450
jmp 0x4f609
movq -0x50(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x54430
movq -0x50(%rbp), %rsi
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4f620
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x5a8f0
jmp 0x4f5d3
leaq -0x38(%rbp), %rdi
callq 0xcfb8
movq -0x50(%rbp), %rdi
addq $0xd8, %rdi
movq -0x10(%rbp), %rsi
callq 0x54450
jmp 0x4f609
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcfb8
jmp 0x4f611
jmp 0x4f60b
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc8c0
nopw (%rax,%rax)
// File: king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::RestClient(cordpp::Service&)
RestClient::RestClient(Service &s) : service(s) {
  global_route.rate_limited = false;
  conn = std::make_unique<SSLClient>(service);
  conn->on_close([this](const Error &err) {
    conn.reset(new SSLClient(service));
    connect_and_flush();
  });
  connect_and_flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
callq 0xc4e0
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0x544c0
movq -0x60(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x54170
jmp 0x4fba3
movq -0x60(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x544f0
jmp 0x4fbb9
movq -0x60(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq %rdi, -0x90(%rbp)
callq 0x54510
movq -0x60(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, -0x88(%rbp)
callq 0x4dfb0
movq -0x60(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq %rdi, -0x80(%rbp)
callq 0x54540
movq -0x60(%rbp), %rax
movb $0x0, 0x80(%rax)
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x54560
jmp 0x4fc14
movq -0x60(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq %rdi, -0xa8(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x545e0
movq -0xb0(%rbp), %rdi
callq 0x15590
movq -0xa8(%rbp), %rdi
callq 0x54430
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x4fd40
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x5a6f0
jmp 0x4fc89
leaq -0x48(%rbp), %rdi
callq 0x15f10
movq -0x60(%rbp), %rdi
callq 0x4fdd0
jmp 0x4fc9d
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4fd18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4fd0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4fce5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x15f10
movq -0x80(%rbp), %rdi
callq 0x15510
movq -0x88(%rbp), %rdi
callq 0x15530
movq -0x90(%rbp), %rdi
callq 0x15590
movq -0x78(%rbp), %rdi
callq 0x15600
movq -0x58(%rbp), %rdi
callq 0x15670
movq -0x68(%rbp), %rdi
callq 0x15690
movq -0x70(%rbp), %rdi
callq 0xcfb8
movq -0x18(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::flush_route(cordpp::RestRoute&)
void RestClient::flush_route(RestRoute &route) {
  RestTask task;
  route.rate_limited = false;
  size_t i, remaining = route.pending.size();
  for (i = 0; i < remaining; i++) {
    task = std::move(route.pending.front());
    route.pending.pop_front();
    perform_task(task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x547a0
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x547d0
movq %rax, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
cmpq -0xb0(%rbp), %rax
jae 0x4ffcb
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x54800
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x54830
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x54870
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x4f530
jmp 0x4ff95
jmp 0x4ff97
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x4ff40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1a640
jmp 0x4ffe0
leaq -0xa0(%rbp), %rdi
callq 0x1a640
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::connect_and_flush()::$_0::operator()(boost::system::error_code const&) const
void RestClient::connect_and_flush() {
  conn->connect(base_host, 443, [this](const Error &err) {
    if (err) { conn->close(err); return; }
    parse_data();
    RestTask task;
    const size_t pending = tasks.size();
    for (size_t i = 0; i < pending; i++) {
      task = std::move(tasks.front());
      tasks.pop_front();
      perform_task(task);
    }
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b830
testb $0x1, %al
jne 0x515f0
jmp 0x51614
movq -0xc8(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x54430
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5ab80
jmp 0x516f8
movq -0xc8(%rbp), %rdi
callq 0x50b50
leaq -0xa0(%rbp), %rdi
callq 0x547a0
movq -0xc8(%rbp), %rdi
addq $0xd8, %rdi
callq 0x547d0
movq %rax, -0xa8(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jae 0x516ec
movq -0xc8(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x54800
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x54830
movq -0xd8(%rbp), %rdi
callq 0x54870
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x4f530
jmp 0x516b6
jmp 0x516b8
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb0(%rbp)
jmp 0x51651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1a640
jmp 0x51701
leaq -0xa0(%rbp), %rdi
callq 0x1a640
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const_iterator find(typename object_t::key_type key) const
    {
        auto result = cend();

        if (is_object())
        {
            result.m_it.object_iterator = m_value.object->find(key);
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
callq 0x58810
movq -0x20(%rbp), %rdi
callq 0x1f720
testb $0x1, %al
jne 0x54b5b
jmp 0x54b7f
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1f770
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: king1600[P]cordpp/src/items.cc
// Function: cordpp::Role::Role(cordpp::Guild*)
Role::Role(Guild *g) : Item() {
  guild = g;
  _color = 0;
  _position = 0;
  _hoist = false;
  _managed = false;
  _permissions = 0;
  _mentionable = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0xc490
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xc4e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x38(%rax)
movb $0x0, 0x8(%rax)
movb $0x0, 0x9(%rax)
movl $0x0, 0x3c(%rax)
movb $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/items.cc
// Function: cordpp::Emoji::Emoji(cordpp::Guild*)
Emoji::Emoji(Guild *g) : Item()  {
  guild = g;
  _managed = false;
  _roles.cache_size(2);
  _require_colons = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0xc4e0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4dc30
jmp 0x598ff
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x70(%rdi)
movb $0x0, 0x8(%rdi)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x4dff0
jmp 0x5991f
movq -0x30(%rbp), %rax
movb $0x0, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x59950
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4e6c0
movq -0x38(%rbp), %rdi
callq 0xcfb8
movq -0x18(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::Timer::Timer(boost::asio::io_context&, long, void*, std::function<void (void*)> const&, std::function<void (cordpp::Timer*)> const&)
Timer::Timer(asio::io_service &service, const long delay_ms, void *data,
  const RawAction &action, const std::function<void(Timer*)> &cb) : timer(service)
{
  this->data = data;
  this->callback = cb;
  this->action = action;
  timer.expires_from_now(boost::posix_time::millisec(delay_ms));
  timer.async_wait([this](const Error &err) {
    if (!err) callback(this);
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x6c6a0
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x28fb0
jmp 0x5a413
movq -0x60(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x70(%rbp)
callq 0x6c6e0
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rsi
callq 0x6c720
jmp 0x5a441
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rdi
callq 0x6c770
jmp 0x5a454
movq -0x60(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6c7c0
jmp 0x5a473
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x296e0
jmp 0x5a482
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x5a4f0
jmp 0x5a49c
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5a4d1
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6c680
movq -0x58(%rbp), %rdi
callq 0x166e0
movq -0x68(%rbp), %rdi
callq 0x54bf0
movq -0x38(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::SSLClient(cordpp::Service&)
SSLClient::SSLClient(Service& service) :
  service(service), sock(service.get(), service.get_ssl_context()) {
  remaining = 0;                          // no remaining read data
  connected = false;                      // client starts of disconnected
  on_close([](const Error &e) {});        // default close callback
  sock.set_verify_mode(ssl::verify_none); // no ssl verification 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x80(%rbp)
callq 0x6c810
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
callq 0x6c810
movq -0x70(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x68(%rbp)
callq 0x16c30
movq %rax, -0x60(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcc80
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x6c850
jmp 0x5a596
leaq -0x11(%rbp), %rdi
callq 0xcfa0
movq -0x70(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a210
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a230
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x6c9d0
jmp 0x5a5e1
movq -0x70(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0x98(%rbp)
callq 0x6cad0
jmp 0x5a5fa
movq -0x70(%rbp), %rax
movq $0x0, 0x10(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x49(%rbp), %rsi
callq 0x5a720
movq -0x70(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x5a6f0
jmp 0x5a62f
leaq -0x48(%rbp), %rdi
callq 0x15f10
movq -0x70(%rbp), %rdi
addq $0xb8, %rdi
xorl %esi, %esi
callq 0x6caf0
jmp 0x5a64c
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xcfa0
jmp 0x5a6cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5a6c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5a6b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x15f10
jmp 0x5a6ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x98(%rbp), %rdi
callq 0x15e10
movq -0x90(%rbp), %rdi
callq 0x15e80
movq -0x68(%rbp), %rdi
callq 0x15ec0
movq -0x78(%rbp), %rdi
callq 0x15f10
movq -0x80(%rbp), %rdi
callq 0x15f10
movq -0x20(%rbp), %rdi
callq 0xc8c0
nopw (%rax,%rax)
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::read_handler(boost::system::error_code const&, unsigned long)
void SSLClient::read_handler(const Error &err, size_t bytes) {
  // close on error
  if (err) { close(err); return; }
  
  // get the action from the task queue
  const BufferAction action = std::move(queue.front());
  queue.pop_front();

  // fix read_n incomplete size
  bytes += remaining;
  remaining = 0;

  // give the action its requested data
  const Buffer buf(
    asio::buffers_begin(buffer.data()),
    asio::buffers_begin(buffer.data()) + bytes);
  buffer.consume(bytes);
  action(std::move(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b830
testb $0x1, %al
jne 0x5a971
jmp 0x5a986
movq -0x138(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ab80
jmp 0x5ab0e
movq -0x138(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0x140(%rbp)
callq 0x6cb70
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x6cba0
movq -0x140(%rbp), %rdi
callq 0x6cc30
movq -0x138(%rbp), %rdi
movq 0x10(%rdi), %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, 0x10(%rdi)
addq $0x58, %rdi
callq 0x6ccd0
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6cca0
jmp 0x5aa02
movq -0x138(%rbp), %rdi
addq $0x58, %rdi
callq 0x6ccd0
movq %rax, -0x128(%rbp)
movq %rdx, -0x120(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x6cca0
jmp 0x5aa35
movq -0x18(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x6cd50
jmp 0x5aa4e
leaq -0x129(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0xcc80
movq -0x150(%rbp), %rsi
movq -0xb0(%rbp), %rcx
movq %rsp, %rax
movq %rax, -0x148(%rbp)
movq %rcx, 0x68(%rax)
movups -0xe0(%rbp), %xmm0
movups -0xd0(%rbp), %xmm1
movups -0xc0(%rbp), %xmm2
movups %xmm2, 0x58(%rax)
movups %xmm1, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x30(%rax)
movups -0x88(%rbp), %xmm0
movups -0x78(%rbp), %xmm1
movups -0x68(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x6cd90
jmp 0x5aacb
leaq -0x129(%rbp), %rdi
callq 0xcfa0
movq -0x138(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x6ceb0
jmp 0x5aaed
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6cf90
jmp 0x5aafc
leaq -0x50(%rbp), %rdi
callq 0x18990
leaq -0x38(%rbp), %rdi
callq 0x162c0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x5ab66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x129(%rbp), %rdi
callq 0xcfa0
jmp 0x5ab66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x18990
leaq -0x38(%rbp), %rdi
callq 0x162c0
movq -0xa0(%rbp), %rdi
callq 0xc8c0
nopl (%rax,%rax)
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::close(boost::system::error_code const&)
void SSLClient::close(const Error &err) {
  // check connection status
  if (!connected) return;
  connected = false;

  // request cancel shutdown
  Error cancel_err;
  sock.lowest_layer().cancel(cancel_err);

  // shutdown read and write socket capabities + ssl teardown
  sock.async_shutdown([&](const Error &shutdown_err) {

    // close internal socket and perform callback
    Error place_holder;
    sock.lowest_layer().close(place_holder);
    close_cb(cancel_err ? cancel_err : shutdown_err);
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, (%rax)
jne 0x5ab9f
jmp 0x5abf9
movq -0x48(%rbp), %rax
movb $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x16a50
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0x6d350
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x6d370
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, %rdi
addq $0xb8, %rdi
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x5ae50
addq $0x50, %rsp
popq %rbp
retq
nop
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::read(std::function<void (std::vector<char, std::allocator<char>> const&)> const&)
void SSLClient::read(const BufferAction& action) {
  if (!connected) return;
  queue.push_back(action);
  
  // read some amount of data
  asio::async_read(sock, buffer, asio::transfer_at_least(1),
    boost::bind(&SSLClient::read_handler, this,
      asio::placeholders::error, asio::placeholders::bytes_transferred));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, (%rax)
jne 0x5ac22
jmp 0x5aca9
movq -0x48(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq -0x10(%rbp), %rsi
callq 0x6cfd0
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, -0x58(%rbp)
addq $0x58, %rax
movq %rax, -0x50(%rbp)
movl $0x1, %edi
callq 0x6d090
movq -0x48(%rbp), %rcx
movq %rax, -0x18(%rbp)
leaq -0x329(%rip), %rax      # 0x5a940
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x124d8(%rip), %r8      # 0x6d160
leaq 0x124f1(%rip), %r9      # 0x6d180
callq 0x6d0c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x6d030
addq $0x60, %rsp
popq %rbp
retq
nop
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::read(unsigned int, std::function<void (std::vector<char, std::allocator<char>> const&)> const&)
void SSLClient::read(const unsigned int size, const BufferAction& action) {
  if (!connected) return;
  queue.push_back(action);

  // read at least {size} amount of data
  buffer.prepare(size);
  remaining = buffer.size();
  asio::async_read(sock, buffer,
    asio::transfer_exactly(size - remaining),
    boost::bind(&SSLClient::read_handler, this,
      asio::placeholders::error, asio::placeholders::bytes_transferred));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, (%rax)
jne 0x5acd5
jmp 0x5ad89
movq -0x60(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq -0x18(%rbp), %rsi
callq 0x6cfd0
movq -0x60(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x68(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x6d1a0
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x6d200
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, -0x70(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %edi
movq 0x10(%rax), %rax
subq %rax, %rdi
callq 0x6d2b0
movq -0x60(%rbp), %rcx
movq %rax, -0x30(%rbp)
leaq -0x409(%rip), %rax      # 0x5a940
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq 0x123f8(%rip), %r8      # 0x6d160
leaq 0x12411(%rip), %r9      # 0x6d180
callq 0x6d0c0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x6d250
addq $0x70, %rsp
popq %rbp
retq
nop
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::read_until(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::vector<char, std::allocator<char>> const&)> const&)
void SSLClient::read_until(const std::string &term, const BufferAction& action) {
  if (!connected) return;
  queue.push_back(action);

  // read until {term} string
  asio::async_read_until(sock, buffer, term,
    boost::bind(&SSLClient::read_handler, this,
      asio::placeholders::error, asio::placeholders::bytes_transferred));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, (%rax)
jne 0x5adb6
jmp 0x5ae44
movq -0x58(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq -0x18(%rbp), %rsi
callq 0x6cfd0
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, -0x68(%rbp)
addq $0x58, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd90
movq -0x58(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x4c0(%rip), %rax      # 0x5a940
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq 0x12341(%rip), %r8      # 0x6d160
leaq 0x1235a(%rip), %r9      # 0x6d180
callq 0x6d0c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x6d2e0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: king1600[P]cordpp/src/ssl.cc
// Function: cordpp::SSLClient::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::function<void (boost::system::error_code const&)> const&)
void SSLClient::connect(const std::string &host,
  const int port, const BoostAction &action)
{
  // already connected
  if (connected) return;
  connect_cb = action;

  // resolve the host
  tcp::resolver::query query(host, std::to_string(port));
  service.get_resolver().async_resolve(query, 
  [this] (const Error &err, tcp::resolver::iterator it) {;
    if (err) { connect_cb(err); return; }

    // connect to the endpoint
    asio::async_connect(sock.lowest_layer(), it,
    [this] (const Error &err, tcp::resolver::iterator it) {
      if (err) { connect_cb(err); return; }

      // perform ssl handshake
      sock.async_handshake(ssl::stream_base::client, [this] (const Error &err) {
        connected = err ? false : true;
        connect_cb(err ? err : Success);
      });
    });
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
testb $0x1, (%rax)
je 0x5aeaf
jmp 0x5af53
movq -0xd0(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x38, %rdi
callq 0x2cbb0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0x14(%rbp), %esi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x1ee10
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movl $0x20, %ecx
callq 0x6d3d0
jmp 0x5af05
leaq -0xb0(%rbp), %rdi
callq 0xcfb8
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5a1f0
movq %rax, %rdi
movq -0xd0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x5afb0
jmp 0x5af47
leaq -0x90(%rbp), %rdi
callq 0x6d4e0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xcfb8
jmp 0x5af9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x6d4e0
movq -0xb8(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/user.cc
// Function: cordpp::User::User(cordpp::Client*)
User::User(Client *client) : Item() {
  this->client = client;
  _bot = false;
  _verified = false;
  _mfa_enabled = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0xc490
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc4e0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc4e0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0xc4e0
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0xc4e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x90(%rax)
movb $0x0, 0x8(%rax)
movb $0x0, 0x9(%rax)
movb $0x0, 0xa(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::WebsockClient(cordpp::Service&)
WebsockClient::WebsockClient(Service &service) 
  : connection(service)
{
  frame.payload = nullptr;
  state = WebsockState::closed;
  on_connect([](const Error &err) {});
  on_close([](const WebsockCloseData &data) {});
  on_message([](const char* data, const size_t len) {});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x8c0e0
movq -0xa8(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5a520
jmp 0x8846a
movq -0xb0(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movq %rdi, -0xd0(%rbp)
callq 0x8c100
movq -0xb0(%rbp), %rdi
addq $0x308, %rdi            # imm = 0x308
movq %rdi, -0xc8(%rbp)
callq 0x6c810
movq -0xb0(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
movq %rdi, -0xc0(%rbp)
callq 0x8c140
movq -0xb0(%rbp), %rdi
addq $0x348, %rdi            # imm = 0x348
movq %rdi, -0xb8(%rbp)
callq 0x8c180
jmp 0x884d4
movq -0xb0(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x1, 0x398(%rax)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x41(%rbp), %rsi
callq 0x88650
movq -0xb0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x299a0
jmp 0x88516
leaq -0x40(%rbp), %rdi
callq 0x15f10
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0x69(%rbp), %rsi
callq 0x886e0
movq -0xb0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x299d0
jmp 0x88548
leaq -0x68(%rbp), %rdi
callq 0x1c9c0
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0x91(%rbp), %rsi
callq 0x88770
movq -0xb0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x29a00
jmp 0x88580
leaq -0x90(%rbp), %rdi
callq 0x1c9e0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x88636
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x88606
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15f10
jmp 0x885fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c9c0
jmp 0x885fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c9e0
movq -0xb8(%rbp), %rdi
callq 0x1c950
movq -0xc0(%rbp), %rdi
callq 0x1c9c0
movq -0xc8(%rbp), %rdi
callq 0x15f10
movq -0xd0(%rbp), %rdi
callq 0x1c9e0
movq -0xa0(%rbp), %rdi
callq 0x15db0
movq -0xa8(%rbp), %rdi
callq 0x18990
movq -0x18(%rbp), %rdi
callq 0xc8c0
nopl (%rax,%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::start_handshake(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void WebsockClient::start_handshake(const std::string &host) {
  // connect to gateway
  state = WebsockState::connecting;
  frame.payload = new char[host.size() + 1];
  frame.payload[sizeof(frame.payload)] = 0;
  std::memcpy(frame.payload, host.c_str(), host.size());
  connection.connect(host, 443, [this](const Error &err) {

    // handle connection error
    if (err) {
      state = WebsockState::closed;
      connect_cb(err);
      return;
    }

    // generate websocket key
    uint8_t key_data[16] = { 0 };
    for (uint8_t i = 0; i < 16; i++)
      key_data[i] = rand_byte();
    char *key = b64_encode(reinterpret_cast<const char*>(key_data), 16);

    // generate http handshake data
    std::ostringstream output;
    output << "GET /?v=" << ws_version << "&encoding=json HTTP/1.1\r\n"
           << "Upgrade: WebSocket\r\n"
           << "Connection: Upgrade\r\n"
           << "Sec-WebSocket-Version: 13\r\n"
           << "Host: " << frame.payload << ":443\r\n"
           << "Sec-WebSocket-Key: " << key << "\r\n\r\n";
    connection.write(output.str());
    delete frame.payload;
    frame.payload = nullptr;
    delete key;

    // check handshake response and start connection
    connection.read_until("\r\n\r\n", [this](const Buffer &buf) {
      const std::string data(buf.begin(), buf.end());
      if (data.find("HTTP/1.1 101") == 0) {
        state = WebsockState::open;
        parse_headers();
        connect_cb(Success);
      }
    });
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x2, 0x398(%rax)
movq -0x10(%rbp), %rdi
callq 0xc420
movq %rax, %rdi
incq %rdi
callq 0xc640
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rcx
movb $0x0, 0x8(%rcx)
movq 0x20(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc190
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc420
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0xc0d0
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x88920
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x5ae80
jmp 0x888ee
leaq -0x30(%rbp), %rdi
callq 0x15f10
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15f10
movq -0x40(%rbp), %rdi
callq 0xc8c0
nop
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::parse_headers()
void WebsockClient::parse_headers() {
  // clean leftover data
  if (frame.payload != nullptr) {
    delete frame.payload;
    frame.payload = nullptr;
  }

  // read and parse the first two bytes
  if (connection.is_connected()) {
    connection.read(2, [this](const Buffer &buf) {

      // parse the first byte
      frame.fin  = (buf[0] >> 7) & 1;
      frame.rsv1 = (buf[0] >> 6) & 1;
      frame.rsv2 = (buf[0] >> 5) & 1;
      frame.rsv3 = (buf[0] >> 4) & 1;
      frame.opcode = static_cast<WebsockOp>(buf[0] & 0x0f);

      // parse the second byte
      frame.payload_len = buf[1] & (~0x80);
      frame.masked = (buf[1] >> 7) & 1;

      // no mask, fetch the payload size
      if (frame.masked == 0) {
        frame.mask = nullptr;
        parse_length();

      // retrive mask then fetch payload size
      } else {
        frame.mask = new uint8_t[4];
        connection.read(4, [this](const Buffer &buf) {
          frame.mask[0] = static_cast<uint8_t>(buf[0]);
          frame.mask[1] = static_cast<uint8_t>(buf[1]);
          frame.mask[2] = static_cast<uint8_t>(buf[2]);
          frame.mask[3] = static_cast<uint8_t>(buf[3]);
          parse_length();
        });
      }
    });
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x889f7
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x889eb
movq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xc1b0
movq -0x48(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0x5a7b0
testb $0x1, %al
jne 0x88a0a
jmp 0x88a64
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x88a80
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movl $0x2, %esi
callq 0x5acb0
jmp 0x88a42
leaq -0x28(%rbp), %rdi
callq 0x162c0
jmp 0x88a64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x162c0
jmp 0x88a6a
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::parse_length()
void WebsockClient::parse_length() {
  // start parsing body if no remaining data
  if (frame.payload_len != 0x7f && frame.payload_len != 0x7e) {
    parse_payload();

  // read remaining data of size if not
  } else {
    const uint8_t padding = frame.payload_len < 0x10000 ? 2 : 8;
    connection.read(padding, [this](const Buffer &buf) {
      size_t payload_size = 0;

      // 16-bit payload
      if (frame.payload_len == 0x7e) {
        payload_size |= static_cast<uint64_t>(buf[0] & 0xff) << 8;
        payload_size |= static_cast<uint64_t>(buf[1] & 0xff);

      // 64-bit payload
      } else if (frame.payload_len == 0x7f) {
        payload_size |= static_cast<uint64_t>(buf[0] & 0xff) << 56;
        payload_size |= static_cast<uint64_t>(buf[1] & 0xff) << 48;
        payload_size |= static_cast<uint64_t>(buf[2] & 0xff) << 40;
        payload_size |= static_cast<uint64_t>(buf[3] & 0xff) << 32;
        payload_size |= static_cast<uint64_t>(buf[4] & 0xff) << 24;
        payload_size |= static_cast<uint64_t>(buf[5] & 0xff) << 16;
        payload_size |= static_cast<uint64_t>(buf[6] & 0xff) << 8;
        payload_size |= static_cast<uint64_t>(buf[7] & 0xff);
      }

      // set size and parse payload
      frame.payload_len = payload_size;
      parse_payload();
    });
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x7f, 0x38(%rax)
je 0x88b41
movq -0x50(%rbp), %rax
cmpq $0x7e, 0x38(%rax)
je 0x88b41
movq -0x50(%rbp), %rdi
callq 0x88bd0
jmp 0x88bbb
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rcx
subq $0x10000, %rcx          # imm = 0x10000
movl $0x2, %edx
movl $0x8, %ecx
cmovbl %edx, %ecx
movb %cl, -0x9(%rbp)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x68(%rbp)
movzbl -0x9(%rbp), %ecx
movl %ecx, -0x5c(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x88c60
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0x5acb0
jmp 0x88b99
leaq -0x30(%rbp), %rdi
callq 0x162c0
jmp 0x88bbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x162c0
jmp 0x88bc1
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc8c0
nopw (%rax,%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::parse_payload()
void WebsockClient::parse_payload() {
  // prepare and read data
  frame.payload = new char[frame.payload_len];
  connection.read(frame.payload_len, [this](const Buffer &buf) {

    // get and unmask data from response
    for (size_t i = 0; i < buf.size(); i++)
      frame.payload[i] = (frame.masked == 0 ?
        buf[i] : buf[i] ^ frame.mask[i % 4]);

    // delete mask if frame was masked
    if (frame.masked == 1)
      delete frame.mask;

    // handle the colelcted frame
    handle_frame();
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x38(%rax), %rdi
callq 0xc640
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x20(%rax)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x58(%rbp)
movl 0x38(%rax), %ecx
movl %ecx, -0x4c(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x88cf0
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x48(%rbp), %rdx
callq 0x5acb0
jmp 0x88c30
leaq -0x28(%rbp), %rdi
callq 0x162c0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x162c0
movq -0x38(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::perform_close()
void WebsockClient::perform_close() {
  WebsockCloseData close_data;
  close_data.code = (frame.payload[0] & 0xff) << 8;
  close_data.code |= frame.payload[1] & 0xff;
  if (frame.payload_len > 2)
    close_data.reason = std::string(
      frame.payload + 2, frame.payload_len);
  connection.close(Success);
  close_cb(close_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8c4e0
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rcx
movsbl (%rcx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
movw %cx, -0x30(%rbp)
movq 0x20(%rax), %rcx
movsbl 0x1(%rcx), %edx
andl $0xff, %edx
movzwl -0x30(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0x30(%rbp)
cmpq $0x2, 0x38(%rax)
jbe 0x894c5
movq -0x70(%rbp), %rcx
movq 0x20(%rcx), %rax
movq 0x38(%rcx), %rcx
movq %rcx, -0x80(%rbp)
addq $0x2, %rax
movq %rax, -0x88(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xcc80
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0xcea0
jmp 0x89489
leaq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
callq 0xc720
leaq -0x50(%rbp), %rdi
callq 0xcfb8
leaq -0x51(%rbp), %rdi
callq 0xcfa0
jmp 0x894c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xcfa0
jmp 0x8950f
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
leaq 0x527ac(%rip), %rsi     # 0xdbc80
callq 0x5ab80
jmp 0x894db
movq -0x70(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
leaq -0x30(%rbp), %rsi
callq 0x8c500
jmp 0x894f1
leaq -0x30(%rbp), %rdi
callq 0x8c540
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8c540
movq -0x60(%rbp), %rdi
callq 0xc8c0
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/src/ws.cc
// Function: cordpp::WebsockClient::close(unsigned short, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void WebsockClient::close(const uint16_t code, const std::string &reason) {
  if (!connection.is_connected()) return;
  char payload[2 + reason.size()];
  payload[0] = static_cast<char>((code >> 8) & 0xff);
  payload[1] = static_cast<char>(code & 0xff);
  std::memcpy(payload + 2, reason.c_str(), reason.size());
  send(payload, sizeof(payload), WebsockOp::close);
  state = WebsockState::closed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
callq 0x5a7b0
testb $0x1, %al
jne 0x89601
jmp 0x896ad
movq -0x18(%rbp), %rdi
callq 0xc420
movq %rax, %rdx
movq %rdx, %rcx
addq $0x2, %rcx
movq %rcx, -0x38(%rbp)
movq %rsp, %rax
movq %rax, -0x20(%rbp)
addq $0x11, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x40(%rbp)
movq %rax, %rsp
movq %rcx, -0x28(%rbp)
movzwl -0xa(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
movb %cl, (%rax)
movzwl -0xa(%rbp), %ecx
andl $0xff, %ecx
movb %cl, 0x1(%rax)
addq $0x2, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc190
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc420
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0xc0d0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rdi
movl $0x8, %ecx
callq 0x89060
movq -0x30(%rbp), %rax
movl $0x1, 0x398(%rax)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bobverity[P]MavericK/./misc.h
// Function: int sum<int>(std::vector<int, std::allocator<int>>&)
TYPE sum(std::vector<TYPE> &x) {
    TYPE output = 0;
    for (int i=0; i<int(x.size()); i++)
        output += x[i];
    return(output);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb030
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x8cdc
movq 0x10(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x8ba0
movl (%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x8c99
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: bobverity[P]MavericK/Hungarian.cpp
// Function: augmentLeft(int, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
vector<int> augmentLeft(int i, vector< vector<double> > &M, vector<int> &edgesRight, vector<int> &blockedLeft, vector<int> &blockedRight) {
    
    blockedLeft[i] = 1;
    vector<int> output(1,-1);
    
    // search all unmatched edges
    for (int j=0; j<int(M.size()); j++) {
        if (M[i][j]==0 && edgesRight[j]!=i && blockedRight[j]==0) {
            
            // if edge leads to augmented path then add current node to path and return
            output = augmentRight(j, M, edgesRight, blockedLeft, blockedRight);
            if (output[0]>=0) {
                output.push_back(i);
                return(output);
            }
        }
    }
    
    // if no more moves then return -1
    return(output);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movslq 0x8c(%rsp), %rsi
callq 0x8ba0
movl $0x1, (%rax)
movb $0x0, 0x67(%rsp)
movl $0xffffffff, 0x60(%rsp) # imm = 0xFFFFFFFF
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xc5e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movl $0x1, %esi
leaq 0x60(%rsp), %rdx
callq 0xc5f0
jmp 0xb1f9
leaq 0x5f(%rsp), %rdi
callq 0xc670
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xb35c
movq 0x80(%rsp), %rdi
movslq 0x8c(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x48(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb34a
jp 0xb34a
movq 0x78(%rsp), %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
movl (%rax), %eax
cmpl 0x8c(%rsp), %eax
je 0xb34a
movq 0x68(%rsp), %rdi
movslq 0x48(%rsp), %rsi
callq 0x8ba0
cmpl $0x0, (%rax)
jne 0xb34a
movl 0x48(%rsp), %esi
movq 0x80(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r9
leaq 0x30(%rsp), %rdi
callq 0xb3a0
jmp 0xb2c5
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6a0
leaq 0x30(%rsp), %rdi
callq 0xc6e0
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ba0
cmpl $0x0, (%rax)
jl 0xb348
movq 0x18(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
callq 0xc740
jmp 0xb305
movb $0x1, 0x67(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0xb369
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0xc670
jmp 0xb387
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0xc6e0
jmp 0xb387
jmp 0xb34a
jmp 0xb34c
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0xb20b
movb $0x1, 0x67(%rsp)
movl $0x1, 0x2c(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xb37a
movq 0x18(%rsp), %rdi
callq 0xc6e0
movq 0x10(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)