LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Wombozo[P]harmony/src/Interval.cpp
// Function: Interval::getNextSorted(Note*)
Note *Interval::getNextSorted(Note *a)
{

    Note *tmp;
    // Get the natural note
    NaturalNote *ntmp = a->getNatural();
    for (int i = 0; i < type - 1; i++)
    {
        ntmp = ntmp->next;
    }
    // Test for altered notes
    SharpNote *stmp;
    FlatNote *ftmp;
    DblSharpNote *sstmp;
    DblFlatNote *fftmp;

    if (getSemiTones() == a->semiToneShift() + ntmp->getNextSTNatural())
    {
        tmp = (Note *)ntmp;
    }
    else if (getSemiTones() == a->semiToneShift() + ntmp->getNextSTNatural() + 1)
    {
        tmp = (Note *)ntmp->sn;
    }
    else if (getSemiTones() == a->semiToneShift() + ntmp->getNextSTNatural() - 1)
    {
        tmp = (Note *)ntmp->fn;
    }
    else if (getSemiTones() == a->semiToneShift() + ntmp->getNextSTNatural() + 2)
    {
        tmp = (Note *)ntmp->sn->sharp;
    }
    else if (getSemiTones() == a->semiToneShift() + ntmp->getNextSTNatural() - 2)
    {
        tmp = (Note *)ntmp->fn->flat;
    }
    else
    {
        throw E_INTERVAL;
    }
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %rbx
movl 0x20(%r15), %ecx
cmpl $0x2, %ecx
pushq $0x1
popq %rax
cmovgel %ecx, %eax
decl %eax
subl $0x1, %eax
jb 0x6550
movq 0x50(%rbx), %rbx
jmp 0x6545
movl 0x24(%r15), %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %r12d
movq %rbx, %rdi
callq 0x6028
addl %r12d, %eax
cmpl %eax, %r13d
je 0x661d
movl 0x24(%r15), %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %r12d
movq %rbx, %rdi
callq 0x6028
addl %r12d, %eax
incl %eax
cmpl %eax, %r13d
jne 0x659c
movq 0x60(%rbx), %rbx
jmp 0x6618
movl 0x24(%r15), %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %r12d
movq %rbx, %rdi
callq 0x6028
addl %r12d, %eax
decl %eax
cmpl %eax, %r13d
jne 0x65c4
movq 0x68(%rbx), %rbx
jmp 0x6618
movl 0x24(%r15), %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %r12d
movq %rbx, %rdi
callq 0x6028
addl %r12d, %eax
addl $0x2, %eax
cmpl %eax, %r13d
jne 0x65ed
movq 0x60(%rbx), %rax
jmp 0x6614
movl 0x24(%r15), %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6028
addl %r14d, %eax
addl $-0x2, %eax
cmpl %eax, %r15d
jne 0x663a
movq 0x68(%rbx), %rax
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x6636
movq (%rbx), %rax
addq -0x38(%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x6624
pushq $0x4
popq %rdi
callq 0x30f0
andl $0x0, (%rax)
leaq 0xb22c(%rip), %rsi      # 0x11878
movq %rax, %rdi
xorl %edx, %edx
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/Wombozo[P]harmony/src/Chord.cpp
// Function: Chord::Chord(Note*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Note*)
Chord::Chord(Note *n, const std::string &str, Note *b) : Chord(n, str, b, 0)
{
    // Remove the notes if the bass is one of the notes of the chord
    if (b != n)
    {
        auto foundIt = std::find(notes.rbegin(), notes.rend(), b);
        if (foundIt != notes.rend())
        {
            auto toRemove = --(foundIt.base());
            notes.erase(toRemove);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, -0x28(%rbp)
xorl %r8d, %r8d
callq 0x6af0
cmpq %r15, %r14
je 0x74dc
movq 0x60(%rbx), %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq 0x58(%rbx), %rax
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rcx
callq 0x7c3f
leaq 0x58(%rbx), %rdi
movq -0x20(%rbp), %rsi
cmpq (%rdi), %rsi
je 0x74dc
addq $-0x8, %rsi
callq 0x7c6e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74e9
movq %rax, %r14
movq %rbx, %rdi
callq 0x74fc
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/Wombozo[P]harmony/src/Chord.cpp
// Function: Chord::displayNotes[abi:cxx11]()
std::string Chord::displayNotes()
{
    std::string str;
    for (int i = 0; i < notes.size(); i++)
    {
        str += notes.at(i)->display() + " ";
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
leaq 0x58(%rsi), %r15
xorl %r12d, %r12d
leaq -0x50(%rbp), %r13
leaq -0x70(%rbp), %rbx
movq 0x60(%r14), %rax
subq 0x58(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x7bcd
movq %r15, %rdi
movq %r12, %rsi
callq 0x5be6
movq (%rax), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *(%rax)
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x49ed(%rip), %rdx      # 0xc594
callq 0x5b25
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x30d0
movq %r13, %rdi
callq 0x30d0
incq %r12
jmp 0x7b73
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x30d0
jmp 0x7bf1
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30d0
jmp 0x7bff
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/Wombozo[P]harmony/src/Triad.cpp
// Function: Triad::Triad(Note*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Note*)
Triad::Triad(Note *n, const std::string &str, Note *b) : Triad(n, str, b, 0)
{
    // Remove the notes if the bass is one of the notes of the chord
    if (b != n)
    {
        auto foundIt = std::find(notes.rbegin(), notes.rend(), b);
        if (foundIt != notes.rend())
        {
            auto toRemove = --(foundIt.base());
            notes.erase(toRemove);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, -0x28(%rbp)
xorl %r8d, %r8d
callq 0x88ac
cmpq %r15, %r14
je 0x9466
movq 0x78(%rbx), %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq 0x70(%rbx), %rax
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rcx
callq 0x7c3f
leaq 0x70(%rbx), %rdi
movq -0x20(%rbp), %rsi
cmpq (%rdi), %rsi
je 0x9466
addq $-0x8, %rsi
callq 0x7c6e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9473
movq %rax, %r14
movq %rbx, %rdi
callq 0x9486
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6032
leaq 0x70(%r14), %r15
movq 0x8(%r14), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x8486
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x9c04
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x8486
xorl %r12d, %r12d
leaq -0x30(%rbp), %r13
cmpq $0x2, %r12
je 0x9c3b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7e02
movq (%r14), %rsi
movq %rax, %rdi
callq 0x6516
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x9d90
incq %r12
jmp 0x9c0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
leaq 0x18(%rdi), %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x6032
leaq 0x40(%r12), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9d90
movq (%r12), %r15
movq 0x8(%r12), %r13
leaq -0x58(%rbp), %r12
cmpq %r13, %r15
je 0xa12c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7e20
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x6516
movq %rax, -0x30(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
callq 0x8486
movq %r12, %rdi
callq 0x6ab4
addq $0x28, %r15
jmp 0xa0f3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x6ab4
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
movq 0x48(%rdi), %rcx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0xa6cb
incl %eax
leaq 0x8(%rdx), %rdi
cmpq %rsi, (%rdx)
movq %rdi, %rdx
jne 0xa6b6
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x30f0
movl $0x5, (%rax)
leaq 0x7198(%rip), %rsi      # 0x11878
movq %rax, %rdi
xorl %edx, %edx
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %r13
movq 0x48(%rsi), %r15
leaq -0x48(%rbp), %r14
leaq -0x68(%rbp), %r12
cmpq %r15, %r13
je 0xa800
movq (%r13), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq %r12, %rdi
movq %r14, %rsi
leaq 0x1dba(%rip), %rdx      # 0xc594
callq 0x5b25
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32f0
movq %r12, %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x30d0
addq $0x8, %r13
jmp 0xa7bc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xa831
movq %rax, %r14
jmp 0xa828
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x32b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x70ad(%rip), %rdi      # 0x11fc8
callq 0x30e0
testl %r13d, %r13d
je 0xaf2b
movl %r13d, -0x2c(%rbp)
jmp 0xaf90
movq 0x7096(%rip), %rbx      # 0x11fc8
leaq 0x1557(%rip), %r14      # 0xc490
movq 0x7098(%rip), %r15      # 0x11fd8
leaq -0x2c(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x3120
movl -0x2c(%rbp), %r13d
cmpl $-0x1, %r13d
jne 0xaf75
callq 0xafa7
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 0xaf44
movl %r13d, %edi
callq 0xa844
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq 0x7013(%rip), %rbx      # 0x11fc8
leaq 0x151d(%rip), %rsi      # 0xc4d9
movq %rbx, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
leaq 0x1512(%rip), %rsi      # 0xc4e5
movq %rbx, %rdi
callq 0x3190
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x32a0
leaq 0x114b(%rip), %r14      # 0xc138
movq %rax, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
leaq 0x14f3(%rip), %rsi      # 0xc4fa
movq %rbx, %rdi
callq 0x3190
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
leaq 0x14db(%rip), %rsi      # 0xc50f
movq %rbx, %rdi
callq 0x3190
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xc0, %rsp
leaq -0xc0(%rbp), %rax
andq $0x0, -0x20(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq -0x88(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movb %cl, 0x10(%rax)
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
callq 0x1f90b
movq (%rax), %r15
movq 0x8(%rax), %r12
leaq -0xe0(%rbp), %rbx
movq 0x2e286(%rip), %r14     # 0x36f90
cmpq %r12, %r15
je 0x8d33
movl (%r15), %esi
movq %rbx, %rdi
callq 0x9b8a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9c7a
movq %rax, %rdi
callq 0x82c0
addq $0x4, %r15
jmp 0x8d0a
leaq -0xe0(%rbp), %rdi
callq 0x9d94
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x9d94
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/http_router.hpp
// Function: void httpc::HttpRouter::Invoke<main::$_0>(httpc::Request&, httpc::Response&, main::$_0)
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 %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x1eab4
movq %r14, %rdi
callq 0x1eab4
testq %rax, %rax
je 0x924a
movb $0x1, 0x120(%r14)
jmp 0x9259
leaq 0x18cc1(%rip), %rsi     # 0x21f12
movq %rbx, %rdi
callq 0x1eb00
cmpb $0x1, 0x121(%r14)
jne 0x9284
cmpb $0x1, 0x122(%r14)
jne 0x9284
movq 0xd0(%r14), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1eb2a
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/response.hpp
// Function: httpc::Response::SetDefault(httpc::HTTPStatusCodeEnum)
inline void SetDefault(HTTPStatusCodeEnum status) {
            this->http_major_version = this->http_minor_version = 1;
            this->status_code = status;
            this->reason_phrase = GetHTTPReasonPhrase(status);
            this->headers.clear();
            this->AddHeader("Content-Type", "text/html");
#ifdef HTTPC_ENABLE_GZIP
            this->AddHeader("Content-Encoding", "gzip");
            // this->headers.push_back({"Content-Encoding", "gzip"});
#endif
            this->message_body
                .assign("<html><body><h1>")
                .append(GetHTTPReasonPhrase(status))
                .append("</h1></body></html>");
#ifdef HTTPC_ENABLE_GZIP
            this->GzipEncode();
#endif
            this->SetContentLength_();
            
            //MakeDefaultResponse(status, *this);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x1f2d0
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x8630
movq %r15, %rdi
callq 0x8280
leaq 0x30(%rbx), %rdi
callq 0xa426
leaq 0x17b67(%rip), %rsi     # 0x21746
leaq 0x17b6d(%rip), %rdx     # 0x21753
movq %rbx, %rdi
callq 0xa434
leaq 0x17b68(%rip), %rsi     # 0x2175d
leaq 0x17b72(%rip), %rdx     # 0x2176e
movq %rbx, %rdi
callq 0xa434
leaq 0x48(%rbx), %rdi
leaq 0x17b64(%rip), %rsi     # 0x21773
callq 0x8900
movq %rax, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x1f2d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x8930
leaq 0x17b4c(%rip), %rsi     # 0x21784
movq %rax, %rdi
callq 0x88f0
leaq -0x40(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0xa4b2
movq %rbx, %rdi
callq 0xa4dc
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17b77(%rip), %rsi     # 0x2180f
callq 0x8530
movl (%r14), %esi
movq %rax, %rdi
callq 0x8840
leaq 0x17b81(%rip), %rsi     # 0x21830
movq %rax, %rdi
callq 0x8530
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x8840
leaq 0x18202(%rip), %r15     # 0x21ecc
movq %rax, %rdi
movq %r15, %rsi
callq 0x8530
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x8840
movq %rax, %rdi
movq %r15, %rsi
callq 0x8530
movq %rax, %r15
movl 0x8(%r14), %esi
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x1f2d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x84c0
movq %rax, %rdi
callq 0x82c0
leaq -0x48(%rbp), %rdi
callq 0x8280
movq 0x30(%r14), %r15
movq 0x38(%r14), %r13
leaq 0x181a1(%rip), %r12     # 0x21ecb
cmpq %r13, %r15
je 0x9d5f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x84c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x8530
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x84c0
movq %rax, %rdi
callq 0x82c0
addq $0x40, %r15
jmp 0x9d2a
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x118c6
leaq -0x10(%rbp), %rdx
movq %rbx, (%rdx)
leaq -0x20(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x1197c
leaq -0x18(%rbp), %rdi
callq 0xfcf6
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/response.hpp
// Function: httpc::Response::SetContentLength_()
inline void SetContentLength_() {
            for (auto itr = this->headers.begin(); itr != this->headers.end(); ++itr) {
                if (itr->field == "Content-Length") {
                    itr->value.assign(boost::lexical_cast<std::string>(this->message_body.length()));
                    return;
                }
            }
#ifdef HTTPC_ENABLE_GZIP
            this->headers.emplace_back(
                Header{
                    "Content-Length",
                    boost::lexical_cast<std::string>(this->gzip_message_body_.length())
                }
            );
#else
            this->headers.emplace_back(
                Header{
                    "Content-Length", 
                    boost::lexical_cast<std::string>(this->message_body.length())
                }
            );
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
movq 0x30(%rdi), %r15
leaq 0x172b9(%rip), %r12     # 0x217b9
cmpq 0x38(%r14), %r15
je 0xa51b
movq %r15, %rdi
movq %r12, %rsi
callq 0xaa85
testb %al, %al
jne 0xa584
addq $0x40, %r15
jmp 0xa500
leaq 0x17297(%rip), %rsi     # 0x217b9
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x9dd6
movq 0xa8(%r14), %rax
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0xaa95
leaq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xa77a
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0xa734
leaq -0xb0(%rbp), %rdi
callq 0xa64e
leaq -0x70(%rbp), %rdi
callq 0x8280
leaq -0x48(%rbp), %rdi
jmp 0xa5b0
addq $0x20, %r15
movq 0x50(%r14), %rax
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
callq 0xaa95
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8630
movq %rbx, %rdi
callq 0x8280
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0xa64e
jmp 0xa5d9
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x8280
jmp 0xa5e7
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq 0x30(%rdi), %r13
cmpq 0x38(%rbx), %r13
je 0xa6ab
movq %r13, %rdi
movq %r12, %rsi
callq 0xa708
testb %al, %al
jne 0xa6d3
addq $0x40, %r13
jmp 0xa690
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xa77a
movq %r15, %rdi
movq %r13, %rsi
callq 0xa734
leaq -0x68(%rbp), %rdi
callq 0xa64e
jmp 0xa6e2
addq $0x20, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x8330
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa64e
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/gzip.hpp
// Function: httpc::compress(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
inline bool compress(std::string_view data, std::string& compressed_data, int level = -1) {
		unsigned char out[CHUNK];
		z_stream strm;
		strm.zalloc = Z_NULL;
		strm.zfree = Z_NULL;
		strm.opaque = Z_NULL;
		if (deflateInit2(&strm, level, Z_DEFLATED, windowBits | GZIP_ENCODING, 8, Z_DEFAULT_STRATEGY) != Z_OK)
		{
			return false;
		}
		strm.next_in = (unsigned char*)data.data();
		strm.avail_in = (uInt)data.length();
		do {
			int have;
			strm.avail_out = CHUNK;
			strm.next_out = out;
			if (deflate(&strm, Z_FINISH) == Z_STREAM_ERROR)
			{
				return false;
			}
			have = CHUNK - strm.avail_out;
			compressed_data.append((char*)out, have);
		} while (strm.avail_out == 0);
		if (deflateEnd(&strm) != Z_OK)
		{
			return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4070, %rsp           # imm = 0x4070
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x16dc9(%rip), %r10     # 0x217b2
pushq $0x1f
popq %rax
pushq $0x8
popq %rdx
xorl %r14d, %r14d
movl %ecx, %esi
movl %eax, %ecx
movl %edx, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %r10
callq 0x8080
popq %rcx
popq %rdx
testl %eax, %eax
jne 0xaa72
leaq -0x90(%rbp), %r14
movq %r12, (%r14)
movl %r15d, 0x8(%r14)
leaq -0x4090(%rbp), %r15
pushq $0x4
popq %r12
movl $0x4000, -0x70(%rbp)    # imm = 0x4000
movq %r15, -0x78(%rbp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x82a0
cmpl $-0x2, %eax
je 0xaa6f
movl $0x4000, %eax           # imm = 0x4000
subl -0x70(%rbp), %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x80a0
cmpl $0x0, -0x70(%rbp)
je 0xaa24
leaq -0x90(%rbp), %rdi
callq 0x8380
testl %eax, %eax
sete %r14b
jmp 0xaa72
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x4070, %rsp           # imm = 0x4070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8540
movq %rax, %r14
leaq 0x80(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11a84
leaq -0x28(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1264e
movq (%r15), %r14
addq $0x18, %r14
leaq -0x38(%rbp), %rdi
movq %rbx, -0x8(%rdi)
addq $0x10, %rbx
movq %r15, %rsi
callq 0x1d5e2
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x11b7e
leaq -0x30(%rbp), %rdi
callq 0xfcf6
leaq -0x20(%rbp), %rdi
callq 0xfcf6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xfcf6
leaq -0x20(%rbp), %rdi
callq 0xfcf6
jmp 0x11974
movq %rax, %rbx
movl $0x508, %esi            # imm = 0x508
movq %r14, %rdi
callq 0x8550
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x13194
leaq 0x18(%rbx), %r14
leaq 0x68(%rbx), %rax
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
movq $0x200, 0x8(%r15)       # imm = 0x200
leaq -0x28(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x1d0c8
leaq -0x30(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1320a
leaq -0x20(%rbp), %rdi
callq 0xfcf6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xfcf6
movq %rbx, %rdi
callq 0x8850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x498(%rdi), %r14
movabsq $0xdf8475800, %rax      # imm = 0xDF8475800
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x13232
movq %rbx, (%r15)
leaq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x1d0c8
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x13286
leaq -0x20(%rbp), %rdi
callq 0xfcf6
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xfcf6
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa388
movq 0x22ac0(%rip), %rdi     # 0x36f90
movq %r14, %rsi
callq 0x84c0
movq %rax, %rdi
callq 0x82c0
leaq -0x50(%rbp), %rdi
callq 0x8280
pushq $0x2
popq %r14
cmpq %r15, %rbx
je 0x1450c
movsbl (%rbx), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x14b64
testl %eax, %eax
je 0x14509
incq %rbx
jmp 0x144ed
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
leaq -0x50(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8850
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/connection.hpp
// Function: httpc::Connection::CheckKeepAlive_()
void CheckKeepAlive_() {
            if (this->request_.http_major_version == 1) {
                bool conn_flag = false;
                auto itr = this->request_.FindHeader("Connection");
                if (itr != this->request_.HeaderCEnd()) {
                    if (itr->value == "close") {
                        this->keep_alive_ = false;
                    } else if (itr->value == "keep-alive") {
                        this->keep_alive_ = true;
                    }
                } else {
                    if (this->request_.http_minor_version == 1) {
                        this->keep_alive_ = true;
                    } else if (this->request_.http_minor_version == 0) {
                        this->keep_alive_ = false;
                    }
                }
            }
            if (this->keep_alive_) {
                this->response_.AddHeader(Header{"Connection", "keep-alive"});
            } else {
                this->response_.AddHeader(Header{"Connection", "close"});
            }
            
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
cmpl $0x1, 0x338(%rdi)
jne 0x145be
leaq 0x2a8(%r14), %rdi
leaq 0xd666(%rip), %rsi      # 0x21bc8
callq 0x14f58
cmpq 0x348(%r14), %rax
je 0x145a1
movq %rax, %rbx
addq $0x20, %rbx
leaq 0xd631(%rip), %rsi      # 0x21baf
movq %rbx, %rdi
callq 0xaa85
testb %al, %al
jne 0x145b1
leaq 0xd642(%rip), %rsi      # 0x21bd3
movq %rbx, %rdi
callq 0xaa85
movb $0x1, %cl
testb %al, %al
jne 0x145b7
jmp 0x145be
movl 0x33c(%r14), %eax
cmpl $0x1, %eax
je 0x145b5
testl %eax, %eax
jne 0x145be
xorl %ecx, %ecx
jmp 0x145b7
movb $0x1, %cl
movb %cl, 0x491(%r14)
leaq 0x3d0(%r14), %rbx
cmpb $0x1, 0x491(%r14)
jne 0x1461c
leaq 0xd5f2(%rip), %rsi      # 0x21bc8
leaq -0x58(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x9dd6
leaq 0xd5e9(%rip), %rsi      # 0x21bd3
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x9dd6
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa77a
leaq -0x98(%rbp), %rsi
movq %rbx, %rdi
callq 0x14f9e
jmp 0x14667
leaq 0xd5a5(%rip), %rsi      # 0x21bc8
leaq -0x58(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x9dd6
leaq 0xd578(%rip), %rsi      # 0x21baf
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x9dd6
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa77a
leaq -0x98(%rbp), %rsi
movq %rbx, %rdi
callq 0x14f9e
leaq -0x98(%rbp), %rdi
callq 0xa64e
leaq -0x38(%rbp), %rdi
callq 0x8280
leaq -0x58(%rbp), %rdi
callq 0x8280
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14693
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xa64e
jmp 0x146a9
jmp 0x146a6
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x8280
jmp 0x146b9
jmp 0x146b6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8280
jmp 0x146c9
jmp 0x146c6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8850
nop
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/request.hpp
// Function: auto httpc::Request::FindHeader<char const (&) [15]>(char const (&) [15]) const
auto FindHeader(StringT&& str) const {
            for (auto itr = this->HeaderCBegin(); itr != this->HeaderCEnd(); ++itr) {
                if (itr->field == str) {
                    return itr;
                }
            }
            return this->HeaderCEnd();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x98(%rdi), %r14
movq 0xa0(%r15), %rax
cmpq %rax, %r14
je 0x1471b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa85
testb %al, %al
jne 0x14718
addq $0x40, %r14
jmp 0x146f7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %rbx
leaq 0x3d0(%rdi), %rsi
leaq -0x38(%rbp), %rdi
callq 0x180b0
leaq -0x18(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x1d0c8
addq $0x18, %rbx
leaq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18085
leaq -0x10(%rbp), %rdi
callq 0xfcf6
leaq -0x38(%rbp), %rdi
callq 0x18436
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
callq 0xfcf6
jmp 0x14aa4
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x18436
movq %rbx, %rdi
callq 0x8850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x491(%rdi)
jne 0x18f9f
andl $0x0, 0x288(%rbx)
movl $0x1, 0x290(%rbx)
andq $0x0, 0x270(%rbx)
movq 0x268(%rbx), %rax
movb $0x0, (%rax)
leaq 0x2a8(%rbx), %rdi
callq 0x18fc6
leaq 0x3d0(%rbx), %rdi
callq 0x1903a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13120
leaq 0x498(%rbx), %rdi
callq 0x19088
movq %rbx, %rdi
callq 0x190da
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13756
nop
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/request.hpp
// Function: httpc::Request::Reset()
inline void Reset() {
            this->method.clear();
            this->uri.Reset();
            this->http_major_version = this->http_minor_version = 0;
            this->headers.clear();
            this->message_body.clear();
            this->files_.clear();
            this->fields_.clear();
            this->file_recv_flag_ = false;
            this->file_recv_complete_flag_ = false;
            this->file_recv_successfully_flag_ = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq (%rdi), %rax
xorl %r14d, %r14d
movb %r14b, (%rax)
addq $0x20, %rdi
callq 0x1910a
andq $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %rdi
callq 0xa426
andq $0x0, 0xb8(%rbx)
movq 0xb0(%rbx), %rax
movb %r14b, (%rax)
leaq 0xd0(%rbx), %rdi
callq 0x19130
leaq 0xe8(%rbx), %rdi
callq 0x124ba
andw $0x0, 0x120(%rbx)
movb %r14b, 0x122(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/response.hpp
// Function: httpc::Response::Reset()
inline void Reset() {
            this->http_major_version = this->http_minor_version = 0;
            this->status_code = static_cast<HTTPStatusCodeEnum>(0);
            this->reason_phrase.clear();
            this->headers.clear();
            this->message_body.clear();
#ifdef HTTPC_ENABLE_GZIP
            this->gzip_message_body_.clear();
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movq 0x10(%rdi), %rax
xorl %r14d, %r14d
movb %r14b, (%rax)
addq $0x30, %rdi
callq 0xa426
andq $0x0, 0x50(%rbx)
movq 0x48(%rbx), %rax
movb %r14b, (%rax)
andq $0x0, 0xa8(%rbx)
movq 0xa0(%rbx), %rax
movb %r14b, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19be2
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1a336
leaq 0x3d0(%rbx), %r15
leaq 0x7c21(%rip), %rsi      # 0x217b9
movq %r15, %rdi
callq 0x1a648
movq 0x10(%rbx), %rdi
leaq 0x2e8(%rbx), %rdx
movq %r14, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x14726
leaq 0x490(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1fd54
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14a38
nop
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/response.hpp
// Function: decltype(auto) httpc::Response::FindHeader<char const (&) [15]>(char const (&) [15])
decltype(auto) FindHeader(StringT&& field) {
            for (auto itr = this->HeaderCBegin(); itr != this->HeaderCEnd(); ++itr) {
                if (itr->field == field) {
                    return itr;
                }
            }
            return this->HeaderCEnd();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rdi), %r14
movq 0x38(%r15), %rax
cmpq %rax, %r14
je 0x1a67d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa85
testb %al, %al
jne 0x1a67a
addq $0x40, %r14
jmp 0x1a65c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/request.hpp
// Function: httpc::Request::GetFileSize() const
inline std::size_t GetFileSize() const {
            if (this->method == "POST") {
                auto itr = this->FindHeader("Content-Length");
                if (itr != this->HeaderCEnd()) {
                    return boost::lexical_cast<std::size_t>(itr->value);
                }
            }
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x345b(%rip), %rsi      # 0x21f1f
callq 0xaa85
testb %al, %al
je 0x1eaf7
leaq 0x2ce5(%rip), %rsi      # 0x217b9
movq %rbx, %rdi
callq 0x146e0
cmpq 0xa0(%rbx), %rax
je 0x1eaf7
addq $0x20, %rax
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1eb54
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/trisolaris233[P]httpc/src/response.hpp
// Function: void httpc::Response::SetMessageBody_<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 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 %rbx
pushq %rax
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x8330
movq %rbx, %rdi
callq 0xa4b2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa4dc