LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Client::send(httplib::Request&, httplib::Response&)
inline bool Client::send(Request &req, Response &res) {
        if (req.path.empty()) { return false; }

        auto sock = create_client_socket();
        if (sock == INVALID_SOCKET) { return false; }

        return read_and_close_socket(sock, req, res);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x68(%rsi)
je 0x16593
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x16d2e
cmpl $-0x1, %eax
je 0x16593
movq (%r15), %rcx
movq 0x18(%rcx), %r8
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::set_nonblocking(int, bool)
inline void set_nonblocking(socket_t sock, bool nonblocking) {
#ifdef _WIN32
            auto flags = nonblocking ? 1UL : 0UL;
            ioctlsocket(sock, FIONBIO, &flags);
#else
            auto flags = fcntl(sock, F_GETFL, 0);
            fcntl(sock, F_SETFL,
                    nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK)));
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x82e0
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
shll $0xb, %ebx
orl %eax, %ebx
pushq $0x4
popq %rsi
movl %r14d, %edi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x82e0
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::wait_until_socket_is_ready(int, long, long)
inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
            fd_set fdsr;
            FD_ZERO(&fdsr);
            FD_SET(sock, &fdsr);

            auto fdsw = fdsr;
            auto fdse = fdsr;

            timeval tv;
            tv.tv_sec = static_cast<long>(sec);
            tv.tv_usec = static_cast<long>(usec);

            if (select(static_cast<int>(sock + 1), &fdsr, &fdsw, &fdse, &tv) < 0) {
                return false;
            } else if (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw)) {
                int error = 0;
                socklen_t len = sizeof(error);
                if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&error, &len) < 0 ||
                        error) {
                    return false;
                }
            } else {
                return false;
            }

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rsi, %r9
movl %edi, %ebx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x16f36
andq $0x0, -0xb8(%rbp,%rax,8)
incq %rax
jmp 0x16f22
pushq $0x40
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
movslq %eax, %r15
shll $0x6, %eax
movl %ebx, %ecx
subl %eax, %ecx
pushq $0x1
popq %r12
shlq %cl, %r12
orq %r12, -0xb8(%rbp,%r15,8)
pushq $0x10
popq %rax
leaq -0x138(%rbp), %rdx
leaq -0xb8(%rbp), %r10
movq %rax, %rcx
movq %rdx, %rdi
movq %r10, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x1b8(%rbp), %r11
movq %rax, %rcx
movq %r11, %rdi
movq %r10, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x38(%rbp), %r8
movq %r9, (%r8)
movq %r14, 0x8(%r8)
leal 0x1(%rbx), %edi
movq %r10, %rsi
movq %r11, %rcx
callq 0x8520
testl %eax, %eax
js 0x16feb
testq %r12, -0xb8(%rbp,%r15,8)
jne 0x16fb8
testq %r12, -0x138(%rbp,%r15,8)
je 0x16feb
leaq -0x28(%rbp), %r14
andl $0x0, (%r14)
leaq -0x24(%rbp), %r8
movl $0x4, (%r8)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
movq %r14, %rcx
callq 0x8420
testl %eax, %eax
setns %cl
cmpl $0x0, (%r14)
sete %al
andb %cl, %al
jmp 0x16fed
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./client.hpp
// Function: P2PClient::GetFileSize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int64_t GetFileSize(std::string host, std::string& name)
    {
      int64_t fsize = -1;
      Client client(host.c_str(), _srv_port);
      std::string path = "/list/" + name;
      auto rsp = client.Head(path.c_str());
      if(rsp && rsp->status == 200)
      {
        if(!rsp->has_header("Content-Length"))
        {
          return -1;
        }
        std::string len = rsp->get_header_value("Content-Length");
        std::stringstream tmp;
        tmp << len;
        tmp >> fsize;
      }
      return fsize;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %rbx
orq $-0x1, -0x10(%rbp)
movq (%rsi), %rsi
movl 0x4(%rdi), %edx
leaq -0xb8(%rbp), %rdi
movl $0x12c, %ecx            # imm = 0x12C
callq 0x160f4
leaq 0xc378(%rip), %rsi      # 0x24dd0
leaq -0x60(%rbp), %rdi
movq %rbx, %rdx
callq 0x19181
movq -0x60(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x191f8
movq -0x20(%rbp), %rdi
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x18af8
cmpl $0xc8, 0x20(%rdi)
jne 0x18af8
leaq 0xc1d6(%rip), %rsi      # 0x24c6a
callq 0x19252
testb %al, %al
je 0x18af8
movq -0x20(%rbp), %rsi
leaq 0xc1c2(%rip), %rdx      # 0x24c6a
leaq -0x40(%rbp), %rdi
xorl %ecx, %ecx
callq 0x192b6
leaq -0x240(%rbp), %rdi
callq 0x83c0
leaq -0x230(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x84b0
leaq -0x240(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8570
leaq -0x240(%rbp), %rdi
callq 0x8410
leaq -0x40(%rbp), %rdi
callq 0x8aa8
movq -0x10(%rbp), %rbx
leaq -0x18(%rbp), %rdi
callq 0x140c0
leaq -0x60(%rbp), %rdi
callq 0x8aa8
leaq -0xb8(%rbp), %rdi
callq 0x8e2c
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x18b39
jmp 0x18b44
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x8410
leaq -0x40(%rbp), %rdi
callq 0x8aa8
jmp 0x18b47
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x140c0
jmp 0x18b55
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x8aa8
jmp 0x18b63
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x8e2c
movq %rbx, %rdi
callq 0x8990
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Client::Head(char const*, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, httplib::detail::ci, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
inline std::shared_ptr<Response> Client::Head(const char *path,
            const Headers &headers) {
        Request req;
        req.method = "HEAD";
        req.headers = headers;
        req.path = path;

        auto res = std::make_shared<Response>();

        return send(req, *res) ? res : nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
leaq -0x190(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %r8d, %r8d
movb %r8b, (%rax)
leaq -0x170(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r8b, (%rax)
leaq -0x150(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r8b, (%rax)
leaq -0x130(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r8b, (%rax)
leaq -0x118(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rcx, %r12
movq %rdx, %r15
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r8b, (%rax)
leaq -0xc8(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x98(%rbp), %rax
andl $0x0, (%rax)
movq %rsi, %r14
andq $0x0, 0x8(%rax)
movq %rdi, %rbx
leaq -0x180(%rbp), %rdi
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x60(%rax)
leaq 0xb87e(%rip), %rsi      # 0x24c65
callq 0x8a40
leaq -0x120(%rbp), %rdi
movq %r12, %rsi
callq 0x1674a
leaq -0x140(%rbp), %rdi
movq %r15, %rsi
callq 0x8a40
leaq -0x30(%rbp), %rdi
callq 0x16534
movq -0x30(%rbp), %rdx
leaq -0x1a0(%rbp), %rsi
movq %r14, %rdi
callq 0x16550
testb %al, %al
je 0x19438
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x16ffe
jmp 0x1943e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x140c0
leaq -0x1a0(%rbp), %rdi
callq 0x165a0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x140c0
jmp 0x19479
jmp 0x19476
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x165a0
movq %rbx, %rdi
callq 0x8990
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::get_remote_addr[abi:cxx11](int)
inline std::string get_remote_addr(socket_t sock) {
            struct sockaddr_storage addr;
            socklen_t len = sizeof(addr);

            if (!getpeername(sock, (struct sockaddr *)&addr, &len)) {
                char ipstr[NI_MAXHOST];

                if (!getnameinfo((struct sockaddr *)&addr, len, ipstr, sizeof(ipstr),
                            nullptr, 0, NI_NUMERICHOST)) {
                    return ipstr;
                }
            }

            return std::string();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movl %esi, %eax
movq %rdi, %rbx
leaq -0x10(%rbp), %rdx
movl $0x80, (%rdx)
leaq -0x90(%rbp), %rsi
movl %eax, %edi
callq 0x83f0
testl %eax, %eax
jne 0x1ab21
movl -0x10(%rbp), %esi
movl $0x1, (%rsp)
leaq -0x90(%rbp), %rdi
leaq -0x4a0(%rbp), %rdx
movl $0x401, %ecx            # imm = 0x401
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8330
testl %eax, %eax
je 0x1ab3e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %rbp
retq
leaq -0x4a0(%rbp), %rsi
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x81d0
jmp 0x1ab31
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: bool httplib::detail::read_and_close_socket<httplib::Server::read_and_close_socket(int)::'lambda'(httplib::Stream&, bool, bool&)>(int, unsigned long, httplib::Server::read_and_close_socket(int)::'lambda'(httplib::Stream&, bool, bool&))
inline bool read_and_close_socket(socket_t sock, size_t keep_alive_max_count,
                    T callback) {
                bool ret = false;

                if (keep_alive_max_count > 0) {
                    auto count = keep_alive_max_count;
                    while (count > 0 &&
                            detail::select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND,
                                CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0) {
                        SocketStream strm(sock);
                        auto last_connection = count == 1;
                        auto connection_close = false;

                        ret = callback(strm, last_connection, connection_close);
                        if (!ret || connection_close) { break; }

                        count--;
                    }
                } else {
                    SocketStream strm(sock);
                    auto dummy_connection_close = false;
                    ret = callback(strm, true, dummy_connection_close);
                }

                close_socket(sock);
                return ret;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %edi, %ebx
testq %rsi, %rsi
je 0x1abdb
movq %rsi, %r15
xorl %r12d, %r12d
leaq -0x29(%rbp), %r13
testq %r15, %r15
je 0x1ac01
movl %ebx, %edi
pushq $0x5
popq %rsi
xorl %edx, %edx
callq 0x15057
testl %eax, %eax
jle 0x1ac01
leaq 0x1c5a8(%rip), %rax     # 0x37140
movq %rax, -0x40(%rbp)
movl %ebx, -0x38(%rbp)
xorl %edx, %edx
cmpq $0x1, %r15
sete %dl
movb $0x0, -0x29(%rbp)
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
movq %r13, %rcx
callq 0x1ac24
movl %eax, %r12d
testb %al, %al
je 0x1ac01
movb -0x29(%rbp), %al
movl %eax, %ecx
xorb $0x1, %cl
movl %r12d, %edx
andb %cl, %dl
movzbl %dl, %ecx
subq %rcx, %r15
testb $0x1, %al
je 0x1ab78
jmp 0x1ac01
leaq 0x1c55e(%rip), %rax     # 0x37140
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movl %ebx, 0x8(%rsi)
leaq -0x29(%rbp), %rcx
movb $0x0, (%rcx)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1ac24
movl %eax, %r12d
movl %ebx, %edi
callq 0x8a60
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::stream_line_reader::getline()
bool getline() {
                    fixed_buffer_used_size_ = 0;
                    glowable_buffer_.clear();

                    for (size_t i = 0;; i++) {
                        char byte;
                        auto n = strm_.read(&byte, 1);

                        if (n < 0) {
                            return false;
                        } else if (n == 0) {
                            if (i == 0) {
                                return false;
                            } else {
                                break;
                            }
                        }

                        append(byte);

                        if (byte == '\n') { break; }
                    }

                    return true;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rax
movb $0x0, (%rax)
xorl %r12d, %r12d
leaq -0x21(%rbp), %r14
pushq $0x1
popq %r15
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
js 0x1b206
je 0x1b20a
movsbl -0x21(%rbp), %esi
movq %rbx, %rdi
callq 0x1c43c
cmpb $0xa, -0x21(%rbp)
je 0x1b212
decq %r12
jmp 0x1b1da
xorl %eax, %eax
jmp 0x1b214
testq %r12, %r12
setne %al
jmp 0x1b214
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::parse_multipart_boundary(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>>&)
inline bool parse_multipart_boundary(const std::string &content_type,
                std::string &boundary) {
            auto pos = content_type.find("boundary=");
            if (pos == std::string::npos) { return false; }

            boundary = content_type.substr(pos + 9);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x96d6(%rip), %rsi      # 0x253c5
xorl %edx, %edx
callq 0x8a70
movq %rax, %r14
cmpq $-0x1, %rax
je 0x1bd28
leaq 0x9(%r14), %rdx
leaq -0x40(%rbp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x8590
movq %rbx, %rdi
movq %r12, %rsi
callq 0x86c0
movq %r12, %rdi
callq 0x8aa8
cmpq $-0x1, %r14
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Server::routing(httplib::Request&, httplib::Response&)
inline bool Server::routing(Request &req, Response &res) {
        //if (req.method == "GET" && handle_file_request(req, res)) { return true; }

        if (req.method == "GET" || req.method == "HEAD") {
            return dispatch_request(req, res, get_handlers_);
        } else if (req.method == "POST") {
            return dispatch_request(req, res, post_handlers_);
        } else if (req.method == "PUT") {
            return dispatch_request(req, res, put_handlers_);
        } else if (req.method == "PATCH") {
            return dispatch_request(req, res, patch_handlers_);
        } else if (req.method == "DELETE") {
            return dispatch_request(req, res, delete_handlers_);
        } else if (req.method == "OPTIONS") {
            return dispatch_request(req, res, options_handlers_);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsi), %r12
leaq 0x89e7(%rip), %rsi      # 0x24d53
movq %r12, %rdi
callq 0xe8a4
pushq $0x40
popq %r13
testb %al, %al
jne 0x1c3bd
leaq 0x88e2(%rip), %rsi      # 0x24c65
movq %r12, %rdi
callq 0xe8a4
testb %al, %al
jne 0x1c3bd
leaq 0x8d7f(%rip), %rsi      # 0x25115
movq %r12, %rdi
callq 0xe8a4
testb %al, %al
je 0x1c3a6
pushq $0x58
jmp 0x1c3bb
leaq 0x8d6d(%rip), %rsi      # 0x2511a
movq %r12, %rdi
callq 0xe8a4
testb %al, %al
je 0x1c3df
pushq $0x70
popq %r13
addq %r15, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e54
leaq 0x8d38(%rip), %rsi      # 0x2511e
movq %r12, %rdi
callq 0xe8a4
movl $0x88, %r13d
testb %al, %al
jne 0x1c3bd
leaq 0x902b(%rip), %rsi      # 0x2542a
movq %r12, %rdi
callq 0xe8a4
movl $0xa0, %r13d
testb %al, %al
jne 0x1c3bd
leaq 0x9019(%rip), %rsi      # 0x25431
movq %r12, %rdi
callq 0xe8a4
movl $0xb8, %r13d
testb %al, %al
jne 0x1c3bd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::stream_line_reader::append(char)
void append(char c) {
                    if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) {
                        fixed_buffer_[fixed_buffer_used_size_++] = c;
                        fixed_buffer_[fixed_buffer_used_size_] = '\0';
                    } else {
                        if (glowable_buffer_.empty()) {
                            assert(fixed_buffer_[fixed_buffer_used_size_] == '\0');
                            glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_);
                        }
                        glowable_buffer_ += c;
                    }
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdx
decq %rax
cmpq %rax, %rdx
jae 0x1c475
movq 0x8(%rdi), %rax
leaq 0x1(%rdx), %rcx
movq %rcx, 0x18(%rdi)
movb %bl, (%rax,%rdx)
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x28(%rdi)
jne 0x1c492
movq 0x8(%rdi), %rsi
cmpb $0x0, (%rsi,%rdx)
jne 0x1c4a1
movq %r14, %rdi
callq 0x8780
movsbl %bl, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8480
leaq 0x8cc8(%rip), %rdi      # 0x25170
leaq 0x8cf0(%rip), %rsi      # 0x2519f
leaq 0x8cf5(%rip), %rcx      # 0x251ab
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x8370
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: void httplib::Stream::write_format<int, char const*>(char const*, int const&, char const* const&)
inline void Stream::write_format(const char *fmt, const Args &... args) {
            const auto bufsiz = 2048;
            char buf[bufsiz];

#if defined(_MSC_VER) && _MSC_VER < 1900
            auto n = _snprintf_s(buf, bufsiz, bufsiz - 1, fmt, args...);
#else
            auto n = snprintf(buf, bufsiz - 1, fmt, args...);
#endif
            if (n > 0) {
                if (n >= bufsiz - 1) {
                    std::vector<char> glowable_buf(bufsiz);

                    while (n >= static_cast<int>(glowable_buf.size() - 1)) {
                        glowable_buf.resize(glowable_buf.size() * 2);
#if defined(_MSC_VER) && _MSC_VER < 1900
                        n = _snprintf_s(&glowable_buf[0], glowable_buf.size(),
                                glowable_buf.size() - 1, fmt, args...);
#else
                        n = snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...);
#endif
                    }
                    write(&glowable_buf[0], n);
                } else {
                    write(buf, n);
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl (%rdx), %ecx
movq (%r14), %r8
leaq -0x850(%rbp), %rdi
movl $0x7ff, %esi            # imm = 0x7FF
movq %r12, %rdx
xorl %eax, %eax
callq 0x88c0
testl %eax, %eax
jle 0x1c5a8
movl %eax, %ebx
cmpl $0x7ff, %eax            # imm = 0x7FF
jb 0x1c57d
movq %r13, -0x50(%rbp)
leaq -0x48(%rbp), %r13
leaq -0x29(%rbp), %rdx
movl $0x800, %esi            # imm = 0x800
movq %r13, %rdi
callq 0x1c832
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
subq %rsi, %rax
leal -0x1(%rax), %ecx
cmpl %ecx, %ebx
jl 0x1c592
addq %rax, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x1c884
movq -0x48(%rbp), %rdi
movq %rdi, %rsi
notq %rsi
addq -0x40(%rbp), %rsi
movl (%r15), %ecx
movq (%r14), %r8
movq %r12, %rdx
xorl %eax, %eax
callq 0x88c0
movl %eax, %ebx
jmp 0x1c53b
movl %ebx, %edx
movq (%r13), %rax
leaq -0x850(%rbp), %rsi
movq %r13, %rdi
callq *0x18(%rax)
jmp 0x1c5a8
movslq %ebx, %rdx
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x48(%rbp), %rdi
callq 0xe70c
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c5bc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xe70c
movq %rbx, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::from_i_to_hex[abi:cxx11](unsigned long)
inline std::string from_i_to_hex(uint64_t n) {
            const char *charset = "0123456789abcdef";
            std::string ret;
            do {
                ret = charset[n & 15] + ret;
                n >>= 4;
            } while (n > 0);
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x8b8d(%rip), %r12      # 0x25349
leaq -0x40(%rbp), %r15
movl %r14d, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1cac7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x86c0
movq %r15, %rdi
callq 0x8aa8
movq %r14, %rax
shrq $0x4, %rax
cmpq $0x10, %r14
movq %rax, %r14
jae 0x1c7c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8aa8
movq %r14, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::decode_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string decode_url(const std::string &s) {
            std::string result;

            for (size_t i = 0; i < s.size(); i++) {
                if (s[i] == '%' && i + 1 < s.size()) {
                    if (s[i + 1] == 'u') {
                        int val = 0;
                        if (from_hex_to_i(s, i + 2, 4, val)) {
                            // 4 digits Unicode codes
                            char buff[4];
                            size_t len = to_utf8(val, buff);
                            if (len > 0) { result.append(buff, len); }
                            i += 5; // 'u0000'
                        } else {
                            result += s[i];
                        }
                    } else {
                        int val = 0;
                        if (from_hex_to_i(s, i + 1, 2, val)) {
                            // 2 digits hex codes
                            result += val;
                            i += 2; // '00'
                        } else {
                            result += s[i];
                        }
                    }
                } else if (s[i] == '+') {
                    result += ' ';
                } else {
                    result += s[i];
                }
            }

            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq -0x2c(%rbp), %r15
movq 0x8(%r14), %rcx
cmpq %rcx, %r12
jae 0x1cc6b
movq (%r14), %rdx
movzbl (%rdx,%r12), %eax
cmpl $0x2b, %eax
je 0x1cc0a
cmpl $0x25, %eax
jne 0x1cc0c
leaq 0x1(%r12), %rsi
cmpq %rcx, %rsi
jae 0x1cc0c
cmpb $0x75, (%rdx,%rsi)
jne 0x1cc1f
andl $0x0, -0x30(%rbp)
leaq 0x2(%r12), %rsi
movq %r14, %rdi
pushq $0x4
popq %rdx
leaq -0x30(%rbp), %rcx
callq 0x1ee6a
testb %al, %al
je 0x1cc47
movl -0x30(%rbp), %edi
leaq -0x34(%rbp), %r13
movq %r13, %rsi
callq 0x1eedd
testq %rax, %rax
je 0x1cc04
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8060
addq $0x5, %r12
jmp 0x1cc17
movb $0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8480
incq %r12
jmp 0x1cb97
andl $0x0, -0x2c(%rbp)
movq %r14, %rdi
pushq $0x2
popq %rdx
movq %r15, %rcx
callq 0x1ee6a
testb %al, %al
je 0x1cc59
movsbl -0x2c(%rbp), %esi
movq %rbx, %rdi
callq 0x8480
addq $0x2, %r12
jmp 0x1cc17
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x8480
jmp 0x1cc17
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x8480
jmp 0x1cc17
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1cc83
jmp 0x1cc83
jmp 0x1cc83
movq %rax, %r14
movq %rbx, %rdi
callq 0x8aa8
movq %r14, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::from_hex_to_i(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long, int&)
inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt,
                int &val) {
            if (i >= s.size()) { return false; }

            val = 0;
            for (; cnt; i++, cnt--) {
                if (!s[i]) { return false; }
                int v = 0;
                if (is_hex(s[i], v)) {
                    val = val * 16 + v;
                } else {
                    return false;
                }
            }
            return true;
        }

// Assembly:
cmpq %rsi, 0x8(%rdi)
jbe 0x1eec9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
andl $0x0, (%rcx)
leaq -0x2c(%rbp), %r13
subq $0x1, %r14
setb %al
jb 0x1eece
movq (%r12), %rcx
cmpb $0x0, (%rcx,%r15)
je 0x1eece
andl $0x0, -0x2c(%rbp)
movsbl (%rcx,%r15), %edi
movq %r13, %rsi
callq 0x1efac
testb %al, %al
je 0x1eecc
movl (%rbx), %eax
shll $0x4, %eax
addl -0x2c(%rbp), %eax
movl %eax, (%rbx)
incq %r15
jmp 0x1ee91
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::to_utf8(int, char*)
inline size_t to_utf8(int code, char *buff) {
            if (code < 0x0080) {
                buff[0] = (code & 0x7F);
                return 1;
            } else if (code < 0x0800) {
                buff[0] = (0xC0 | ((code >> 6) & 0x1F));
                buff[1] = (0x80 | (code & 0x3F));
                return 2;
            } else if (code < 0xD800) {
                buff[0] = (0xE0 | ((code >> 12) & 0xF));
                buff[1] = (0x80 | ((code >> 6) & 0x3F));
                buff[2] = (0x80 | (code & 0x3F));
                return 3;
            } else if (code < 0xE000) { // D800 - DFFF is invalid...
                return 0;
            } else if (code < 0x10000) {
                buff[0] = (0xE0 | ((code >> 12) & 0xF));
                buff[1] = (0x80 | ((code >> 6) & 0x3F));
                buff[2] = (0x80 | (code & 0x3F));
                return 3;
            } else if (code < 0x110000) {
                buff[0] = (0xF0 | ((code >> 18) & 0x7));
                buff[1] = (0x80 | ((code >> 12) & 0x3F));
                buff[2] = (0x80 | ((code >> 6) & 0x3F));
                buff[3] = (0x80 | (code & 0x3F));
                return 4;
            }

            // NOTREACHED
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %edi
jg 0x1eef9
andb $0x7f, %dil
movb %dil, (%rsi)
movabsq $0x1, %rax
jmp 0x1ef61
cmpl $0x7ff, %edi            # imm = 0x7FF
ja 0x1ef22
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
movabsq $0x2, %rax
jmp 0x1ef61
cmpl $0xd7ff, %edi           # imm = 0xD7FF
ja 0x1ef57
movl %edi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x2(%rsi)
movabsq $0x3, %rax
jmp 0x1ef61
cmpl $0xe000, %edi           # imm = 0xE000
jae 0x1ef63
xorl %eax, %eax
popq %rbp
retq
cmpl $0xffff, %edi           # imm = 0xFFFF
jbe 0x1ef2a
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x1ef5f
movl %edi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rsi)
movabsq $0x4, %rax
jmp 0x1ef61
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::is_hex(char, int&)
inline bool is_hex(char c, int &v) {
            if (0x20 <= c && isdigit(c)) {
                v = c - '0';
                return true;
            } else if ('A' <= c && c <= 'F') {
                v = c - 'A' + 10;
                return true;
            } else if ('a' <= c && c <= 'f') {
                v = c - 'a' + 10;
                return true;
            }
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsbl %dil, %eax
cmpb $0x20, %al
setge %dl
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
setb %r8b
testb %r8b, %dl
jne 0x1efe4
leal -0x41(%rdi), %ecx
cmpb $0x5, %cl
ja 0x1efd5
addl $-0x37, %eax
jmp 0x1efe2
addb $-0x61, %dil
cmpb $0x5, %dil
ja 0x1efea
addl $-0x57, %eax
movl %eax, %ecx
movl %ecx, (%rsi)
movb $0x1, %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x1efe8
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::get_header_value_uint64(std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, httplib::detail::ci, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, char const*, int)
inline uint64_t get_header_value_uint64(const Headers &headers, const char *key,
                int def = 0) {
            auto it = headers.find(key);
            if (it != headers.end()) {
                return std::strtoull(it->second.data(), nullptr, 10);
            }
            return def;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x81d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x14afc
movq %rax, %r15
leaq -0x40(%rbp), %rdi
callq 0x8aa8
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f15e
movq 0x40(%r15), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x8760
jmp 0x1f161
movslq %ebx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::skip_content_with_length(httplib::Stream&, unsigned long)
inline void skip_content_with_length(Stream &strm, size_t len) {
            char buf[BUFSIZ];
            size_t r = 0;
            while (r < len) {
                auto n = strm.read(buf, BUFSIZ);
                if (n <= 0) { return; }
                r += n;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x2020(%rbp), %r15
cmpq %rbx, %r12
jae 0x1f408
movq (%r14), %rax
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movl %eax, %ecx
addq %rcx, %r12
testl %eax, %eax
jg 0x1f3e9
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::read_content_with_length(httplib::Stream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, std::function<bool (unsigned long, unsigned long)>)
inline bool read_content_with_length(Stream &strm, std::string &out, size_t len,
                Progress progress) {
            out.assign(len, 0);
            size_t r = 0;
            while (r < len) {
                auto n = strm.read(&out[r], len - r);
                if (n <= 0) { return false; }

                r += n;

                if (progress) {
                    if (!progress(r, len)) { return false; }
                }
            }

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r12
xorl %r15d, %r15d
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x8980
movq %r15, %r13
movq %rbx, %rdx
subq %r15, %rdx
jbe 0x1f485
movq -0x30(%rbp), %rax
movq (%rax), %rsi
addq %r13, %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
testl %eax, %eax
jle 0x1f485
movl %eax, %r15d
addq %r13, %r15
cmpq $0x0, 0x10(%r14)
je 0x1f443
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f5de
testb %al, %al
jne 0x1f443
cmpq %r13, %rbx
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::read_content_without_length(httplib::Stream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool read_content_without_length(Stream &strm, std::string &out) {
            for (;;) {
                char byte;
                auto n = strm.read(&byte, 1);
                if (n < 0) {
                    return false;
                } else if (n == 0) {
                    return true;
                }
                out += byte;
            }

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x21(%rbp), %r15
pushq $0x1
popq %r12
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
testl %eax, %eax
jle 0x1f4d8
movsbl -0x21(%rbp), %esi
movq %rbx, %rdi
callq 0x8480
jmp 0x1f4b7
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: void httplib::detail::split<httplib::detail::parse_query_text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)::'lambda'(char const*, char const*)>(char const*, char const*, char, httplib::detail::parse_query_text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)::'lambda'(char const*, char const*))
void split(const char *b, const char *e, char d, Fn fn) {
            int i = 0;
            int beg = 0;

            while (e ? (b + i != e) : (b[i] != '\0')) {
                if (b[i] == d) {
                    fn(&b[beg], &b[i]);
                    beg = i + 1;
                }
                i++;
            }

            if (i) { fn(&b[beg], &b[i]); }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %rcx, (%r12)
xorl %r13d, %r13d
xorl %eax, %eax
leaq (%rbx,%r13), %rdx
movslq %eax, %rsi
testq %r15, %r15
je 0x1f644
cmpq %r15, %rdx
je 0x1f667
movb (%rdx), %cl
jmp 0x1f64a
movb (%rdx), %cl
testb %cl, %cl
je 0x1f667
cmpb %r14b, %cl
je 0x1f654
incq %r13
jmp 0x1f62f
addq %rbx, %rsi
movq %r12, %rdi
callq 0x1f68e
incq %r13
movl %r13d, %eax
jmp 0x1f62f
testq %r13, %r13
je 0x1f67e
addq %rbx, %rsi
movl %r13d, %edx
addq %rbx, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1f68e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::detail::parse_query_text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)::'lambda'(char const*, char const*)::operator()(char const*, char const*) const
inline void parse_query_text(const std::string &s, Params &params) {
            split(&s[0], &s[s.size()], '&', [&](const char *b, const char *e) {
                    std::string key;
                    std::string val;
                    split(b, e, '=', [&](const char *b, const char *e) {
                            if (key.empty()) {
                            key.assign(b, e);
                            } else {
                            val.assign(b, e);
                            }
                            });
                    params.emplace(key, decode_url(val));
                    });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
pushq $0x3d
popq %rax
leaq -0x48(%rbp), %rcx
leaq -0x28(%rbp), %r8
movq %rsi, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x1f741
movq (%rbx), %rbx
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cb69
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x1f802
leaq -0x68(%rbp), %rdi
callq 0x8aa8
leaq -0x28(%rbp), %rdi
callq 0x8aa8
leaq -0x48(%rbp), %rdi
callq 0x8aa8
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x8aa8
jmp 0x1f727
jmp 0x1f724
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x8aa8
leaq -0x48(%rbp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Server::dispatch_request(httplib::Request&, httplib::Response&, std::vector<std::pair<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>, std::function<void (httplib::Request const&, httplib::Response&)>>, std::allocator<std::pair<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>, std::function<void (httplib::Request const&, httplib::Response&)>>>>&)
inline bool Server::dispatch_request(Request &req, Response &res,
            Handlers &handlers) {
        for (const auto &x : handlers) {
            const auto &pattern = x.first;
            const auto &handler = x.second;

            if (std::regex_match(req.path, req.matches, pattern)) {
                handler(req, res);
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq (%rcx), %rbx
movq 0x8(%rcx), %r14
leaq 0x60(%rsi), %r12
leaq 0x130(%rsi), %r13
cmpq %r14, %rbx
je 0x21eaa
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x1fa03
testb %al, %al
jne 0x21e9a
addq $0x40, %rbx
jmp 0x21e7b
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x1c4c0
cmpq %r14, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Client::process_request(httplib::Stream&, httplib::Request&, httplib::Response&, bool&)
inline bool Client::process_request(Stream &strm, Request &req, Response &res,
            bool &connection_close) {
        // Send request
        write_request(strm, req);

        // Receive response and headers
        if (!read_response_line(strm, res) ||
                !detail::read_headers(strm, res.headers)) {
            return false;
        }

        if (res.get_header_value("Connection") == "close" ||
                res.version == "HTTP/1.0") {
            connection_close = true;
        }

        // Body
        if (req.method != "HEAD") {
            bool exceed_payload_max_length = false;
            if (!detail::read_content(strm, res, std::numeric_limits<uint64_t>::max(),
                        exceed_payload_max_length, req.progress)) {
                return false;
            }

            if (res.get_header_value("Content-Encoding") == "gzip") {
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
                detail::decompress(res.body);
#else
                return false;
#endif
            }
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
callq 0x2210e
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22398
testb %al, %al
je 0x220e5
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x1b8f0
testb %al, %al
je 0x220e5
leaq 0x30fc(%rip), %rdx      # 0x250f8
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x192b6
leaq 0x30ef(%rip), %rsi      # 0x25103
movq %r13, %rdi
callq 0xe8a4
testb %al, %al
je 0x2202b
leaq -0x50(%rbp), %rdi
callq 0x8aa8
jmp 0x2204b
leaq 0x3407(%rip), %rsi      # 0x25439
movq %rbx, %rdi
callq 0xe8a4
movl %eax, %r13d
leaq -0x50(%rbp), %rdi
callq 0x8aa8
testb %r13b, %r13b
je 0x22050
movb $0x1, (%r12)
leaq 0x20(%r15), %rdi
leaq 0x2c0a(%rip), %rsi      # 0x24c65
callq 0x1c758
testb %al, %al
je 0x220e0
leaq -0x29(%rbp), %r12
movb $0x0, (%r12)
addq $0x150, %r15            # imm = 0x150
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x16486
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x22598
movl %eax, %r14d
leaq -0x70(%rbp), %rdi
callq 0x16248
testb %r14b, %r14b
je 0x220e5
leaq 0x3075(%rip), %rdx      # 0x25124
xorl %r14d, %r14d
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x192b6
leaq 0x306b(%rip), %rsi      # 0x25135
movq %r15, %rdi
callq 0xe8a4
movl %eax, %ebx
movq %r15, %rdi
callq 0x8aa8
testb %bl, %bl
jne 0x220e8
movb $0x1, %r14b
jmp 0x220e8
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x16248
movq %rbx, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/MisakiFx[P]P2PDownload/./httplib.h
// Function: httplib::Client::read_response_line(httplib::Stream&, httplib::Response&)
inline bool Client::read_response_line(Stream &strm, Response &res) {
        const auto bufsiz = 2048;
        char buf[bufsiz];

        detail::stream_line_reader reader(strm, buf, bufsiz);

        if (!reader.getline()) { return false; }

        const static std::regex re("(HTTP/1\\.[01]) (\\d+?) .*\r\n");

        std::cmatch m;
        if (std::regex_match(reader.ptr(), m, re)) {
            res.version = std::string(m[1]);
            res.status = std::stoi(std::string(m[2]));
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x888, %rsp            # imm = 0x888
movq %rdx, %r15
leaq -0x90(%rbp), %rbx
movq %rsi, -0x20(%rbx)
leaq -0x8b0(%rbp), %rax
movq %rax, -0x18(%rbx)
movq $0x800, -0x10(%rbx)     # imm = 0x800
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xb0(%rbp), %rdi
callq 0x1b1ac
movl %eax, %r14d
testb %al, %al
je 0x224e2
movb 0x1670e(%rip), %al      # 0x38b08
testb %al, %al
je 0x224ff
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
leaq -0xa8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
movaps %xmm0, (%rsi)
cmovneq %rbx, %rax
movq (%rax), %rdi
leaq 0x166be(%rip), %rdx     # 0x38ae8
xorl %ecx, %ecx
callq 0x1cb31
testb %al, %al
je 0x224d9
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
pushq $0x18
popq %r13
subq %rsi, %rcx
je 0x22462
movq %rcx, %rax
cqto
idivq %r13
addq $-0x5, %rax
cmpq $-0x3, %rax
ja 0x22462
addq $0x18, %rsi
jmp 0x22469
addq %rcx, %rsi
addq $-0x48, %rsi
leaq -0x70(%rbp), %rdi
callq 0x1ee26
leaq -0x70(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x86c0
movq %r12, %rdi
callq 0x8aa8
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
subq %rsi, %rcx
je 0x224ae
movq %rcx, %rax
cqto
idivq %r13
addq $-0x6, %rax
cmpq $-0x4, %rax
ja 0x224ae
addq $0x30, %rsi
jmp 0x224b5
addq %rcx, %rsi
addq $-0x48, %rsi
leaq -0x70(%rbp), %rdi
callq 0x1ee26
leaq -0x70(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x1f4e8
movl %eax, 0x20(%r15)
leaq -0x70(%rbp), %rdi
callq 0x8aa8
leaq -0x50(%rbp), %rdi
callq 0x1d19a
movq %rbx, %rdi
callq 0x8aa8
movl %r14d, %eax
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16602(%rip), %rdi     # 0x38b08
callq 0x89c0
testl %eax, %eax
je 0x22402
leaq 0x165ce(%rip), %rdi     # 0x38ae8
leaq 0x2fc3(%rip), %rsi      # 0x254e4
pushq $0x10
popq %rdx
callq 0xa008
leaq -0x1849e(%rip), %rdi    # 0xa092
leaq 0x165b1(%rip), %rsi     # 0x38ae8
leaq 0x1601a(%rip), %rdx     # 0x38558
callq 0x84a0
leaq 0x165be(%rip), %rdi     # 0x38b08
callq 0x8360
jmp 0x22402
movq %rax, %r14
leaq 0x165aa(%rip), %rdi     # 0x38b08
callq 0x8350
jmp 0x22588
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x8aa8
jmp 0x2257a
jmp 0x22577
jmp 0x22577
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1d19a
jmp 0x22588
movq %rax, %r14
movq %rbx, %rdi
callq 0x8aa8
movq %r14, %rdi
callq 0x8990
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/rabinkarp.c
// Function: mpow
int mpow(int base, int n)
{
	int result = 1;
	for(int i = 0; i < n; i++)
	{
		result *= base;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movl $0x1, %eax
subl $0x1, %ecx
jb 0x11d6
imull %edi, %eax
jmp 0x11cc
popq %rbp
retq