LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vividvilla[P]hackerrank/src/oobleck-boxes.cpp
// Function: getWays(int, int)
int getWays(int n, int m) {
    vector<int> w = vector<int>(n + 1, 0);

    for (long long i = 1; i <= n; i *= m) {
        w[i] = (w[i] + 1) % MOD;
        for (int j = i + 1; j <= n; j++) {
            w[j] = (w[j] + w[j - i]) % MOD;
        }
    }

    return w[n];
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movl 0x64(%rsp), %eax
incl %eax
cltq
movq %rax, 0x10(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x43(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1420
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rdx
callq 0x1430
jmp 0x128b
leaq 0x43(%rsp), %rdi
callq 0x14b0
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
movslq 0x64(%rsp), %rcx
cmpq %rcx, %rax
jg 0x138e
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movl (%rax), %eax
addl $0x1, %eax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cltd
idivl %ecx
movl %edx, 0xc(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movl 0xc(%rsp), %edx
movl %edx, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x64(%rsp), %eax
jg 0x1377
movslq 0x24(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movslq 0x24(%rsp), %rsi
subq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movq %rax, %rcx
movl 0x4(%rsp), %eax
addl (%rcx), %eax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cltd
idivl %ecx
movl %edx, 0x8(%rsp)
movslq 0x24(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movl 0x8(%rsp), %edx
movl %edx, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x12f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x43(%rsp), %rdi
callq 0x14b0
jmp 0x13b4
jmp 0x1379
movslq 0x60(%rsp), %rax
imulq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x129e
movslq 0x64(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x14c0
movl (%rax), %eax
movl %eax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0x14e0
movl (%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x10f0
nop
// File: vividvilla[P]hackerrank/src/oobleck-boxes.cpp
// Function: main
int main() {
    int n, m;
    cin >> n >> m;

    cout << getWays(n, m) << endl;

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movq 0x2c0d(%rip), %rdi      # 0x3fe0
leaq 0x10(%rsp), %rsi
callq 0x1070
movq %rax, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1070
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x1240
movl %eax, %esi
movq 0x2bd0(%rip), %rdi      # 0x3fd0
callq 0x10e0
movq %rax, %rdi
movq 0x2bb1(%rip), %rsi      # 0x3fc0
callq 0x10c0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH08_TheIOLibrary/examples/add_item.cc
// Function: main
int main()
{
	Sales_data data1, data2;
	read(cin, data1);                       // read the transactions
	read(cin, data2);                      
	// code to add into data1 and data2 unchanged from chapter 7
	if (data1.isbn() == data2.isbn()) {     // check isbns
		Sales_data sum = add(data1, data2); // add the transactions
		print(cout, sum);                   // print the results
		cout << endl;                       // followed by a newline 
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1470
leaq -0x68(%rbp), %rdi
callq 0x1470
movq -0xf0(%rbp), %rsi
movq 0x2cc7(%rip), %rdi      # 0x3fe0
callq 0x1650
jmp 0x1320
movq 0x2cb9(%rip), %rdi      # 0x3fe0
leaq -0x68(%rbp), %rsi
callq 0x1650
jmp 0x1332
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1540
jmp 0x1344
leaq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1540
jmp 0x1356
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x14b0
movb %al, -0xf1(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1080
leaq -0x98(%rbp), %rdi
callq 0x1080
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x1396
jmp 0x1426
leaq -0xe8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1750
jmp 0x13ac
movq 0x2c1d(%rip), %rdi      # 0x3fd0
leaq -0xe8(%rbp), %rsi
callq 0x17b0
jmp 0x13c1
movq 0x2c08(%rip), %rdi      # 0x3fd0
movq 0x2bf1(%rip), %rsi      # 0x3fc0
callq 0x10e0
jmp 0x13d6
leaq -0xe8(%rbp), %rdi
callq 0x1570
jmp 0x1426
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x144b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1080
jmp 0x144b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1570
jmp 0x144b
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1570
leaq -0x38(%rbp), %rdi
callq 0x1570
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x1570
leaq -0x38(%rbp), %rdi
callq 0x1570
movq -0x70(%rbp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH07_Classes/examples/Sales_data.cc
// Function: Sales_data::avg_price() const
double 
Sales_data::avg_price() const {
	if (units_sold)
		return revenue/units_sold;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x20(%rax)
je 0x16f2
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm0
movl 0x20(%rax), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x16fa
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wombozo[P]harmony/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    Note::initialize();
    try
    {
        std::cout << "// WELCOME TO HARMONY ANALYSER \\" << std::endl;
        std::cout << "This software has many features and will be improved by time. "
                     "Please use 'git pull' each time you want to use it to keep you updated."
                  << std::endl;
        if (argc > 1)
            interact(atoi(argv[1]));
        else
        {
            help();
            interact(0);
        }
    }
    catch (H_ERR err)
    {
        std::cout << "ERROR: " << handle_H_ERR(err) << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5350
movq 0x1bdce(%rip), %rdi     # 0x20fd0
leaq 0x13e02(%rip), %rsi     # 0x1900b
callq 0x3220
movq %rax, -0x48(%rbp)
jmp 0x5214
movq -0x48(%rbp), %rdi
movq 0x1bd99(%rip), %rsi     # 0x20fb8
callq 0x3250
jmp 0x5226
movq 0x1bda3(%rip), %rdi     # 0x20fd0
leaq 0x13df8(%rip), %rsi     # 0x1902c
callq 0x3220
movq %rax, -0x50(%rbp)
jmp 0x523f
movq -0x50(%rbp), %rdi
movq 0x1bd6e(%rip), %rsi     # 0x20fb8
callq 0x3250
jmp 0x5251
cmpl $0x1, -0x8(%rbp)
jle 0x5303
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3340
movl %eax, %edi
callq 0x18290
jmp 0x5271
jmp 0x5315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x533f
movq -0x18(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x1bd29(%rip), %rdi     # 0x20fd0
leaq 0x13e04(%rip), %rsi     # 0x190b2
callq 0x3220
movq %rax, -0x58(%rbp)
jmp 0x52b9
movl -0x20(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0xae50
jmp 0x52c7
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3210
movq %rax, -0x60(%rbp)
jmp 0x52da
movq -0x60(%rbp), %rdi
movq 0x1bcd3(%rip), %rsi     # 0x20fb8
callq 0x3250
jmp 0x52ec
leaq -0x40(%rbp), %rdi
callq 0x3190
callq 0x3380
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
callq 0x18360
jmp 0x530a
xorl %edi, %edi
callq 0x18290
jmp 0x5313
jmp 0x5315
jmp 0x52fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x533a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
callq 0x3380
movq -0x18(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: Wombozo[P]harmony/src/utils.cpp
// Function: valid_user_note_input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool valid_user_note_input(const std::string &str)
{
    for (auto snote : snotes)
    {
        if (!snote.compare(str))
            return true;
    }
    std::cout << "Available answers : ";
    for (auto snote : snotes)
    {
        std::cout << "| " + snote + " | ";
    }
    std::cout << std::endl;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x190b2(%rip), %rax     # 0x21388
movq %rax, -0x18(%rbp)
leaq 0x190a7(%rip), %rdi     # 0x21388
callq 0xa250
movq %rax, -0x20(%rbp)
leaq 0x19097(%rip), %rdi     # 0x21388
callq 0xa280
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa2b0
testb $0x1, %al
jne 0x8310
jmp 0x83a4
leaq -0x20(%rbp), %rdi
callq 0xa2f0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3100
movq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3040
movl %eax, -0xd4(%rbp)
jmp 0x8344
movl -0xd4(%rbp), %eax
cmpl $0x0, %eax
jne 0x8376
movb $0x1, -0x1(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x837d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3190
jmp 0x8509
movl $0x0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3190
movl -0x58(%rbp), %eax
testl %eax, %eax
je 0x8394
jmp 0x838f
jmp 0x84fb
jmp 0x8396
leaq -0x20(%rbp), %rdi
callq 0xa310
jmp 0x82fa
movq 0x18c25(%rip), %rdi     # 0x20fd0
leaq 0x10dea(%rip), %rsi     # 0x1919c
callq 0x3220
leaq 0x18fca(%rip), %rax     # 0x21388
movq %rax, -0x60(%rbp)
leaq 0x18fbf(%rip), %rdi     # 0x21388
callq 0xa250
movq %rax, -0x68(%rbp)
leaq 0x18faf(%rip), %rdi     # 0x21388
callq 0xa280
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa2b0
testb $0x1, %al
jne 0x83f8
jmp 0x84e4
leaq -0x68(%rbp), %rdi
callq 0xa2f0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3100
movq -0xe8(%rbp), %rdx
leaq 0x10d8d(%rip), %rsi     # 0x191b2
leaq -0xd0(%rbp), %rdi
callq 0xa380
jmp 0x8433
leaq 0x10d77(%rip), %rdx     # 0x191b1
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xa330
jmp 0x844f
movq 0x18b7a(%rip), %rdi     # 0x20fd0
leaq -0xb0(%rbp), %rsi
callq 0x3210
jmp 0x8464
leaq -0xb0(%rbp), %rdi
callq 0x3190
leaq -0xd0(%rbp), %rdi
callq 0x3190
leaq -0x90(%rbp), %rdi
callq 0x3190
leaq -0x68(%rbp), %rdi
callq 0xa310
jmp 0x83e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x84d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x84ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3190
leaq -0xd0(%rbp), %rdi
callq 0x3190
leaq -0x90(%rbp), %rdi
callq 0x3190
jmp 0x8509
movq 0x18ae5(%rip), %rdi     # 0x20fd0
movq 0x18ac6(%rip), %rsi     # 0x20fb8
callq 0x3250
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: Wombozo[P]harmony/src/utils.cpp
// Function: u_parse_note(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Note *u_parse_note(const std::string &str)
{
    Note *tmp;
    for (int i = 0; i < snotes.size(); i++)
    {
        if (!str.compare(snotes.at(i)))
        {
            tmp = Notes.at(i);
        }
    }
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x172c6(%rip), %rdi     # 0x21388
callq 0xa490
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xa120
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0x172a2(%rip), %rdi     # 0x21388
callq 0xa4b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3040
cmpl $0x0, %eax
jne 0xa113
movslq -0x14(%rbp), %rsi
leaq 0x17261(%rip), %rdi     # 0x21368
callq 0xa4f0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa115
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa0b3
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Wombozo[P]harmony/src/errors.cpp
// Function: handle_H_ERR[abi:cxx11](H_ERR)
std::string handle_H_ERR(H_ERR e)
{
    std::string str;
    switch (e)
    {
    case E_INTERVAL:
        str = "Invalid interval";
        break;
    case E_CHORD_UNKNOWN:
        str = "Unknown chord";
        break;
    case E_INVERSION:
        str = "Cannot invert chord";
        break;
    case E_SCALE_UNKNOWN:
        str = "Unknown scale";
        break;
    case E_CHOICE:
        str = "Bad choice";
        break;
    case E_DEGREE_NOT_FOUND:
        str = "Degree not found";
        break;
    case E_TYPE:
        str = "Wrong type";
        break;
    default:
        str = "Unknown error";
        break;
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x3300
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x6, %rax
ja 0xaf41
movq -0x28(%rbp), %rax
leaq 0xe4d5(%rip), %rcx      # 0x19364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
leaq 0xe4dd(%rip), %rsi      # 0x19380
callq 0x32f0
jmp 0xaeaa
jmp 0xaf55
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3190
jmp 0xaf72
movq -0x38(%rbp), %rdi
leaq 0xe4bd(%rip), %rsi      # 0x19391
callq 0x32f0
jmp 0xaedb
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe4b7(%rip), %rsi      # 0x1939f
callq 0x32f0
jmp 0xaeef
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe4b7(%rip), %rsi      # 0x193b3
callq 0x32f0
jmp 0xaf03
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe4b1(%rip), %rsi      # 0x193c1
callq 0x32f0
jmp 0xaf17
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe4a8(%rip), %rsi      # 0x193cc
callq 0x32f0
jmp 0xaf2b
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe4a5(%rip), %rsi      # 0x193dd
callq 0x32f0
jmp 0xaf3f
jmp 0xaf55
movq -0x38(%rbp), %rdi
leaq 0xe49c(%rip), %rsi      # 0x193e8
callq 0x32f0
jmp 0xaf53
jmp 0xaf55
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0xaf68
movq -0x38(%rbp), %rdi
callq 0x3190
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: Wombozo[P]harmony/src/NaturalNote.cpp
// Function: NaturalNote::sort()
void NaturalNote::sort()
{
    semiToneOrdered = BASE_ST;
    NaturalNote *nTmp = this;
    do
    {
        nTmp->next->semiToneOrdered = nTmp->semiToneNext + nTmp->semiToneOrdered;
        nTmp = nTmp->next;
    } while (nTmp != this->previous);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x48(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x48(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x58(%rcx), %rax
jne 0xb30b
popq %rbp
retq
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xca40
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0xe5dc
movq -0x78(%rbp), %rsi
addq $0x58, %rsi
movq %rsi, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf360
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xf3b0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rcx
callq 0xf2f0
jmp 0xe512
movq -0x78(%rbp), %rsi
addq $0x58, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xf3b0
movq -0xa0(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xf400
movb %al, -0x91(%rbp)
jmp 0xe542
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0xe551
jmp 0xe5da
leaq -0x28(%rbp), %rdi
callq 0xf430
movq %rax, -0xa8(%rbp)
jmp 0xe563
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf450
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x58(%rbp)
addq $0x58, %rax
movq %rax, -0xb8(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xf4e0
movq -0xb8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xf470
movq %rax, -0xb0(%rbp)
jmp 0xe5b6
movq -0xb0(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xe5da
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe5f0
jmp 0xe5e5
jmp 0xe5dc
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33d0
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3300
movl $0x0, -0x18(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x58, %rdi
callq 0x7ce0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0xf244
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa4f0
movq %rax, -0x90(%rbp)
jmp 0xf1ab
movq -0x90(%rbp), %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xf1c3
leaq 0xa3d7(%rip), %rdx      # 0x195a1
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa330
jmp 0xf1d9
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32d0
jmp 0xf1e8
leaq -0x38(%rbp), %rdi
callq 0x3190
leaq -0x58(%rbp), %rdi
callq 0x3190
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf166
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xf264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xf239
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3190
leaq -0x58(%rbp), %rdi
callq 0x3190
jmp 0xf264
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xf257
movq -0x80(%rbp), %rdi
callq 0x3190
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3190
movq -0x60(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0x13270
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x14e9c
movq -0x78(%rbp), %rsi
addq $0x70, %rsi
movq %rsi, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf360
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xf3b0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rcx
callq 0xf2f0
jmp 0x14dd2
movq -0x78(%rbp), %rsi
addq $0x70, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xf3b0
movq -0xa0(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xf400
movb %al, -0x91(%rbp)
jmp 0x14e02
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x14e11
jmp 0x14e9a
leaq -0x28(%rbp), %rdi
callq 0xf430
movq %rax, -0xa8(%rbp)
jmp 0x14e23
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf450
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x58(%rbp)
addq $0x70, %rax
movq %rax, -0xb8(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xf4e0
movq -0xb8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xf470
movq %rax, -0xb0(%rbp)
jmp 0x14e76
movq -0xb0(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x14e9a
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x14eb0
jmp 0x14ea5
jmp 0x14e9c
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33d0
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e30
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0xb2f0
movq -0x8(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e50
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xfc10
movq -0x8(%rbp), %rdi
callq 0x15e30
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e50
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x15c48
movq -0x8(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e30
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xfc10
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jge 0x15c9b
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xf940
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e30
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbf20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
leaq -0x28(%rbp), %rsi
callq 0x15f40
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15c4f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2f0
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x18, %rsi
callq 0x15f40
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11b90
testb $0x1, %al
jne 0x1694a
jmp 0x169d0
leaq -0x20(%rbp), %rdi
callq 0x11bd0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf980
movq -0x70(%rbp), %rax
movq -0x88(%rbp), %rdi
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x80(%rbp)
movq 0x18(%rax), %rsi
callq 0xbf20
movq %rax, -0x78(%rbp)
jmp 0x1698b
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xfc10
jmp 0x169a2
leaq -0x50(%rbp), %rdi
callq 0xc990
leaq -0x20(%rbp), %rdi
callq 0x11bf0
jmp 0x16934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc990
jmp 0x169d9
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x14(%rbp)
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfd70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfde0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10780
testb $0x1, %al
jne 0x175f0
jmp 0x1762c
leaq -0x28(%rbp), %rdi
callq 0x10610
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x17616
movl -0x14(%rbp), %eax
addl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17621
leaq -0x28(%rbp), %rdi
callq 0x12fc0
jmp 0x175dd
movl $0x4, %edi
callq 0x3140
movq %rax, %rdi
movl $0x5, (%rdi)
leaq 0x91f2(%rip), %rsi      # 0x20838
xorl %eax, %eax
movl %eax, %edx
callq 0x33a0
nop
// File: 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
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3300
movq -0x90(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfd70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfde0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10780
testb $0x1, %al
jne 0x17837
jmp 0x178e3
leaq -0x28(%rbp), %rdi
callq 0x10610
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
callq *%rax
jmp 0x17859
leaq 0x1d41(%rip), %rdx      # 0x195a1
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa330
jmp 0x1786f
movq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x32d0
jmp 0x17881
leaq -0x58(%rbp), %rdi
callq 0x3190
leaq -0x78(%rbp), %rdi
callq 0x3190
leaq -0x28(%rbp), %rdi
callq 0x12fc0
jmp 0x17821
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x17909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x178d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3190
leaq -0x78(%rbp), %rdi
callq 0x3190
jmp 0x17909
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x178f9
movq -0xa0(%rbp), %rdi
callq 0x3190
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3190
movq -0x80(%rbp), %rdi
callq 0x33d0
nop
// File: Wombozo[P]harmony/src/user.cpp
// Function: handle_choice(int)
void handle_choice(int c)
{
    switch (c)
    {
    case C_CD:
        handle_cd();
        break;
    case C_SD:
        handle_sd();
        break;
    case C_ID:
        handle_id();
        break;
    default:
        throw E_CHOICE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0x1794c
jmp 0x17938
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0x17953
jmp 0x17942
movl -0x8(%rbp), %eax
subl $0x3, %eax
je 0x1795a
jmp 0x17961
callq 0x17990
jmp 0x17984
callq 0x17c20
jmp 0x17984
callq 0x17f70
jmp 0x17984
movl $0x4, %edi
callq 0x3140
movq %rax, %rdi
movl $0x4, (%rdi)
leaq 0x8ebd(%rip), %rsi      # 0x20838
xorl %eax, %eax
movl %eax, %edx
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x8d2e(%rip), %rdi      # 0x20fd0
movq 0x8d0f(%rip), %rsi      # 0x20fb8
callq 0x3250
cmpl $0x0, -0x4(%rbp)
jne 0x18341
jmp 0x182ba
movq 0x8d0f(%rip), %rdi      # 0x20fd0
leaq 0x11d5(%rip), %rsi      # 0x1949d
callq 0x3220
movq %rax, %rdi
movq 0x8ce1(%rip), %rsi      # 0x20fb8
callq 0x3250
movq 0x8cfd(%rip), %rdi      # 0x20fe0
leaq -0x8(%rbp), %rsi
callq 0x3180
cmpl $-0x1, -0x8(%rbp)
jne 0x182f7
callq 0x18360
jmp 0x182f9
movq 0x8ce0(%rip), %rax      # 0x20fe0
movq (%rax), %rax
movq 0x8cd6(%rip), %rdi      # 0x20fe0
addq -0x18(%rax), %rdi
callq 0x3130
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x18334
movb $0x1, %al
cmpl $0x3, -0x8(%rbp)
movb %al, -0x9(%rbp)
jg 0x18334
cmpl $0x0, -0x8(%rbp)
setl %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x182ba
jmp 0x18347
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x17920
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq 0x8c65(%rip), %rdi      # 0x20fd0
leaq 0x1174(%rip), %rsi      # 0x194e6
callq 0x3220
movq %rax, %rdi
movq 0x8c37(%rip), %rsi      # 0x20fb8
callq 0x3250
movq 0x8c43(%rip), %rdi      # 0x20fd0
leaq 0x115e(%rip), %rsi      # 0x194f2
callq 0x3220
movq %rax, %rdi
movl $0x1, %esi
callq 0x33c0
movq %rax, %rdi
leaq 0xd88(%rip), %rsi       # 0x19138
callq 0x3220
movq %rax, %rdi
movq 0x8bf9(%rip), %rsi      # 0x20fb8
callq 0x3250
movq 0x8c05(%rip), %rdi      # 0x20fd0
leaq 0x1135(%rip), %rsi      # 0x19507
callq 0x3220
movq %rax, %rdi
movl $0x2, %esi
callq 0x33c0
movq %rax, %rdi
leaq 0xd4a(%rip), %rsi       # 0x19138
callq 0x3220
movq %rax, %rdi
movq 0x8bbb(%rip), %rsi      # 0x20fb8
callq 0x3250
movq 0x8bc7(%rip), %rdi      # 0x20fd0
leaq 0x110c(%rip), %rsi      # 0x1951c
callq 0x3220
movq %rax, %rdi
movl $0x3, %esi
callq 0x33c0
movq %rax, %rdi
leaq 0xd0c(%rip), %rsi       # 0x19138
callq 0x3220
movq %rax, %rdi
movq 0x8b7d(%rip), %rsi      # 0x20fb8
callq 0x3250
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
leaq -0xc0(%rbp), %rdi
callq 0xf550
callq 0x555a0
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0xf5c0
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rdi
callq 0xf5f0
movq %rax, -0xd8(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xf620
testb $0x1, %al
jne 0xb2f5
jmp 0xb383
leaq -0xd0(%rbp), %rdi
callq 0xf660
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movl (%rax), %esi
leaq -0xc0(%rbp), %rdi
callq 0xf680
jmp 0xb31f
movq 0x7ec62(%rip), %rdi     # 0x89f88
leaq -0xc0(%rbp), %rsi
callq 0xf7b0
movq %rax, -0xf8(%rbp)
jmp 0xb33b
movq -0xf8(%rbp), %rdi
movq 0x7ebc7(%rip), %rsi     # 0x89f10
callq 0xa720
jmp 0xb350
jmp 0xb352
leaq -0xd0(%rbp), %rdi
callq 0xf940
jmp 0xb2d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xf960
jmp 0xb398
leaq -0xc0(%rbp), %rdi
callq 0xf960
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0xab10
nopw %cs:(%rax,%rax)
// File: trisolaris233[P]httpc/src/http_router.hpp
// Function: void httpc::HttpRouter::RegisterRouter<(httpc::HttpMethodEnum)0, (httpc::HttpMethodEnum)1, main::$_0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, main::$_0&&)
void RegisterRouter(
            const std::string&  router_directory,
            Function&&          callback,
            Aspects&&...        aspects 
        ) {
            // if has at least one http method.
            if constexpr(sizeof...(Methods) > 0) {
                auto methods = GetMethodsStr<Methods...>();
                
                for (auto& method : methods) {
                    // register router for every method
                    RegisterRouterImpl_(
                        method,
                        router_directory, 
                        std::forward<Function>(callback), 
                        std::forward<Aspects>(aspects)...
                    );
                }
            } else {    // has no http method.
                RegisterRouterImpl_(
                    GetMethodStr<HttpMethodEnum::GET>(),
                    router_directory,
                    std::forward<Function>(callback),
                    std::forward<Aspects>(aspects)...
                );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x529a0
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x44760
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x445a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x45a10
testb $0x1, %al
jne 0xb99a
jmp 0xb9e2
leaq -0x40(%rbp), %rdi
callq 0x44cc0
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xba00
jmp 0xb9be
jmp 0xb9c0
leaq -0x40(%rbp), %rdi
callq 0x45a50
jmp 0xb987
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43ff0
jmp 0xb9f1
leaq -0x30(%rbp), %rdi
callq 0x43ff0
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xab10
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xa3b0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0xbef0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x1(%rbp), %rdi
callq 0xbf20
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0xbff0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x1, 0x4(%rax)
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54730
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x10, %rdi
callq 0xa840
movq -0x88(%rbp), %rdi
callq 0xa450
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
callq 0x127b0
movq -0x80(%rbp), %rdi
leaq 0x4a059(%rip), %rsi     # 0x59751
leaq 0x4a05f(%rip), %rdx     # 0x5975e
callq 0x127d0
movq -0x80(%rbp), %rdi
leaq 0x4a059(%rip), %rsi     # 0x59768
leaq 0x4a063(%rip), %rdx     # 0x59779
callq 0x127d0
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
leaq 0x4a054(%rip), %rsi     # 0x5977e
callq 0xac00
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x54730
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xac30
movq %rax, -0x68(%rbp)
jmp 0xf756
movq -0x68(%rbp), %rdi
leaq 0x4a02e(%rip), %rsi     # 0x5978f
callq 0xabf0
jmp 0xf768
leaq -0x50(%rbp), %rdi
callq 0xa450
movq -0x80(%rbp), %rdi
callq 0x12900
movq -0x80(%rbp), %rdi
callq 0x12960
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa450
movq -0x58(%rbp), %rdi
callq 0xab10
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4a04c(%rip), %rsi     # 0x5981a
callq 0xa6a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xab00
movq %rax, %rdi
leaq 0x4a050(%rip), %rsi     # 0x5983b
callq 0xa6a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xab00
movq %rax, %rdi
leaq 0x4a862(%rip), %rsi     # 0x5a06b
movq %rsi, -0x80(%rbp)
callq 0xa6a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xab00
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0xa6a0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x54730
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xa600
movq %rax, -0x68(%rbp)
jmp 0xf858
movq -0x68(%rbp), %rdi
movq 0x7a6ad(%rip), %rsi     # 0x89f10
callq 0xa720
jmp 0xf86a
leaq -0x30(%rbp), %rdi
callq 0xa450
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x14d00
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x14d30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x14d60
testb $0x1, %al
jne 0xf8ac
jmp 0xf916
leaq -0x50(%rbp), %rdi
callq 0x14da0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa600
movq %rax, %rdi
leaq 0x4a79a(%rip), %rsi     # 0x5a06a
callq 0xa6a0
movq %rax, %rdi
movq -0x60(%rbp), %rsi
addq $0x20, %rsi
callq 0xa600
movq %rax, %rdi
movq 0x7a621(%rip), %rsi     # 0x89f10
callq 0xa720
leaq -0x50(%rbp), %rdi
callq 0x14dc0
jmp 0xf899
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa450
jmp 0xf934
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0xa600
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xab10
nopl (%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
addq $0x30, %rdi
callq 0x12e40
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rdi
addq $0x30, %rdi
callq 0x12eb0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12e70
testb $0x1, %al
jne 0x129b1
jmp 0x12a32
leaq -0x10(%rbp), %rdi
callq 0x12f70
movq %rax, %rdi
leaq 0x46e00(%rip), %rsi     # 0x597c4
callq 0x13b80
testb $0x1, %al
jne 0x129cf
jmp 0x12a22
leaq -0x10(%rbp), %rdi
callq 0x12f70
movq -0xe8(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0xf0(%rbp)
addq $0x48, %rdi
callq 0xaa10
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13bb0
movq -0xf0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa6c0
leaq -0x38(%rbp), %rdi
callq 0xa450
jmp 0x12afa
jmp 0x12a24
leaq -0x10(%rbp), %rdi
callq 0x12f90
jmp 0x12987
movq -0xe8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x100(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xab40
movq -0xf8(%rbp), %rdx
leaq 0x46d5f(%rip), %rsi     # 0x597c4
leaq -0xa0(%rbp), %rdi
callq 0xf9c0
jmp 0x12a73
movq -0xe8(%rbp), %rdi
addq $0xa0, %rdi
callq 0xaa10
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x13bb0
jmp 0x12aa2
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x13030
jmp 0x12abb
movq -0x100(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x12fb0
jmp 0x12acd
leaq -0x80(%rbp), %rdi
callq 0x12ce0
leaq -0xd8(%rbp), %rdi
callq 0xa450
leaq -0xa0(%rbp), %rdi
callq 0xa450
leaq -0xa1(%rbp), %rdi
callq 0xa740
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x12b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x12b66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x12b5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x12ce0
leaq -0xd8(%rbp), %rdi
callq 0xa450
leaq -0xa0(%rbp), %rdi
callq 0xa450
leaq -0xa1(%rbp), %rdi
callq 0xa740
movq -0xb0(%rbp), %rdi
callq 0xab10
nopw (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movb $0x0, -0x19(%rbp)
addq $0x30, %rdi
callq 0x12e40
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rdi
addq $0x30, %rdi
callq 0x12eb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12e70
testb $0x1, %al
jne 0x12d6a
jmp 0x12dbf
leaq -0x28(%rbp), %rdi
callq 0x12f70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x12ee0
testb $0x1, %al
jne 0x12d85
jmp 0x12db2
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12f70
movq -0x90(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0xa070
movb $0x1, -0x19(%rbp)
jmp 0x12dbf
jmp 0x12db4
leaq -0x28(%rbp), %rdi
callq 0x12f90
jmp 0x12d43
testb $0x1, -0x19(%rbp)
jne 0x12e26
movq -0x88(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x13030
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x12fb0
jmp 0x12e04
leaq -0x70(%rbp), %rdi
callq 0x12ce0
jmp 0x12e26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x12ce0
jmp 0x12e36
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xab10
nop