LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/./include/json.h
// Function: nlohmann::detail::parse_error::create(int, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static parse_error create(int id, std::size_t byte_, const std::string& what_arg)
    {
        std::string w = exception::name("parse_error", id) + "parse error" +
                        (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +
                        ": " + what_arg;
        return parse_error(id, byte_, w.c_str());
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x17b57(%rip), %rsi     # 0x3394a
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xc152
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl %ebp, %edx
callq 0xebba
leaq 0x17b3c(%rip), %rdx     # 0x33956
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xec9a
testq %rbx, %rbx
je 0x1be56
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1bfd2
leaq 0x17b1d(%rip), %rsi     # 0x33962
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xf155
jmp 0x1be6c
leaq 0x18a60(%rip), %rsi     # 0x348bd
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc152
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xecb9
leaq 0x16911(%rip), %rdx     # 0x3279e
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xec9a
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
movq %r15, %rdx
callq 0xeb9a
leaq 0xc8(%rsp), %rdi
callq 0xac38
leaq 0xa8(%rsp), %rdi
callq 0xac38
leaq 0x28(%rsp), %rdi
callq 0xac38
testq %rbx, %rbx
je 0x1beed
leaq 0x8(%rsp), %rdi
callq 0xac38
leaq 0x88(%rsp), %rdi
callq 0xac38
leaq 0x68(%rsp), %rdi
callq 0xac38
leaq 0x48(%rsp), %rdi
callq 0xac38
movq 0xe8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1c014
leaq 0xe8(%rsp), %rdi
callq 0xac38
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1bf48
movq %rax, %r14
jmp 0x1bf90
movq %rax, %r14
jmp 0x1bf9a
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
jmp 0x1bfb6
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0xac38
jmp 0x1bf6f
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xac38
jmp 0x1bf81
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xac38
testq %rbx, %rbx
je 0x1bf9a
leaq 0x8(%rsp), %rdi
callq 0xac38
leaq 0x88(%rsp), %rdi
callq 0xac38
leaq 0x68(%rsp), %rdi
callq 0xac38
leaq 0x48(%rsp), %rdi
callq 0xac38
movq %r14, %rdi
callq 0xa6c0
movq %rax, %r14
jmp 0x1bfa7
movq %rax, %r14
jmp 0x1bfb1
movq %rax, %r14
jmp 0x1bfbb
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/./include/json.h
// Function: nlohmann::detail::input_adapter::input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, 0>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
input_adapter(IteratorType first, IteratorType last)
    {
        // assertion to check that the iterator range is indeed contiguous,
        // see http://stackoverflow.com/a/35008842/266378 for more discussion
        assert(std::accumulate(
                   first, last, std::pair<bool, int>(true, 0),
                   [&first](std::pair<bool, int> res, decltype(*first) val)
        {
            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
            return res;
        }).first);

        // assertion to check that each element is 1 byte long
        static_assert(
            sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
            "each element in the iterator range must have the size of 1 byte");

        const auto len = static_cast<size_t>(std::distance(first, last));
        if (JSON_LIKELY(len > 0))
        {
            // there is at least one element: use the address of first
            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
        }
        else
        {
            // the address of first cannot be used: use nullptr
            ia = std::make_shared<input_buffer_adapter>(nullptr, len);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rsi, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1c1c5
testb $0x1, %al
je 0x1c18b
movq 0x20(%rsp), %rax
subq %rax, %r14
movq %r14, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
je 0x1c178
movq %rax, (%rsi)
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
callq 0x1c223
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1c4bc
leaq 0x8(%rsp), %rdi
callq 0xe33a
addq $0x28, %rsp
popq %rbx
popq %r14
retq
andq $0x0, (%rsi)
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
callq 0x1c244
jmp 0x1c15b
leaq 0x177d5(%rip), %rdi     # 0x33967
leaq 0x1519f(%rip), %rsi     # 0x31338
leaq 0x1789e(%rip), %rcx     # 0x33a3e
movl $0x5e0, %edx            # imm = 0x5E0
callq 0xa1a0
jmp 0x1c1ae
jmp 0x1c1ae
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xe33a
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/./include/json.h
// Function: nlohmann::detail::iter_impl<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>>::operator==(nlohmann::detail::iter_impl<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>> const&) const
bool operator==(const iter_impl& other) const
    {
        // if objects are not the same, the comparison is undefined
        if (JSON_UNLIKELY(m_object != other.m_object))
        {
            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
        }

        assert(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
                return (m_it.object_iterator == other.m_it.object_iterator);

            case value_t::array:
                return (m_it.array_iterator == other.m_it.array_iterator);

            default:
                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x1c602
testq %rax, %rax
je 0x1c650
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x1c5e4
cmpl $0x1, %eax
jne 0x1c5ee
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x1c5f6
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x1c5f6
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xa3c0
movq %rax, %rbx
leaq 0x174ca(%rip), %rsi     # 0x33ade
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xc152
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xd4, %esi
callq 0x1c696
xorl %ebp, %ebp
leaq 0x33e8f(%rip), %rsi     # 0x504d0
leaq -0xd4ae(%rip), %rdx     # 0xf19a
movq %rbx, %rdi
callq 0xa690
leaq 0x174b8(%rip), %rdi     # 0x33b0f
leaq 0x14cda(%rip), %rsi     # 0x31338
leaq 0x174be(%rip), %rcx     # 0x33b23
movl $0xf17, %edx            # imm = 0xF17
callq 0xa1a0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xac38
testb %bpl, %bpl
jne 0x1c686
jmp 0x1c68e
movq %rax, %r14
movq %rbx, %rdi
callq 0xa8d0
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/src/guild.cc
// Function: cordpp::Guild::Guild()
Guild::Guild() : Item() {
  _roles.cache_size(10);
  _emojis.cache_size(10);
  _members.cache_size(10);
  _channels.cache_size(10);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, (%rdi)
addq $0x8, %rdi
callq 0xf42c
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
xorl %eax, %eax
movb %al, 0x58(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
movb %al, 0x78(%rbx)
leaq 0x98(%rbx), %rcx
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movb %al, 0x98(%rbx)
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
leaq 0xf0(%rbx), %r14
movq %r14, %rdi
callq 0x1d09c
leaq 0x128(%rbx), %r15
movq %r15, %rdi
callq 0x1d102
leaq 0x160(%rbx), %r12
movq %r12, %rdi
callq 0x1d168
leaq 0x198(%rbx), %rbp
movq %rbp, %rdi
callq 0x1d1ce
leaq 0x1e8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x200(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x208(%rbx)
movups %xmm0, 0x1f8(%rbx)
movups %xmm0, 0x1e8(%rbx)
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x1d234
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x1d2ec
pushq $0xa
popq %rsi
movq %r12, %rdi
callq 0x1d3a4
pushq $0xa
popq %rsi
movq %rbp, %rdi
callq 0x1d45c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
jmp 0x1cf85
movq %rax, 0x8(%rsp)
jmp 0x1cf8d
movq %rax, 0x8(%rsp)
jmp 0x1cf95
movq %rax, 0x8(%rsp)
jmp 0x1cf9d
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x1d514
movq 0x10(%rsp), %rdi
callq 0xca5c
movq %rbp, %rdi
callq 0x1d536
movq %r12, %rdi
callq 0x1d54c
movq %r15, %rdi
callq 0x1d562
movq %r14, %rdi
callq 0x1d578
leaq 0x48(%rbx), %r14
leaq 0x68(%rbx), %r15
leaq 0x88(%rbx), %r12
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0xac38
movq %r12, %rdi
callq 0xac38
movq %r15, %rdi
callq 0xac38
movq %r14, %rdi
callq 0xac38
movq 0x8(%rsp), %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/src/http.cc
// Function: cordpp::RestClient::request(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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> const&, std::function<void (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> const&)> const&)
void RestClient::request(const std::string &method, const std::string &endpoint,
  const std::string &audit, const Json &data, const JsonAction &action)
{
  Request request{data, method, endpoint, audit};
  RestTask task{request, action};
  if (!conn->is_connected())
    tasks.push_back(task);
  else
    perform_task(task);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r9, %r14
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %r8, %rsi
callq 0x1929a
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xa580
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xa580
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0xa580
leaq 0x78(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1f148
leaq 0xe8(%rsp), %rdi
movq %r14, %rsi
callq 0x1f1c4
movq 0x128(%rbx), %rdi
callq 0x20eda
testb %al, %al
je 0x1d896
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x1dba6
jmp 0x1d8aa
addq $0xd8, %rbx
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f20a
leaq 0x78(%rsp), %rdi
callq 0xe1a8
leaq 0x8(%rsp), %rdi
callq 0xe1be
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xe1be
jmp 0x1d91a
movq %rax, %rbx
jmp 0x1d91a
movq %rax, %rbx
movq %r13, %rdi
callq 0xac38
jmp 0x1d8f4
movq %rax, %rbx
movq %r15, %rdi
callq 0xac38
jmp 0x1d901
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc8b0
jmp 0x1d924
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xe1a8
leaq 0x8(%rsp), %rdi
callq 0xe1be
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rsi
leaq 0x16b5a(%rip), %rdx     # 0x34617
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1f08f
addq $0x30, %rbx
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xeb9a
leaq 0x20(%rsp), %rdi
callq 0xac38
leaq 0x148(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1fae2
addq $0x150, %r14            # imm = 0x150
cmpq %r14, %rax
jne 0x1db52
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r14
movaps %xmm0, 0x38(%r14)
movaps %xmm0, 0x28(%r14)
movaps %xmm0, 0x18(%r14)
movaps %xmm0, 0x8(%r14)
movaps %xmm0, -0x8(%r14)
andq $0x0, 0x48(%r14)
movq %r14, %rdi
callq 0x1f5ae
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1f0c8
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1f12e
movq %r14, %rdi
callq 0xca98
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1f0c8
movq %rax, %rbx
movq %rsp, %rdi
callq 0xac38
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xca98
jmp 0x1db8c
jmp 0x1db89
jmp 0x1db89
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x1db99
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xac38
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1daa0
cmpb $0x1, (%rax)
jne 0x1dbca
addq $0x8, %rax
movq %rax, %rdi
jmp 0x1dbde
cmpb $0x1, 0x80(%r14)
jne 0x1dbf1
addq $0x88, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f20a
movq 0x128(%r14), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1dc54
movq %r15, %rdi
movq %r12, %rsi
callq 0x20f4c
leaq 0x8(%rsp), %rdi
callq 0xac38
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f20a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xac38
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x1f23a
leaq 0x88(%rbx), %r15
movq %r15, %rdi
callq 0x1f5ae
leaq 0xd8(%rbx), %r12
movq %r12, %rdi
callq 0x1f5ae
andl $0x0, 0x150(%rbx)
leaq 0x150(%rbx), %rax
andq $0x0, 0x158(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x128(%rbx)
movups %xmm0, 0x138(%rbx)
movq %rax, 0x160(%rbx)
movq %rax, 0x168(%rbx)
andq $0x0, 0x170(%rbx)
leaq 0x128(%rbx), %r13
movb $0x0, 0x80(%rbx)
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1f266
leaq 0x8(%rsp), %rbp
movq (%rbp), %rsi
andq $0x0, (%rbp)
movq %r13, %rdi
callq 0x1f7a4
movq %rbp, %rdi
callq 0xca7e
movq 0x128(%rbx), %rdi
andq $0x0, 0x8(%rbp)
movq %rbx, (%rbp)
leaq 0x674(%rip), %rax       # 0x1e69c
movq %rax, 0x18(%rbp)
leaq 0x6bf(%rip), %rax       # 0x1e6f2
movq %rax, 0x10(%rbp)
leaq 0x8(%rsp), %rsi
callq 0x20ed0
leaq 0x8(%rsp), %rdi
callq 0xe8c8
movq %rbx, %rdi
callq 0x1e0d4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e074
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0xe8c8
jmp 0x1e078
movq %rax, (%rsp)
leaq 0x130(%rbx), %rbp
leaq 0x148(%rbx), %rdi
callq 0xcafe
movq %rbp, %rdi
callq 0xca5c
movq %r13, %rdi
callq 0xca7e
movq %r12, %rdi
callq 0xca98
jmp 0x1e0a9
movq %rax, (%rsp)
movq %r15, %rdi
callq 0xca98
jmp 0x1e0b7
movq %rax, (%rsp)
addq $0x8, %rbx
movq %r14, %rdi
callq 0xcae4
movq %rbx, %rdi
callq 0xac38
movq (%rsp), %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x1f2e0
movb $0x0, (%rbx)
leaq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x1f2fa
movq %rax, %r13
subq $0x1, %r13
jb 0x1e190
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x1f30a
movq %r12, %rdi
callq 0x1f334
movq %r14, %rdi
movq %r15, %rsi
callq 0x1dba6
jmp 0x1e169
movq %rsp, %rdi
callq 0xe1a8
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe1a8
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x205b8
cmpb $0x1, (%r15)
jne 0x1f455
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xf1ba
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
movq %rsi, 0x40(%rdi)
andl $0x0, 0xc(%rdi)
andq $0x0, 0x38(%rdi)
andw $0x0, 0x8(%rdi)
movb %al, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rsi, %r15
movb $0x0, 0x20(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x1d09c
movq %r15, 0x70(%rbx)
movb $0x0, 0x8(%rbx)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x1d234
movb $0x0, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x1d578
jmp 0x209c5
movq %rax, %r15
addq $0x10, %rbx
movq %rbx, %rdi
callq 0xac38
movq %r15, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/src/ssl.cc
// Function: cordpp::Service::call_later(long, void*, std::function<void (void*)> const&)
void Service::call_later(const long delay, void *data, const RawAction &action)
{
  new Timer(service, delay, data, action, [](Timer *timer) {
    const RawAction &action = std::move(timer->get());
    action(timer->raw());
    delete timer;
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0xb8, %edi
callq 0xa170
movq %rax, %rbx
addq $0x18, %r13
xorps %xmm0, %xmm0
movq %rsp, %r9
movaps %xmm0, (%r9)
leaq 0x5295(%rip), %rax      # 0x25e84
movq %rax, 0x18(%r9)
leaq 0x52b0(%rip), %rax      # 0x25eaa
movq %rax, 0x10(%r9)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x20c48
movq %rsp, %rdi
callq 0xe8c8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0xe8c8
movl $0xb8, %esi
movq %rbx, %rdi
callq 0xa110
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x14e2e
leaq 0x98(%r12), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%r12)
movups %xmm0, 0x98(%r12)
movq %r15, (%r12)
movq %rdi, %r15
movq %rbx, %rsi
callq 0x262b8
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x26306
imulq $0x3e8, %r13, %rax      # imm = 0x3E8
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x1277a
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
movq 0x28(%r12), %r13
movq %rsi, 0x8(%rsp)
pushq $0x60
popq %rdi
xorl %eax, %eax
callq 0x129fb
movq %rax, %rbp
movq %rax, 0x10(%rsp)
andq $0x0, (%rax)
leaq 0x808(%rip), %rax       # 0x2150c
movq %rax, 0x8(%rbp)
andl $0x0, 0x10(%rbp)
leaq 0x68(%r12), %rsi
andl $0x0, 0x18(%rbp)
leaq 0x30(%r12), %rbx
movb $0x0, 0x1c(%rbp)
leaq 0x2e64b(%rip), %rax     # 0x4f370
movq %rax, 0x20(%rbp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rbp)
movq %rbp, %rdi
addq $0x30, %rdi
callq 0x13250
movq %rbp, 0x18(%rsp)
movb $0x1, 0x38(%r12)
movq 0x68(%r13), %rdi
addq $0x28, %r13
addq $0x40, %r12
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %rbp, %r8
callq 0x12962
leaq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x214fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x214fc
jmp 0x20da5
jmp 0x20da2
jmp 0x20da2
movq %rax, %r12
jmp 0x20db5
movq %rax, %r12
movq %r15, %rdi
callq 0xe8c8
movq %r14, %rdi
callq 0xce80
movq (%rsp), %rdi
callq 0xe8c8
movq %r12, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x58(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
pushq $-0x1
popq %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x26354
leaq 0xb8(%r14), %r12
leaq 0x18(%r13), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x263f0
leaq 0x258(%r14), %r13
movq %r13, %rdi
callq 0x26fbe
andq $0x0, 0x10(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x507d(%rip), %rax      # 0x25ec2
movq %rax, 0x18(%rsi)
leaq 0x5074(%rip), %rax      # 0x25ec4
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1369c
movq %rsp, %rdi
callq 0xe8c8
movq %r12, %rdi
xorl %esi, %esi
callq 0x26462
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
jmp 0x20e8d
movq %rax, %rbp
movq %rsp, %rdi
callq 0xe8c8
movq %r13, %rdi
callq 0xcc30
jmp 0x20e9a
movq %rax, %rbp
movq %r12, %rdi
callq 0xcc7c
jmp 0x20ea7
movq %rax, %rbp
movq %r15, %rdi
callq 0xcc92
jmp 0x20eb4
movq %rax, %rbp
addq $0x38, %r14
movq %r14, %rdi
callq 0xe8c8
movq %rbx, %rdi
callq 0xe8c8
movq %rbp, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %r14
cmpb $0x1, 0x4(%rsi)
jne 0x20f95
movq %r14, %rdi
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21194
movq %rdx, %rbx
leaq 0x258(%r14), %rdi
movq 0x268(%r14), %rax
xorps %xmm1, %xmm1
movaps %xmm1, 0x70(%rsp)
andq $0x0, 0x80(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x20fe3
movups (%rax), %xmm0
addq $0x10, %rax
movaps %xmm0, 0x70(%rsp)
movq %rcx, 0x80(%rsp)
movups %xmm1, (%rax)
callq 0x2649a
addq 0x10(%r14), %rbx
andq $0x0, 0x10(%r14)
movq 0x68(%r14), %r13
movq 0x80(%r14), %rbp
leaq 0xa0(%rsp), %rax
movq %r13, -0x10(%rax)
subq %r13, %rbp
leaq 0x90(%rsp), %r12
cmoveq %rax, %r12
movq %rbp, -0x8(%rax)
leaq 0x100(%rsp), %rax
leaq 0xf0(%rsp), %rcx
movq %rcx, %rdx
cmoveq %rax, %rdx
leaq 0x100(%rsp), %r15
movq %r13, (%r15)
movq %rbp, 0x8(%r15)
andq $0x0, 0x10(%r15)
movq %r13, -0x10(%rax)
movq %rbp, -0x8(%rax)
movq %rcx, 0x18(%r15)
movq %rdx, 0x20(%r15)
movq %rax, 0x28(%r15)
andq $0x0, 0x30(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2efa6
movq %r13, 0xb8(%rsp)
movq %rbp, 0xc0(%rsp)
andq $0x0, 0xc8(%rsp)
leaq 0x90(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq %r12, 0xd8(%rsp)
leaq 0xa0(%rsp), %rax
movq %rax, 0xe0(%rsp)
andq $0x0, 0xe8(%rsp)
leaq 0xa0(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x30(%r15), %rax
movq %rax, 0x68(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x58(%rsp)
movups %xmm1, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0xb8(%rsp), %xmm0
movups 0xc8(%rsp), %xmm1
movups 0xd8(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2f120
addq $0x58, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x264c4
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x264fa
leaq 0xa0(%rsp), %rdi
callq 0xdaf2
leaq 0x70(%rsp), %rdi
callq 0xe8c8
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21171
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xdaf2
leaq 0x70(%rsp), %rdi
callq 0xe8c8
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, (%rdi)
jne 0x21278
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x258, %rdi            # imm = 0x258
callq 0x2650e
leaq -0x2ea(%rip), %rax      # 0x20f62
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
andq $0x0, 0x8(%rcx)
leaq 0xb8(%rbx), %rdi
movq %rbx, 0x10(%rcx)
addq $0x58, %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x26538
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, (%rdi)
jne 0x212f6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
addq $0x258, %rdi            # imm = 0x258
movq %rdx, %rsi
callq 0x2650e
leaq 0x58(%rbx), %r14
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2654c
movq 0x80(%rbx), %rax
subq 0x68(%rbx), %rax
movq %rax, 0x10(%rbx)
leaq -0x363(%rip), %rdx      # 0x20f62
movq %rsp, %rcx
movq %rdx, (%rcx)
andq $0x0, 0x8(%rcx)
subq %rax, %r15
movq %rbx, 0x10(%rcx)
addq $0xb8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2656a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, (%rdi)
jne 0x21350
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x258, %rdi            # imm = 0x258
movq %rdx, %rsi
callq 0x2650e
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq -0x3c5(%rip), %rax      # 0x20f62
movq %rsp, %r8
movq %rax, (%r8)
andq $0x0, 0x8(%r8)
leaq 0xb8(%rbx), %rdi
movq %rbx, 0x10(%r8)
addq $0x58, %rbx
movq %rbx, %rsi
callq 0x2657e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpb $0x0, (%rdi)
jne 0x2149f
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
movq %rcx, %rsi
callq 0x1369c
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0xed20
leaq 0x38(%rsp), %rdi
pushq $0x20
popq %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x265b6
movq %rsp, %r14
movq %r14, %rdi
callq 0xac38
movq 0x8(%rbx), %rax
movq 0x28(%rax), %r15
leaq 0x20(%rsp), %rsi
movq %rbx, (%rsi)
movq (%r15), %rbx
movq %rsi, (%r14)
movl $0xf0, %edi
xorl %eax, %eax
callq 0x129fb
movq %rax, %r14
leaq 0x8(%r15), %rsi
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2ce18
movq 0x28(%rbx), %r13
andq $0x0, (%r14)
leaq 0x27f9(%rip), %rax      # 0x23bf4
movq %rax, 0x8(%r14)
andl $0x0, 0x10(%r14)
andl $0x0, 0x18(%r14)
movb $0x0, 0x1c(%r14)
leaq 0x2df5b(%rip), %rax     # 0x4f370
movq %rax, 0x20(%r14)
leaq 0x28(%r14), %rdi
movq %r12, %rsi
callq 0x2e102
leaq 0x38(%r14), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2ce4c
addq $0x28, %rbx
addq $0x18, %r15
movq %r13, 0xa8(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0xb0(%r14)
movq %r14, %rdi
addq $0xb8, %rdi
movq %r15, %rsi
callq 0x13250
andq $0x0, 0xe8(%r14)
movq %r14, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2e136
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2cdbe
leaq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rsp, %rdi
callq 0x23be4
leaq 0x38(%rsp), %rdi
callq 0x26622
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x214cf
movq %rax, %rbx
addq $0x30, %r14
movq %r14, %rdi
callq 0x2e136
leaq 0x30(%rsp), %rdi
callq 0x2e136
movq %rsp, %rdi
callq 0x23be4
jmp 0x214dc
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x26622
jmp 0x214f3
movq %rax, %rbx
movq %rsp, %rdi
callq 0xac38
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x80(%rdi), %rcx
movq %rcx, 0x70(%rdi)
andq $0x0, 0x78(%rdi)
movb %al, 0x80(%rdi)
movq %rsi, 0x90(%rdi)
andw $0x0, 0x8(%rdi)
movb %al, 0xa(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x20dc6
leaq 0x2e8(%rbx), %r15
leaq 0x308(%rbx), %r12
leaq 0x328(%rbx), %r13
leaq 0x348(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x338(%rbx)
movups %xmm0, 0x328(%rbx)
movups %xmm0, 0x318(%rbx)
movups %xmm0, 0x308(%rbx)
movups %xmm0, 0x2f8(%rbx)
movups %xmm0, 0x2e8(%rbx)
movq %rbp, %rdi
movq %r14, 0x20(%rsp)
callq 0x30638
andq $0x0, 0x20(%rbx)
movl $0x1, 0x398(%rbx)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x7c3(%rip), %rax       # 0x2fef0
movq %rax, 0x18(%rsi)
leaq 0x7ba(%rip), %rax       # 0x2fef2
movq %rax, 0x10(%rsi)
movq %r12, %rdi
callq 0x1369c
movq %rsp, %r14
movq %r14, %rdi
callq 0xe8c8
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x7ad(%rip), %rax       # 0x2ff0a
movq %rax, 0x18(%r14)
leaq 0x7a4(%rip), %rax       # 0x2ff0c
movq %rax, 0x10(%r14)
movq %rsp, %rsi
movq %r13, %rdi
callq 0x13730
movq %rsp, %r14
movq %r14, %rdi
callq 0xe8c8
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x794(%rip), %rax       # 0x2ff24
movq %rax, 0x18(%r14)
leaq 0x78b(%rip), %rax       # 0x2ff26
movq %rax, 0x10(%r14)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x137c4
movq %rsp, %rdi
callq 0xe8c8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f7c5
jmp 0x2f7c5
movq %rax, %r14
movq %rsp, %rdi
callq 0xe8c8
movq %rbp, %rdi
callq 0xe87c
jmp 0x2f7dd
movq %rax, %r14
movq %r13, %rdi
callq 0xe8c8
movq %r12, %rdi
callq 0xe8c8
movq %r15, %rdi
callq 0xe8c8
movq 0x20(%rsp), %rdi
callq 0xcbf4
jmp 0x2f804
movq %rax, %r14
movq %rbx, %rdi
callq 0xdaf2
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0xa480
movq %rax, 0x20(%rbx)
leaq 0x8(%rsp), %rdx
andq $0x0, 0x8(%rdx)
movq %rbx, (%rdx)
addq $0x40, %rbx
leaq 0xa7c(%rip), %rax       # 0x30450
movq %rax, 0x18(%rdx)
leaq 0xac3(%rip), %rax       # 0x304a2
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2127a
leaq 0x8(%rsp), %rdi
callq 0xe8c8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe8c8
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x20eda
testb %al, %al
je 0x2feca
movq %rsp, -0x30(%rbp)
movq 0x8(%r14), %rax
leaq 0x2(%rax), %r12
movq %rsp, %rcx
addq $0x11, %rax
andq $-0x10, %rax
movq %rcx, %r13
subq %rax, %r13
movq %r13, %rsp
negq %rax
rolw $0x8, %r15w
movw %r15w, (%rcx,%rax)
leaq 0x2(%r13), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xa090
pushq $0x8
popq %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2fb94
movl $0x1, 0x398(%rbx)
movq -0x30(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x511f
addl (%rcx,%rsi,4), %eax
incq %rsi
jmp 0x5112
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %rcx, %rbp
movq %rdx, %r13
movl %esi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movslq %esi, %r14
movq %r8, 0x28(%rsp)
movq (%r8), %rax
movl $0x1, (%rax,%r14,4)
leaq 0x30(%rsp), %rbx
orl $-0x1, (%rbx)
pushq $0x1
popq %rsi
leaq 0xf(%rsp), %rcx
movq %rdi, 0x10(%rsp)
movq %rbx, %rdx
callq 0x5f08
xorl %r15d, %r15d
imulq $0x18, %r14, %r14
movq %rbp, 0x20(%rsp)
movq (%r13), %rcx
movq 0x8(%r13), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r15
jge 0x5720
movq (%rcx,%r14), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd 0x219d1(%rip), %xmm0    # 0x27078
jne 0x5709
jp 0x5709
movq (%rbp), %rax
movl 0x18(%rsp), %ecx
cmpl %ecx, (%rax,%r15,4)
je 0x5709
movq (%r12), %rax
cmpl $0x0, (%rax,%r15,4)
jne 0x5709
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
movq %rbp, %rcx
movq 0x28(%rsp), %r8
movq %r12, %rbp
movq %r12, %r9
callq 0x574b
movq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6266
movq %rbx, %rdi
callq 0x61d0
movq (%r12), %rax
cmpl $0x0, (%rax)
movq %rbp, %r12
movq 0x20(%rsp), %rbp
jns 0x5711
incq %r15
jmp 0x5677
leaq 0x1c(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x5f5e
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5736
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/Hungarian.cpp
// Function: augmentRight(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> augmentRight(int j, vector< vector<double> > &M, vector<int> &edgesRight, vector<int> &blockedLeft, vector<int> &blockedRight) {
    
    blockedRight[j] = 1;
    vector<int> output(1);
    
    // if node j is unmatched then return j as start of augmented path
    if (edgesRight[j]<0) {
        output[0] = j;
        return(output);
    }
    
    // otherwise continue chain of augmenting
    output = augmentLeft(edgesRight[j], M, edgesRight, blockedLeft, blockedRight);
    if (output[0]>=0) {
        output.push_back(j);
    }
    return(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movslq %esi, %r15
movq (%r9), %rax
movl $0x1, (%rax,%r15,4)
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x5f7c
movq (%r12), %rax
movl (%rax,%r15,4), %esi
testl %esi, %esi
js 0x57de
leaq 0x10(%rsp), %rdi
movq %r13, %rdx
movq %r12, %rcx
movq 0x8(%rsp), %r8
movq %r14, %r9
callq 0x561c
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6266
movq %r14, %rdi
callq 0x61d0
movq (%rbx), %rax
cmpl $0x0, (%rax)
js 0x57e3
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x5f5e
jmp 0x57e3
movq (%rbx), %rax
movl %ebp, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::updateQmatrix(int)
void MCMCobject_admixture::updateQmatrix(int rep) {
    
    // add logQmatrix_gene_new to logQmatrix_gene_running
    for (int i=0; i<geneCopies; i++) {
        for (int k=0; k<K; k++) {
            logQmatrix_gene_running[i][k] = logSum(logQmatrix_gene_running[i][k], logQmatrix_gene_new[i][k]);
        }
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x70(%rbx), %rax
cmpq %rax, %r14
jge 0x916d
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jge 0x9168
movq 0x298(%rbx), %rax
movq 0x2c8(%rbx), %rcx
movq (%rcx,%r15), %rcx
movsd (%rcx,%r12,8), %xmm0
movq (%rax,%r15), %rax
movsd (%rax,%r12,8), %xmm1
callq 0x14ce5
movq 0x2c8(%rbx), %rax
movq (%rax,%r15), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x9122
incq %r14
jmp 0x9112
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/MCMCobject_admixture.cpp
// Function: MCMCobject_admixture::storeQmatrix()
void MCMCobject_admixture::storeQmatrix() {
    
    // store individual-level Qmatrix
    groupIndex=-1;
    for (int ind=0; ind<n; ind++) {
        for (int l=0; l<loci; l++) {
            for (int p=0; p<ploidy_vec[ind]; p++) {
                groupIndex++;
                for (int k=0; k<K; k++) {
                    logQmatrix_gene[groupIndex][k] = logSum(logQmatrix_gene[groupIndex][k], logQmatrix_gene_new[groupIndex][k]);
                }
            }
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
orl $-0x1, 0x108(%rdi)
pushq $-0x1
popq %rax
xorl %r14d, %r14d
movslq 0x20(%rbx), %rcx
cmpq %rcx, %r14
jge 0x9226
xorl %ebp, %ebp
cmpl 0x24(%rbx), %ebp
jge 0x921e
xorl %r15d, %r15d
movq 0x40(%rbx), %rcx
cmpl (%rcx,%r14,4), %r15d
jge 0x921a
incl %eax
movl %eax, 0x108(%rbx)
xorl %r12d, %r12d
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %r12
jge 0x9215
cltq
movq 0x298(%rbx), %rcx
movq 0x2e0(%rbx), %rdx
imulq $0x18, %rax, %rax
movq (%rdx,%rax), %rdx
movsd (%rdx,%r12,8), %xmm0
movq (%rcx,%rax), %rax
movsd (%rax,%r12,8), %xmm1
callq 0x14ce5
movslq 0x108(%rbx), %rax
movq 0x2e0(%rbx), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %rcx
movsd %xmm0, (%rcx,%r12,8)
incq %r12
jmp 0x91be
incl %r15d
jmp 0x91a9
incl %ebp
jmp 0x91a1
incq %r14
jmp 0x9192
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop