LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/Triad.cpp
// Function: setNotes(Triad*, std::vector<Interval, std::allocator<Interval>>*)
static void _setNotes(Triad *c, std::vector<Interval> *intervals)
{
    c->getRoot()->getNatural()->sort();
    c->notes.push_back(c->getBass());
    if (c->getRoot() != c->getBass())
    {
        c->notes.push_back(c->getRoot());
    }
    Note *tmp;
    for (int k = 0; k < 2; k++)
    {
        tmp = intervals->at(k).getNextSorted(c->getRoot());
        c->notes.push_back(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x6baa
leaq 0x70(%r14), %r15
movq 0x8(%r14), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x96e6
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0xb661
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x96e6
movb $0x1, %r13b
xorl %esi, %esi
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0xb6de
leaq (%rsi,%rsi,4), %rcx
leaq (%rax,%rcx,8), %rdi
movq (%r14), %rsi
callq 0x71f2
movq %rax, -0x30(%rbp)
movq 0x78(%r14), %rsi
cmpq 0x80(%r14), %rsi
je 0xb6b2
movq %rax, (%rsi)
addq $0x8, 0x78(%r14)
jmp 0xb6be
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0xb8ea
movl $0x1, %esi
testb $0x1, %r13b
movl $0x0, %r13d
jne 0xb670
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c09(%rip), %rdi      # 0xe2ee
xorl %eax, %eax
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/Scale.cpp
// Function: Scale::setNotes()
void Scale::setNotes()
{
    NaturalNote *ntmp = tonic->getNatural();
    ntmp->sort();
    notes.push_back(tonic);
    for (auto i : intervals)
    {
        notes.push_back(i.getNextSorted(tonic));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x6baa
leaq 0x40(%r15), %r14
movq 0x48(%r15), %rsi
cmpq 0x50(%r15), %rsi
je 0xbcba
movq 0x18(%r15), %rax
movq %rax, (%rsi)
addq $0x8, 0x48(%r15)
jmp 0xbcc5
movq %r14, %rdi
movq %rbx, %rdx
callq 0xb8ea
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0xbd24
leaq -0x58(%rbp), %r15
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x663a
movq 0x20(%r13), %rax
movq %rax, -0x38(%rbp)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x71f2
movq %rax, -0x30(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
callq 0x96e6
movq %r15, %rdi
callq 0x780a
addq $0x28, %r13
cmpq %r12, %r13
jne 0xbcd5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x780a
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/Scale.cpp
// Function: Scale::getDegree(Note*)
int Scale::getDegree(Note *n)
{
    int deg = 0;
    for (auto note : notes)
    {
        if (n == note)
            return deg + 1;
        else
            deg++;
    }
    throw E_DEGREE_NOT_FOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rcx
movq 0x48(%rdi), %rdx
cmpq %rdx, %rcx
je 0xc546
movl $0x1, %eax
cmpq %rsi, (%rcx)
je 0xc567
addq $0x8, %rcx
incl %eax
cmpq %rdx, %rcx
jne 0xc536
movl $0x4, %edi
callq 0x30d0
movl $0x5, (%rax)
leaq 0x631b(%rip), %rsi      # 0x12878
movq %rax, %rdi
xorl %edx, %edx
callq 0x3290
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/Scale.cpp
// Function: Scale::display[abi:cxx11]()
std::string Scale::display()
{
    std::string str;
    for (auto n : notes)
    {
        str += n->display() + " ";
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %r12
movq 0x48(%rsi), %r15
cmpq %r15, %r12
je 0xc71d
leaq -0x40(%rbp), %r13
leaq -0x70(%rbp), %r14
movq (%r12), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq %r14, %rdi
leaq 0x1f16(%rip), %rsi      # 0xe5a4
callq 0x32e0
movq %r13, -0x50(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc6b3
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0xc6bb
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x48(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x3080
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xc6f7
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3190
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xc710
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x8, %r12
cmpq %r15, %r12
jne 0xc678
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc76a
movq %rax, %r14
jmp 0xc751
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xc751
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3190
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xc76a
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x3190
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xc782
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3190
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/user.cpp
// Function: interact(int)
void interact(int c)
{
    std::cout << std::endl;
    int choice;
    if (!c)
        do
        {
            std::cout << "Select which feature you want to use (ex : 2) or '-1' to see features : " << std::endl;
            std::cin >> choice;
            if (choice == -1)
                help();
        } while (!std::cin || choice > 3 || choice < 0);
    else
        choice = c;
    handle_choice(choice);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r13d
movq 0x5cc1(%rip), %rbx      # 0x12fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
testl %r13d, %r13d
je 0xd33c
movl %r13d, -0x2c(%rbp)
jmp 0xd3be
leaq 0x115d(%rip), %r14      # 0xe4a0
movq 0x5c8e(%rip), %r15      # 0x12fd8
leaq -0x2c(%rbp), %r12
movl $0x48, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %r15, %rdi
movq %r12, %rsi
callq 0x3100
movl -0x2c(%rbp), %r13d
cmpl $-0x1, %r13d
jne 0xd3a3
callq 0xd3d5
movl -0x2c(%rbp), %r13d
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
setne %al
cmpl $0x4, %r13d
setae %cl
orb %al, %cl
jne 0xd34e
movl %r13d, %edi
callq 0xc78c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Wombozo[P]harmony/src/user.cpp
// Function: help()
void help()
{
    std::cout << "Features : " << std::endl;
    std::cout << "\t -> Chord display (" << C_CD << ")" << std::endl;
    std::cout << "\t -> Scale display (" << C_SD << ")" << std::endl;
    std::cout << "\t -> Interval display (" << C_ID << ")" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x5be2(%rip), %rbx      # 0x12fc8
leaq 0x10fc(%rip), %rsi      # 0xe4e9
movl $0xb, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x10cd(%rip), %rsi      # 0xe4f5
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x32a0
movq %rax, %r15
leaq 0xcec(%rip), %r14       # 0xe138
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x1080(%rip), %rsi      # 0xe50a
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31c0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x32a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x103a(%rip), %rsi      # 0xe51f
movl $0x17, %edx
movq %rbx, %rdi
callq 0x31c0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x32a0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/main2.cpp
// Function: testDefaultResponse()
void testDefaultResponse() {
    Response res;
    for (const auto& status_code : httpc::GetAllHttpStatus()) {
        res.SetDefault(status_code);
        std::cout << res << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
xorl %eax, %eax
leaq -0xc8(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x90(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movb %al, 0x10(%rcx)
leaq -0x70(%rbp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
callq 0x22985
movq (%rax), %r13
movq 0x8(%rax), %r12
cmpq %r12, %r13
je 0x8fa2
leaq -0xe8(%rbp), %rbx
movq 0x2c038(%rip), %r14     # 0x34f90
movl (%r13), %esi
movq %rbx, %rdi
callq 0xa54e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa739
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8500
movsbl %al, %esi
movq %r15, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x83b0
addq $0x4, %r13
cmpq %r12, %r13
jne 0x8f58
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x8fbb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xb8(%rbp), %rbx
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0xc04a
movq -0x28(%r14), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x8fed
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0xc00c
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rax
cmpq %rax, %rdi
je 0x9017
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0xa8f4
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/http_router.hpp
// Function: void httpc::HttpRouter::Invoke<main::$_2>(httpc::Request&, httpc::Response&, main::$_2)
void Invoke(
            Request&            request,
            Response&           response,
            Function            callback,
            Aspects...          aspects
        ) {
            // get all the aspects objects into a tuple
            std::tuple<Aspects...> aspects_tuple(std::forward<Aspects>(aspects)...);
            // go through for every aspect and call the before() function
            std::apply([&request, &response](auto&&... aspect) {
                (aspect.before(request, response), ...);
            }, aspects_tuple);

            // do the bussiness
            std::forward<Function>(callback)(request, response);

            // do same for after()
            std::apply([&request, &response](auto&&... aspect) {
                (aspect.after(request, response), ...);
            }, aspects_tuple);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq 0x60(%rcx), %rsi
movq 0x68(%rcx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x58(%rbp), %rdi
callq 0xb088
leaq 0x1b3ee(%rip), %rsi     # 0x24f29
leaq -0x58(%rbp), %rdi
callq 0x88d0
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9b68
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x9b6f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x9f28
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9ba7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x9bbc
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9be4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x9be4
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x9bf9
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
movq %rax, %rdi
callq 0x9e2e
nop
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/response.hpp
// Function: httpc::operator<<(std::ostream&, httpc::Response const&)
std::ostream& operator<< (std::ostream& os, const Response& response) {
            os << "HTTP/" << response.http_major_version << "." << response.http_minor_version
               << " " << static_cast<int>(response.status_code) << " " << GetHTTPReasonPhrase(response.status_code) << std::endl;
            for (const auto& header : response.headers) {
                os << header.field << ": " << header.value << std::endl;
            }
            os << response.message_body;
            return os;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a0b8(%rip), %rsi     # 0x2480f
movl $0x5, %edx
callq 0x85b0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x8810
movq %rax, %r15
leaq 0x1a0ba(%rip), %rsi     # 0x24830
movl $0x1, %edx
movq %rax, %rdi
callq 0x85b0
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x8810
movq %rax, %r15
leaq 0x1a72c(%rip), %r12     # 0x24ec5
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x85b0
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x8810
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x85b0
movl 0x8(%r14), %esi
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x223b0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x85b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8500
movsbl %al, %esi
movq %r15, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x83b0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa82c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x30(%r14), %r13
movq %r14, -0x30(%rbp)
movq 0x38(%r14), %r14
cmpq %r14, %r13
je 0xa8aa
leaq 0x1a680(%rip), %r15     # 0x24ec4
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x85b0
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x85b0
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
movq %r12, %rdi
callq 0x85b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8500
movsbl %al, %esi
movq %r12, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x83b0
addq $0x40, %r13
cmpq %r14, %r13
jne 0xa844
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x85b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa8ec
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/server.hpp
// Function: httpc::Server::Start()
void Start() {
            // thread_.reset(new std::thread(
            //     [this] {
            //         io_context_.run();
            //     }
            // ));
            // // should be tested before use.
            // // but that means I should make a exception class
            // // I am lazy...
            // thread_->detach();

            // use std::async instead
            this->Accept_();
            std::async(std::launch::async, [this] {
                io_context_.run(); 
            });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x138d4
leaq -0x10(%rbp), %rdx
movq %rbx, (%rdx)
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x139bd
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xac31
callq 0x118ea
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/response.hpp
// Function: httpc::Response& httpc::Response::AddHeader<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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
inline Response& AddHeader(StringT&& field, StringT&& value) {
            bool flag = false;
            for (auto itr = this->headers.begin(); itr != this->headers.end(); ++itr) {
                if (itr->field == field) {
                    itr->value = value;
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                headers.emplace_back(std::forward<Header>({
                    std::forward<StringT>(field),
                    std::forward<StringT>(value)
                }));
            }
            
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq 0x30(%rdi), %r12
movq %rdi, -0x38(%rbp)
movq 0x38(%rdi), %rbx
cmpq %rbx, %r12
je 0xb586
movq (%r15), %r13
movq 0x8(%r15), %r14
cmpq %r14, 0x8(%r12)
jne 0xb57d
testq %r14, %r14
je 0xb5e0
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x8540
testl %eax, %eax
je 0xb5e0
addq $0x40, %r12
cmpq %rbx, %r12
jne 0xb55e
movq -0x38(%rbp), %rbx
leaq 0x30(%rbx), %r14
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0xb65e
movq %r14, %rdi
movq %r12, %rsi
callq 0xb61a
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5c5
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5f4
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xb5f4
addq $0x20, %r12
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x8310
movq -0x38(%rbp), %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xb4e8
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/server.hpp
// Function: httpc::Server::Accept_()
void Accept_() {
            //while (this->atomic_accept_flag_);
            //this->atomic_accept_flag_ = true;
            
            std::shared_ptr<Connection> ptr_conn(new Connection(this->io_context_, this->http_router_));
            acceptor_.async_accept(
                ptr_conn->Socket(), 
                [this, ptr_conn] (boost::system::error_code ec) {
                    if(!ec) {
                        // debug().dg("accept: ").dg(ec.message()).lf();
                        //debug().dg("start").lf();
                        debug().dg("accept and start a connection").lf();
                        ptr_conn->Socket().set_option(boost::asio::ip::tcp::no_delay(true));
                        ptr_conn->Start();
                    } else {
                        // std::cout << "err: " << ec.message() << std::endl;
                    }
                    //this->atomic_accept_flag_ = false;
                    debug().dg("wait for next connection").lf();
                    this->Accept_();
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x508, %edi            # imm = 0x508
callq 0x8510
movq %rax, %r14
leaq 0x80(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13ae6
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x14848
movq (%r15), %rdx
movq 0x8(%r15), %rax
movq %rbx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
addq $0x18, %rdx
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x13943
movq 0x21653(%rip), %rcx     # 0x34f88
cmpb $0x0, (%rcx)
je 0x1393f
incl 0x8(%rax)
jmp 0x13943
lock
incl 0x8(%rax)
movq 0x10(%rbx), %rdi
leaq 0x18(%rbx), %rsi
addq $0x30, %rbx
leaq -0x30(%rbp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x14c9c
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1396b
callq 0x118ea
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x13979
callq 0x118ea
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x13995
callq 0x118ea
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x139b5
callq 0x118ea
jmp 0x139b5
movq %rax, %rbx
movl $0x508, %esi            # imm = 0x508
movq %r14, %rdi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::DoRead()
void DoRead() {
            // set up timer for each call
            this->ActiveKeepAliveTimer();

            // try to read from buffer
            socket_.async_read_some(
                boost::asio::buffer(this->buffer_),
                [this, self = this->shared_from_this()] 
                (boost::system::error_code const& ec, std::size_t bytes_transferred) {
                    // if no error occurs
                    if (!ec) {
                        // handle read.
                        this->HandleRead_(ec, bytes_transferred);
                    } else {
                        if (ec == boost::asio::error::eof) {
                            // this->hand_shake_ = false;
                            debug().dg("shut down send").lf();
                            boost::system::error_code ignore_ec;
                            this->Socket().shutdown(boost::asio::ip::tcp::socket::shutdown_send, ignore_ec);
                        }
                    }
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x154b2
leaq 0x68(%rbx), %rax
leaq -0x38(%rbp), %r14
movq %rax, (%r14)
movq $0x200, 0x8(%r14)       # imm = 0x200
leaq -0x20(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x203ba
movq 0x18(%rbx), %rdi
addq $0x28, %rdi
leaq 0x20(%rbx), %rsi
addq $0x38, %rbx
leaq -0x28(%rbp), %r8
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x1636c
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x1548f
callq 0x118ea
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x154a9
callq 0x118ea
movq %rbx, %rdi
callq 0x8830
nop
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::ActiveKeepAliveTimer()
void ActiveKeepAliveTimer() {
            //debug().dg("set timer").lf();
            // this->keep_alive_ = true;
            this->keep_alive_timer_.expires_after(std::chrono::seconds{60});
            this->keep_alive_timer_.async_wait([this, self = this->shared_from_this()]
            (boost::system::error_code const& ec) {
                if (ec) {
                    //debug().dg("timer handler: ").dg(ec.message()).lf();
                    return;
                }
                debug().dg("timer handler get closed").lf();
                //std::cout << "no." << this->no << " timer close" << std::endl;
                self->Socket().close();
            });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x498, %rdi            # imm = 0x498
movabsq $0xdf8475800, %rax      # imm = 0xDF8475800
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rsi
callq 0x15540
movq %rbx, (%r14)
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x203ba
movq 0x498(%rbx), %rdi
leaq 0x4a0(%rbx), %rsi
addq $0x4d8, %rbx            # imm = 0x4D8
leaq -0x28(%rbp), %rdx
movq %rbx, %rcx
callq 0x1568e
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x1551e
callq 0x118ea
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x15538
callq 0x118ea
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/request_parser.hpp
// Function: std::tuple<httpc::RequestParser::ResultType, char*> httpc::RequestParser::Parse<char*>(httpc::Request&, char*, char*)
std::tuple<ResultType, InputIterator> Parse(Request& request, 
            InputIterator begin, InputIterator end) {
            std::cout << std::string(begin, end) << std::endl;
            ResultType res = kBad;
            for (; begin != end; ++begin) {
                if(ParseRequest(request, *begin) == kGood) {
                    return std::make_tuple(kGood, begin);
                }

            }
            //std::cout << "end of parse" << std::endl;
            return std::make_tuple(kIndeterminate, begin);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0xb088
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x1e473(%rip), %rdi     # 0x34f90
callq 0x85b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8500
movsbl %al, %esi
movq %r14, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x83b0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x16b65
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0x2, %r14d
cmpq %r15, %rbx
je 0x16b8a
movsbl (%rbx), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x173fe
testl %eax, %eax
je 0x16b87
incq %rbx
jmp 0x16b6b
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
movl %r14d, 0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x16bc0
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::DoWrite()
void DoWrite()  {
            // auto self{shared_from_this()};
            // std::cout << "write" << std::endl;
            // this->write_buffer_ = response_.ToBuffers();
// #ifdef HTTPC_ENABLE_GZIP 
//             this->response_.WriteGzipBuffer(this->write_buffer_);
//             // this->response_.WriteBuffer(this->write_buffer_);
// #endif
            // std::vector<boost::asio::const_buffer> buffers = this->response_.ToBuffers();
            // for(auto x : buffers) {
            //     std::cout << static_cast<const char*>(x.data()) << std::endl;
            // }
            // std::cout << response_ << std::endl;
            // this->ResetKeepAliveTimer();
            // debug().dg(this->response_).lf();
            // this->ActiveKeepAliveTimer();
            boost::asio::async_write(
                socket_,
                this->response_.ToBuffers(),
                [this, self = this->shared_from_this()]
                (boost::system::error_code ec, std::size_t bytes_transferred) {
                    //std::cout << ec.message() << std::endl;
                    //std::cout << bytes_transferred << std::endl;
                    this->HandleWrite_(ec, bytes_transferred);
                }
            );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x3d0(%rdi), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1a6fc
leaq -0x38(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x203ba
addq $0x18, %rbx
leaq -0x48(%rbp), %rdi
movq %rbx, (%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x1aa9c
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1732c
callq 0x118ea
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x17341
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1735e
callq 0x118ea
jmp 0x1735e
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x17373
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8830
nop
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::HandleWrite_(boost::system::error_code, unsigned long)
void HandleWrite_(boost::system::error_code ec, std::size_t bytes_transferred) {
            if (this->keep_alive_) {
                this->parser_.Reset();
                this->request_.Reset();
                this->response_.Reset();
                //std::cout << "keep-alive" << std::endl;
                this->DoRead();
            }
            else {
                this->keep_alive_timer_.cancel();
                this->ShutDownSocket_();
                this->Close();
            }
            
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x491(%rdi)
jne 0x1bb2f
xorl %r14d, %r14d
movl %r14d, 0x288(%rbx)
movl $0x1, 0x290(%rbx)
movq %r14, 0x270(%rbx)
movq 0x268(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2b0(%rbx)
movq 0x2a8(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2d0(%rbx)
movq 0x2c8(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x2f0(%rbx)
movq 0x2e8(%rbx), %rax
movb %r14b, (%rax)
leaq 0x308(%rbx), %rdi
callq 0x1bba4
movq %r14, 0x338(%rbx)
leaq 0x340(%rbx), %rdi
movq 0x340(%rbx), %rsi
callq 0xb460
movq %r14, 0x360(%rbx)
movq 0x358(%rbx), %rax
movb %r14b, (%rax)
leaq 0x378(%rbx), %rdi
movq 0x378(%rbx), %rsi
callq 0x1bbdc
leaq 0x390(%rbx), %rdi
callq 0x14710
movw $0x0, 0x3c8(%rbx)
movb %r14b, 0x3ca(%rbx)
movq %r14, 0x3d0(%rbx)
movl %r14d, 0x3d8(%rbx)
movq %r14, 0x3e8(%rbx)
movq 0x3e0(%rbx), %rax
movb %r14b, (%rax)
leaq 0x400(%rbx), %rdi
movq 0x400(%rbx), %rsi
callq 0xb460
movq %r14, 0x420(%rbx)
movq 0x418(%rbx), %rax
movb %r14b, (%rax)
movq %r14, 0x478(%rbx)
movq 0x470(%rbx), %rax
movb %r14b, (%rax)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1542a
cmpb $0x1, 0x4a8(%rbx)
jne 0x1bb61
movq 0x498(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x4b0(%rbx), %rdx
movq $-0x1, %rcx
callq 0x14ad0
movb $0x0, 0x4a8(%rbx)
leaq -0x20(%rbp), %rcx
movl $0x0, (%rcx)
movb $0x0, 0x4(%rcx)
leaq 0x17d1a(%rip), %rax     # 0x33890
movq %rax, 0x8(%rcx)
leaq 0x18(%rbx), %r14
movq 0x18(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movl $0x2, %edx
callq 0x1fc2c
movq %r14, %rdi
callq 0x15b76
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::HandleReadBody(boost::system::error_code const&, unsigned long)
void HandleReadBody(boost::system::error_code const& ec, std::size_t bytes_transferred) {
            debug().dg("HandleReadBody() member function").lf();
        
            // debug().dg(this->request_).lf();

            // judge if user would like to receive the next file
            // if (this->request_.RecvNextFileOrNot()) {
            this->parser_.ParseBody(
                this->request_,
                this->buffer_.data(), 
                this->buffer_.data() + bytes_transferred
            );
            this->parser_.ParseFormData(
                this->request_,
                this->buffer_.data(), 
                this->buffer_.data() + bytes_transferred
            );
            debug().dg("parse post body complete").lf();
            // debug().dg(this->request_).lf();
            auto itr = this->response_.FindHeader("Content-Length");
            if (itr != this->response_.HeaderCEnd()) {
                debug().dg("Response Content-Length => ").dg(itr->value).lf();
            }
            // complete the parsement
            this->http_router_.Route(
                this->request_.method,
                this->request_.uri.GetUri(), 
                this->request_, 
                this->response_
            );
            // }
            
            // this->CheckKeepAlive_();

            // this->request_.uri.Update();
                // debug().dg(this->request_.uri.GetUri()).lf();
            
            //debug().dg(this->response_).lf();
            this->handler_.Respond(
                this->request_,
                this->response_
            );
            this->DoWrite();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x268(%rdi), %r15
leaq 0x2a8(%rdi), %r14
leaq 0x68(%rdi), %r12
leaq 0x68(%rdi,%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1c490
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1cf58
movq 0x400(%rbx), %r15
cmpq 0x408(%rbx), %r15
je 0x1c447
leaq 0x838e(%rip), %r12      # 0x247b9
movq %r15, %rdi
movq %r12, %rsi
callq 0x81a0
testl %eax, %eax
je 0x1c447
addq $0x40, %r15
cmpq 0x408(%rbx), %r15
jne 0x1c42b
leaq 0x3d0(%rbx), %r15
movq 0x10(%rbx), %rdi
leaq 0x2e8(%rbx), %rdx
movq %r14, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x16e1e
leaq 0x490(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22dac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x172d6
nop
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::RenderString<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 void RenderString(StringT&& str) {
            this->SetMessageBody_(
                std::forward<StringT>(str)
            );
#ifdef HTTPC_ENABLE_GZIP
            this->AddHeader("Content-Encoding", "gzip");
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp           # imm = 0x4078
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x8310
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r12
xorps %xmm0, %xmm0
leaq -0x98(%rbp), %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x2cf3(%rip), %rax      # 0x247b2
movl $0x1, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x8090
addq $0x10, %rsp
testl %eax, %eax
jne 0x21b48
leaq 0xa0(%rbx), %r14
leaq -0x98(%rbp), %r15
movq %r13, (%r15)
movl %r12d, 0x8(%r15)
leaq -0x40a0(%rbp), %r12
movl $0x4000, -0x78(%rbp)    # imm = 0x4000
movq %r12, -0x80(%rbp)
movq %r15, %rdi
movl $0x4, %esi
callq 0x8290
cmpl $-0x2, %eax
je 0x21b48
movl $0x4000, %eax           # imm = 0x4000
subl -0x78(%rbp), %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x80b0
cmpl $0x0, -0x78(%rbp)
je 0x21b03
leaq -0x98(%rbp), %rdi
callq 0x8360
movq %rbx, %rdi
callq 0xb1e4
leaq 0x2c06(%rip), %rsi      # 0x2475d
leaq 0x2c10(%rip), %rdx      # 0x2476e
movq %rbx, %rdi
callq 0xb126
addq $0x4078, %rsp           # imm = 0x4078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::SetMessageBody_<char const (&) [13]>(char const (&) [13])
inline void SetMessageBody_(StringT&& str) {
            this->message_body.assign(
                std::forward<StringT>(str)
            );
            
#ifdef HTTPC_ENABLE_GZIP
            this->GzipEncode();
#endif
            this->SetContentLength_();
            //std::cout << "SetMessageBody_" << std::endl;
            //std::cout << this->message_body << std::endl;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp           # imm = 0x4078
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rdi), %r15
movq 0x50(%rdi), %r12
movq %rsi, %rdi
callq 0x8260
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x8790
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r12
xorps %xmm0, %xmm0
leaq -0x98(%rbp), %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x28c4(%rip), %rax      # 0x247b2
movl $0x1, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x8090
addq $0x10, %rsp
testl %eax, %eax
jne 0x21f77
leaq 0xa0(%rbx), %r14
leaq -0x98(%rbp), %r15
movq %r13, (%r15)
movl %r12d, 0x8(%r15)
leaq -0x40a0(%rbp), %r12
movl $0x4000, -0x78(%rbp)    # imm = 0x4000
movq %r12, -0x80(%rbp)
movq %r15, %rdi
movl $0x4, %esi
callq 0x8290
cmpl $-0x2, %eax
je 0x21f77
movl $0x4000, %eax           # imm = 0x4000
subl -0x78(%rbp), %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x80b0
cmpl $0x0, -0x78(%rbp)
je 0x21f32
leaq -0x98(%rbp), %rdi
callq 0x8360
movq %rbx, %rdi
callq 0xb1e4
addq $0x4078, %rsp           # imm = 0x4078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mapbox[P]svg-tools/test/path.hpp
// Function: mapbox::svg::test::operator<<(std::ostream&, std::vector<mapbox::svg::test::PathCommand, std::allocator<mapbox::svg::test::PathCommand>> const&)
::std::ostream& operator<<(::std::ostream& os, const Path& path) {
    os << "Path {" << std::endl;
    for (const auto& command : path) {
        os << "    " << command << "," << std::endl;
    }
    os << "}";
    return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2c7d(%rip), %rsi      # 0x42b9
movl $0x6, %edx
callq 0x10f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x16e2
leaq 0x2c40(%rip), %r15      # 0x42c0
leaq 0x2c3e(%rip), %r12      # 0x42c5
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12f2
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
addq $0x40, %r14
cmpq %r13, %r14
jne 0x1687
leaq 0x2ad9(%rip), %rsi      # 0x41c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mapbox[P]svg-tools/include/mapbox/svg/path_parser.hpp
// Function: mapbox::svg::PathParser<mapbox::svg::test::PathVertexReceiver>::parseNumber(double&)
bool parseNumber(double& value) {
        if (*cursor) {
            value = strtod(cursor, &next);
            if (cursor != next && value != HUGE_VAL) {
                cursor = next;
                skipSeparator();
                return true;
            }
        }
        error = PathParseErrorType::NumberParsing;
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
cmpb $0x0, (%rdi)
je 0x2fb5
movq %rsi, %r14
leaq 0x18(%rbx), %rsi
callq 0x1080
movsd %xmm0, (%r14)
movq 0x18(%rbx), %rcx
cmpq %rcx, 0x10(%rbx)
je 0x2fb5
ucomisd 0x118f(%rip), %xmm0     # 0x4120
jae 0x2fb5
movabsq $0x100002600, %rdx      # imm = 0x100002600
movq %rcx, 0x10(%rbx)
movzbl (%rcx), %eax
cmpq $0x2c, %rax
ja 0x2fd3
btq %rax, %rdx
jae 0x2fc6
incq %rcx
jmp 0x2f9d
movl $0x1, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x2c, %rax
jne 0x2fd3
incq %rcx
movq %rcx, 0x10(%rbx)
movzbl (%rcx), %esi
movb $0x1, %al
cmpq $0x20, %rsi
ja 0x2fbe
btq %rsi, %rdx
jb 0x2fcc
jmp 0x2fbe
// File: /workspace/github_cpp_makefile_star2_O3/mapbox[P]svg-tools/include/mapbox/svg/path_parser.hpp
// Function: mapbox::svg::PathParser<mapbox::svg::test::PathVertexReceiver>::parseFlag(bool&)
bool parseFlag(bool& value) {
        if (*cursor == '0') {
            value = false;
        } else if (*cursor == '1') {
            value = true;
        } else {
            error = PathParseErrorType::FlagParsing;
            return false;
        }
        ++cursor;
        skipSeparator();
        return true;
    }

// Assembly:
movq 0x10(%rdi), %rcx
movzbl (%rcx), %eax
cmpl $0x30, %eax
je 0x33db
cmpl $0x31, %eax
jne 0x340c
movb $0x1, %al
jmp 0x33dd
xorl %eax, %eax
movb %al, (%rsi)
incq %rcx
movabsq $0x100002600, %rdx      # imm = 0x100002600
movq %rcx, 0x10(%rdi)
movzbl (%rcx), %eax
cmpq $0x2c, %rax
ja 0x341d
btq %rax, %rdx
jae 0x3404
incq %rcx
jmp 0x33ec
cmpq $0x2c, %rax
je 0x3416
jmp 0x341d
movl $0x2, 0x20(%rdi)
xorl %eax, %eax
retq
incq %rcx
movq %rcx, 0x10(%rdi)
movzbl (%rcx), %esi
movb $0x1, %al
cmpq $0x20, %rsi
ja 0x342e
btq %rsi, %rdx
jb 0x3416
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mapbox[P]svg-tools/test/path.hpp
// Function: mapbox::svg::test::PathCommand::operator==(mapbox::svg::test::PathCommand const&) const
bool operator==(const PathCommand& other) const {
        return type == other.type && relative == other.relative &&
               largeArcFlag == other.largeArcFlag && sweepFlag == other.sweepFlag &&
               equals(x, other.x) && equals(y, other.y) && equals(x1, other.x1) &&
               equals(y1, other.y1) && equals(x2, other.x2) && equals(y2, other.y2) &&
               equals(xAxisRotation, other.xAxisRotation);
    }

// Assembly:
movb (%rdi), %al
cmpb (%rsi), %al
jne 0x37c2
movb 0x1(%rdi), %al
cmpb 0x1(%rsi), %al
jne 0x37c2
movb 0x2(%rdi), %al
cmpb 0x2(%rsi), %al
jne 0x37c2
movb 0x3(%rdi), %al
cmpb 0x3(%rsi), %al
jne 0x37c2
movsd 0x8(%rdi), %xmm1
subsd 0x8(%rsi), %xmm1
andpd 0x952(%rip), %xmm1      # 0x4070
movsd 0xa02(%rip), %xmm0      # 0x4128
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x10(%rdi), %xmm1
subsd 0x10(%rsi), %xmm1
andpd 0x92e(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x18(%rdi), %xmm1
subsd 0x18(%rsi), %xmm1
andpd 0x916(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x20(%rdi), %xmm1
subsd 0x20(%rsi), %xmm1
andpd 0x8fe(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x28(%rdi), %xmm1
subsd 0x28(%rsi), %xmm1
andpd 0x8e6(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x30(%rdi), %xmm1
subsd 0x30(%rsi), %xmm1
andpd 0x8ce(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
jbe 0x37c2
movsd 0x38(%rdi), %xmm1
subsd 0x38(%rsi), %xmm1
andpd 0x8b6(%rip), %xmm1      # 0x4070
ucomisd %xmm1, %xmm0
seta %al
retq
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::operator<<(std::ostream&, to::saved_options const&)::'lambda'(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::ostream& operator<<(std::ostream& out, const saved_options& s) {
        auto escape = [](const std::string& v) {
            if (!v.empty() && v.find_first_of("\\*?[#~=%|^;<>()$'`\" \t\n")==std::string::npos) return v;

            // Wrap string in single quotes, replacing any internal single quote
            // character with: '\''

            std::string q ="'";
            for (auto c: v) {
                c=='\''? q += "'\\''": q += c;
            }
            return q += '\'';
        };

        bool first = true;
        for (auto& p: s) {
            if (first) first = false; else out << ' ';
            out << escape(p);
        }
        return out;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0x3dfb
leaq 0x33e6(%rip), %rsi      # 0x71c8
movl $0x16, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x21f0
cmpq $-0x1, %rax
je 0x3ea9
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x33d7(%rip), %rsi      # 0x71e2
leaq 0x33d1(%rip), %rdx      # 0x71e3
leaq 0x8(%rsp), %rdi
callq 0x3f94
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x3e60
movq (%r14), %rbp
xorl %r12d, %r12d
leaq 0x33ad(%rip), %r14      # 0x71df
leaq 0x8(%rsp), %r15
movb (%rbp,%r12), %al
cmpb $0x27, %al
jne 0x3e4d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2280
jmp 0x3e58
movsbl %al, %esi
movq %r15, %rdi
callq 0x2140
incq %r12
cmpq %r12, %r13
jne 0x3e37
leaq 0x8(%rsp), %rdi
movl $0x27, %esi
callq 0x2140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3efe
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3ec2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x3ec2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3efe
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ed6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3ef5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::~MPSCQueue()
~MPSCQueue(){
        T output;
        while(this->dequeue(output));
        listNode* front = _head.load(std::memory_order_relaxed);
        delete front;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3160
testb %al, %al
jne 0x434b
movq 0x2890(%rbx), %r14
testq %r14, %r14
je 0x437c
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x437c
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movl $0x28, %esi
movq %r14, %rdi
callq 0x3200
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x43a0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x28c8(%rbx), %rdi
callq 0x3380
addq $0x27d8, %rbx           # imm = 0x27D8
movq $-0x2800, %r14          # imm = 0xD800
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x43d0
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
addq $-0x28, %rbx
addq $0x28, %r14
jne 0x43ba
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x43e8
jmp 0x43e8
jmp 0x43e8
movq %rax, %rdi
callq 0x381f
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/MPSCQueue.hpp
// Function: BSignals::details::MPSCQueue<std::function<void ()>, 256ul>::transferMaxToCache()
void transferMaxToCache(){
        T output;
        while (slowDequeue(output)){
            if (!fastEnqueue(output)){
                slowEnqueue(output);
                break;
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x2898(%rbx), %r15
movq 0x20(%r15), %r12
testq %r12, %r12
je 0x4196
movq %r14, %rdi
movq %r12, %rsi
callq 0x3070
movq %r12, 0x2898(%rbx)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x4129
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movl $0x28, %esi
movq %r15, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
testb %al, %al
jne 0x40ed
movl $0x28, %edi
callq 0x31f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3070
movq %r14, %rax
xchgq %rax, 0x2890(%rbx)
movq %r14, 0x20(%rax)
movb 0x28f8(%rbx), %al
testb $0x1, %al
je 0x4196
addq $0x28c8, %rbx           # imm = 0x28C8
movq %rbx, %rdi
callq 0x30f0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x41ad
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x41e1
jmp 0x41bf
jmp 0x41e1
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x41d9
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x381f
nop