LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/database.cpp
// Function: Scheduler::run()
void Scheduler::run() {
    while (!transactions.empty()) {
        unique_ptr<Transaction> tx = move(transactions.front());
        transactions.pop();
        wait(tx.get());

        if (tx->is_done) {
            tx->terminate();
            tx.reset();
            continue;
        }
        transactions.push(move(tx));
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x4f84
movq (%rax), %rcx
movq %rcx, (%rsp)
andq $0x0, (%rax)
movq %rbx, %rdi
callq 0x8362
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x4fa0
movq (%rsp), %rdi
cmpb $0x1, 0x48(%rdi)
jne 0x4f6f
addq $0xd0, %rdi
callq 0x33f0
movq %r14, %rdi
xorl %esi, %esi
callq 0x83cc
jmp 0x4f7a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7f8a
movq %r14, %rdi
callq 0x62a8
jmp 0x4f24
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x62a8
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/database.cpp
// Function: DataBase::~DataBase()
DataBase::~DataBase() {
    LOG;

    // checkpointing
    ofstream ofs_dump(dumpfilename_);  // dump file will be truncated
    for (const auto& [key, v] : table) {
        ofs_dump << key << " " << v.value << endl;
    }

    ofs_dump.close();
    close(fd_log_);

    // clear log file
    fd_log_ = open(logfilename_.c_str(), O_TRUNC);
    close(fd_log_);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x60c9(%rip), %rdi      # 0xb528
leaq 0x60e6(%rip), %rsi      # 0xb54c
movl $0xf9, %edx
xorl %eax, %eax
callq 0x3050
leaq 0x38(%rbx), %r14
leaq 0x8(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x3450
movq 0x18(%rbx), %r13
leaq 0x8(%rbx), %rbp
leaq 0x8(%rsp), %r15
leaq 0x60bc(%rip), %r12      # 0xb556
cmpq %rbp, %r13
je 0x54d7
leaq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x3250
movq %rax, %rdi
movq %r12, %rsi
callq 0x3270
movl 0x40(%r13), %esi
movq %rax, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x3140
movq %r13, %rdi
callq 0x31d0
movq %rax, %r13
jmp 0x549a
leaq 0x8(%rsp), %rdi
callq 0x3340
movl 0x78(%rbx), %edi
callq 0x3480
movq 0x58(%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x31f0
movl %eax, 0x78(%rbx)
movl %eax, %edi
callq 0x3480
leaq 0x58(%rbx), %r15
leaq 0x8(%rsp), %rdi
callq 0x3390
movq %r15, %rdi
callq 0x3498
movq %r14, %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x6c6a
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x553d
movq %rax, %rdi
callq 0x3ceb
nop
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/database.cpp
// Function: DataBase::deserialize(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<ChangeMode, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::pair<ChangeMode, int>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void DataBase::deserialize(DBDiff& diff, vector<string> buf) {
    for (const auto& line : buf) {
        vector<string> fields = words(line);
        if (fields.size() != 4) {
            diff = {};
            return;
        }
        // checksum validation
        string str = fields[1] + fields[2] + fields[3];
        if (((unsigned int) stol(fields[0])) != crc32(str)) {
            diff = {};
            return;
        }
        diff[fields[1]] = make_pair(
                stoi(fields[2]) ? Delete : New,
                stoi(fields[3]));
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, (%rsp)
movq (%rdx), %r14
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
leaq 0x8(%rsp), %r15
leaq 0x68(%rsp), %r13
pushq $0xa
popq %rbx
cmpq 0x20(%rsp), %r14
je 0x56af
movq %r15, %rdi
movq %r14, %rsi
callq 0x372c
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rdx, %rax
cmpq $0x80, %rax
jne 0x5698
leaq 0x20(%rdx), %rsi
addq $0x40, %rdx
movq %r13, %rdi
callq 0x63f1
movq 0x8(%rsp), %rdx
addq $0x60, %rdx
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x63d2
movq %r13, %rdi
callq 0x3498
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x6429
movq %rax, %rbp
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3320
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x3b6d
movl %eax, %ebx
movq %r12, %rdi
callq 0x3498
cmpl %ebp, %ebx
jne 0x5668
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
pushq $0xa
popq %r13
movl %r13d, %edx
callq 0x3bfe
movl %eax, %r15d
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x3bfe
movl %eax, %r13d
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
movq (%rsp), %rdi
callq 0x60c0
xorl %ecx, %ecx
testl %r15d, %r15d
setne %cl
movl %ecx, (%rax)
movl %r13d, 0x4(%rax)
leaq 0x8(%rsp), %r15
leaq 0x68(%rsp), %r13
jmp 0x5675
movq (%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x61b4
leaq 0x28(%rsp), %rdi
callq 0x3498
movq %r15, %rdi
callq 0x3ba2
addq $0x20, %r14
cmpl %ebp, %ebx
pushq $0xa
popq %rbx
je 0x5574
jmp 0x56af
movq (%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x61b4
leaq 0x8(%rsp), %rdi
callq 0x3ba2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56cf
jmp 0x56e5
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x56ed
movq %rax, %rbx
jmp 0x56f2
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3498
jmp 0x56e8
jmp 0x56e5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
leaq 0x8(%rsp), %rdi
callq 0x3ba2
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/database.cpp
// Function: DataBase::serialize(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<ChangeMode, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::pair<ChangeMode, int>>>>)
string DataBase::serialize(DBDiff diff) {
    string buf = "{\n";
    for (const auto& [key, value] : diff) {
        buf += make_log_format(value.first, key, value.second);
    }
    buf += "}\n";
    return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x5e8a(%rip), %rsi      # 0xb5a9
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x3c1a
movq 0x18(%r14), %r13
addq $0x8, %r14
leaq 0x8(%rsp), %r12
cmpq %r14, %r13
je 0x5787
leaq 0x20(%r13), %rsi
movl 0x40(%r13), %ebp
movq %r12, %rdi
callq 0x3320
movl 0x44(%r13), %r8d
movq %r15, %rdi
movl %ebp, %edx
movq %r12, %rcx
callq 0x57dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3470
movq %r15, %rdi
callq 0x3498
movq %r12, %rdi
callq 0x3498
movq %r13, %rdi
callq 0x31d0
movq %rax, %r13
jmp 0x5739
leaq 0x5ddf(%rip), %rsi      # 0xb56d
movq %rbx, %rdi
callq 0x3440
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57aa
movq %rax, %r14
jmp 0x57cb
movq %rax, %r14
jmp 0x57c1
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3498
leaq 0x8(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3498
movq %r14, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/database.cpp
// Function: DataBase::make_log_format(ChangeMode, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string DataBase::make_log_format(ChangeMode mode, Key key, int val) {
    string seed = key + to_string(mode) + to_string(val);
    string buf;
    buf += to_string(crc32(seed)) + " ";
    buf += key + " ";
    buf += to_string(mode) + " ";
    buf += to_string(val) + "\n";
    return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl %edx, %esi
callq 0x64d0
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x64ac
leaq 0x60(%rsp), %rdi
movl %ebp, %esi
callq 0x64d0
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
callq 0x6445
leaq 0x60(%rsp), %rdi
callq 0x3498
movq %rsp, %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
callq 0x3498
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x3320
leaq 0x40(%rsp), %rdi
callq 0x3b6d
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x6548
leaq 0x5cc6(%rip), %rdx      # 0xb556
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x6529
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3470
movq %rsp, %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
callq 0x3498
leaq 0x40(%rsp), %rdi
callq 0x3498
leaq 0x5c8b(%rip), %rdx      # 0xb556
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6587
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3470
movq %rsp, %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x64d0
leaq 0x5c59(%rip), %rdx      # 0xb556
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x6529
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3470
movq %rsp, %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x64d0
leaq 0x5c4c(%rip), %rdx      # 0xb586
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x6529
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3470
movq %rsp, %rdi
callq 0x3498
leaq 0x20(%rsp), %rdi
callq 0x3498
leaq 0x80(%rsp), %rdi
callq 0x3498
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x598a
jmp 0x5997
jmp 0x59c9
movq %rax, %r14
movq %rsp, %rdi
callq 0x3498
jmp 0x599a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x59fc
jmp 0x59c9
movq %rax, %r14
movq %rsp, %rdi
jmp 0x59fc
jmp 0x59c9
movq %rax, %r14
movq %rsp, %rdi
callq 0x3498
jmp 0x59bd
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3498
jmp 0x59f7
movq %rax, %r14
jmp 0x5a01
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x3498
jmp 0x59e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x3498
jmp 0x59ed
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x5a11
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3498
leaq 0x80(%rsp), %rdi
callq 0x3498
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/main.cpp
// Function: transaction1(Transaction*)
void transaction1(Transaction* tx) {
    tx->begin();
    tx->set("key1", 1);
    tx->set("key2", 2);
    tx->commit();
    // vector<string> keys = tx->keys();
    // for (const auto& key : keys)
    //     cout << key << endl;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x406e
leaq 0x1c80(%rip), %rsi      # 0xb790
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3c1a
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x438c
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x1c55(%rip), %rsi      # 0xb795
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3c1a
leaq 0x10(%rsp), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x438c
leaq 0x10(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x4110
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x9b8b
jmp 0x9b92
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x9b95
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/main.cpp
// Function: transaction4(Transaction*)
void transaction4(Transaction* tx) {
    tx->begin();
    int x = tx->get_until_success("key1");
    tx->set("key2", x + 10);
    tx->commit();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x406e
leaq 0x1b14(%rip), %rsi      # 0xb790
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c1a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x49e0
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x3498
leaq 0x1aea(%rip), %rsi      # 0xb795
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c1a
addl $0xa, %ebp
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x438c
leaq 0x8(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x4110
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x9cf9
jmp 0x9d00
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
jmp 0x9d03
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/main.cpp
// Function: transaction5(Transaction*)
void transaction5(Transaction* tx) {
    tx->begin();
    int x = tx->get_until_success("key2");
    tx->set("key1", x + 1);
    tx->commit();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x406e
leaq 0x1a75(%rip), %rsi      # 0xb795
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c1a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x49e0
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x3498
leaq 0x1a41(%rip), %rsi      # 0xb790
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c1a
incl %ebp
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x438c
leaq 0x8(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x4110
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x9d9c
jmp 0x9da3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
jmp 0x9da6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/momohatt[P]seccampDB/main.cpp
// Function: main
int main()
{
    scheduler.add_tx(move(transaction1));
    // scheduler.add_tx(move(transaction2));
    // scheduler.add_tx(move(transaction3));
    scheduler.add_tx(move(transaction4));
    scheduler.add_tx(move(transaction4));

    scheduler.start();
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x48(%rsp), %rbx
andq $0x0, 0x8(%rbx)
leaq -0x2ce(%rip), %rax      # 0x9afc
movq %rax, (%rbx)
leaq 0x282(%rip), %r14       # 0xa056
movq %r14, 0x18(%rbx)
leaq 0x27f(%rip), %r15       # 0xa05e
movq %r15, 0x10(%rbx)
leaq 0x84f6(%rip), %rdi      # 0x122e0
movq %rbx, %rsi
callq 0x4cbc
leaq 0x48(%rsp), %rdi
callq 0x628c
leaq 0x28(%rsp), %rbx
andq $0x0, 0x8(%rbx)
leaq -0x1a6(%rip), %r12      # 0x9c67
movq %r12, (%rbx)
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
leaq 0x84c1(%rip), %rdi      # 0x122e0
movq %rbx, %rsi
callq 0x4cbc
leaq 0x28(%rsp), %rdi
callq 0x628c
leaq 0x8(%rsp), %rbx
andq $0x0, 0x8(%rbx)
movq %r12, (%rbx)
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
leaq 0x8493(%rip), %rdi      # 0x122e0
movq %rbx, %rsi
callq 0x4cbc
leaq 0x8(%rsp), %rdi
callq 0x628c
leaq 0x847a(%rip), %rdi      # 0x122e0
callq 0x4e10
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9e7d
jmp 0x9e7d
movq %rax, %r14
movq %rbx, %rdi
callq 0x628c
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/magic_square.cpp
// Function: main
int main(){
    int rank;
    cout << "input the rank of magic square: ";
    cin >> rank;
    magic_square ms;
    auto ans = ms.get_magic_square(rank);
    ms.print_ans(ans, rank);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq 0x5168(%rip), %rdi      # 0x6fd0
leaq 0x21f6(%rip), %rsi      # 0x4065
callq 0x10e0
movq 0x5165(%rip), %rdi      # 0x6fe0
leaq -0x10(%rbp), %rbx
movq %rbx, %rsi
callq 0x1090
movl (%rbx), %edx
leaq -0x40(%rbp), %rbx
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ef2
leaq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x2298
movl -0x10(%rbp), %edx
leaq -0x9(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21a0
leaq -0x28(%rbp), %rdi
callq 0x22f2
leaq -0x40(%rbp), %rdi
callq 0x22f2
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x22f2
jmp 0x1ee1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x22f2
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/magic_square.cpp
// Function: magic_square::print_ans(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, int)
void print_ans(vector<vector<int>> ans, int rank){
        cout << "find " << ans.size() << " magic square!" << endl;
        for(auto p: ans){
            cout << "**********" << endl;
            print_magic_square(p, rank);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x4e0f(%rip), %rdi      # 0x6fd0
leaq 0x1ebe(%rip), %rsi      # 0x4086
callq 0x10e0
movq %rax, %rdi
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x10a0
leaq 0x1e9e(%rip), %rsi      # 0x408c
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
movq (%r15), %r12
movq 0x8(%r15), %rbx
leaq -0x60(%rbp), %r13
leaq -0x48(%rbp), %r15
cmpq %rbx, %r12
je 0x2267
movq %r13, %rdi
movq %r12, %rsi
callq 0x1a10
movq 0x4dac(%rip), %rdi      # 0x6fd0
leaq 0x1e70(%rip), %rsi      # 0x409b
callq 0x10e0
movq %rax, %rdi
callq 0x1070
movq %r15, %rdi
movq %r13, %rsi
callq 0x1a10
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0x3484
movq %r15, %rdi
callq 0x1aae
movq %r13, %rdi
callq 0x1aae
addq $0x18, %r12
jmp 0x220d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1aae
jmp 0x2287
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x1aae
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/magic_square.cpp
// Function: magic_square::add(std::vector<int, std::allocator<int>>, int, int)
int add(vector<int> p, int begin, int num){
        int ret = 0;
        for(int i = 0; i < num; i++){
            ret += p[begin + i];
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rdx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
subq $0x1, %rcx
jb 0x233d
movq (%rsi), %rdi
addl (%rdi,%rdx,4), %eax
incq %rdx
jmp 0x232c
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/magic_square.cpp
// Function: magic_square::if_magic_square(std::vector<int, std::allocator<int>>, int, int)
bool if_magic_square(vector<int> p, int rank, int magic_sum){
        int **array2D = new int *[rank];
        for(int i = 0; i < rank; i++){
            array2D[i] = new int[rank];
        }

        for(int i = 0; i < rank; i++){
            for(int j = 0; j < rank; j++){
                array2D[i][j] = p[i * rank + j];
            }
        }
        
        bool flag = true;
        int t1, t2, t3, t4;
        t3 = 0; t4 = 0;
        for(int i = 0; i < rank; i++){
            t1 = 0; t2 = 0;
            for(int j = 0; j < rank; j++){
                t1 += array2D[i][j];
                t2 += array2D[j][i];
            }
            if(t1 != magic_sum || t2 != magic_sum){
                flag = false;
                break;
            }
            t3 += array2D[i][i];
            t4 += array2D[rank - i - 1][i];
        }
        if(t3 != magic_sum || t4 != magic_sum){
            flag = false;
        }

        for(int i = 0; i < rank; i++){
            delete[] array2D[i];
        }
        delete[] array2D;
        return flag;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x30(%rbp)
movq %rsi, %r12
movslq %edx, %r13
leaq (,%r13,8), %rax
xorl %ebx, %ebx
testl %r13d, %r13d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movl $0x0, %r15d
movl %edx, -0x2c(%rbp)
cmovgl %edx, %r15d
callq 0x1030
movq %rax, %r14
movq %r13, -0x38(%rbp)
leaq (,%r13,4), %r13
cmpq %rbx, %r15
je 0x23a5
movq %r13, %rdi
callq 0x1030
movq %rax, (%r14,%rbx,8)
incq %rbx
jmp 0x238f
movl -0x2c(%rbp), %r9d
movl %r9d, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %r15, %rdx
je 0x23db
xorl %esi, %esi
cmpq %rsi, %rax
je 0x23d3
movq (%r12), %rdi
addq %rcx, %rdi
movl (%rdi,%rsi,4), %edi
movq (%r14,%rdx,8), %r8
movl %edi, (%r8,%rsi,4)
incq %rsi
jmp 0x23b7
incq %rdx
addq %r13, %rcx
jmp 0x23b0
xorl %ebx, %ebx
xorl %r10d, %r10d
xorl %r13d, %r13d
movl -0x30(%rbp), %r8d
cmpq %r15, %rbx
je 0x2433
xorl %edx, %edx
xorl %esi, %esi
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x240a
movq (%r14,%rbx,8), %rdi
addl (%rdi,%rdx,4), %esi
movq (%r14,%rdx,8), %rdi
addl (%rdi,%rbx,4), %ecx
incq %rdx
jmp 0x23f2
cmpl %r8d, %esi
jne 0x2433
cmpl %r8d, %ecx
jne 0x2433
movq (%r14,%rbx,8), %rcx
addl (%rcx,%rbx,4), %r10d
movl %ebx, %ecx
notl %ecx
addl %r9d, %ecx
movslq %ecx, %rcx
movq (%r14,%rcx,8), %rcx
addl (%rcx,%rbx,4), %r13d
incq %rbx
jmp 0x23e7
movl %r10d, -0x2c(%rbp)
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x2452
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x244d
callq 0x1100
incq %r12
jmp 0x243a
cmpq -0x38(%rbp), %rbx
setge %al
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %edx
xorl %ecx, %edx
xorl %ecx, %r13d
orl %edx, %r13d
sete %bl
andb %al, %bl
movq %r14, %rdi
callq 0x1100
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/magic_square.cpp
// Function: magic_square::print_magic_square(std::vector<int, std::allocator<int>>, int)
void print_magic_square(vector<int> p, int rank){
        for(int i = 0; i < rank; i++){
            for(int j = 0; j < rank; j++){
                cout << p[i * rank + j] << " ";
            }
            cout << endl;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movslq %edx, %rax
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movq %rcx, -0x40(%rbp)
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
movq 0x3b0f(%rip), %r14      # 0x6fd0
leaq 0xbbc(%rip), %r15       # 0x4084
xorl %eax, %eax
movq -0x38(%rbp), %r13
movq %r12, -0x50(%rbp)
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
je 0x351b
subq $0x1, %r13
jb 0x3502
movq (%rbx), %rax
movl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x1150
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
addq $0x4, %r12
jmp 0x34dc
movq %r14, %rdi
callq 0x1070
movq -0x48(%rbp), %rax
incq %rax
movq -0x50(%rbp), %r12
addq -0x30(%rbp), %r12
jmp 0x34ca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]image-morph/src/morph.cpp
// Function: blendImages(Image const&, Image const&, double)
Image
blendImages(Image const & img1, Image const & img2, double t)
{
  assert(img1.hasSameDimsAs(img2));

  std::cout << "Blending images..." << std::endl;

  int w = img1.width();
  int h = img1.height();
  int n = img1.numChannels();
  unsigned char *res_pix;
  const unsigned char *pix_1, *pix_2;

  Image result(w, h, n);

  for (int row = 0; row < h; ++row)
  {
    for (int col = 0; col < w; ++col)
    { 
      res_pix = result.pixel(row, col);
      pix_1 = img1.pixel(row, col);
      pix_2 = img2.pixel(row, col);

      for (int channel = 0; channel < n; ++channel)
      { 
        // weighted average of the value of the pixel
        double z = ((double)pix_1[channel] * t)
                 + ((double)pix_2[channel] * (1-t));
        res_pix[channel] = floor(z);
      }
    }
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, 0x20(%rsp)
movq %rdx, %rsi
callq 0x290c
testb %al, %al
je 0x30b8
movq 0x12050(%rip), %rdi     # 0x14fd0
leaq 0xc255(%rip), %rsi      # 0xf1dc
callq 0x21f0
movq %rax, %rdi
callq 0x2110
movl (%r12), %ebx
movl 0x4(%r12), %ebp
movl 0x8(%r12), %r13d
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r13d, %ecx
callq 0x25ce
xorl %edx, %edx
testl %r13d, %r13d
cmovlel %edx, %r13d
movsd 0xc0ce(%rip), %xmm0     # 0xf090
testl %ebx, %ebx
cmovlel %edx, %ebx
movl %ebx, 0x4(%rsp)
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0x30(%rsp)
testl %ebp, %ebp
cmovlel %edx, %ebp
movl %ebp, (%rsp)
movq %r14, 0x18(%rsp)
movq %r12, 0x10(%rsp)
cmpl (%rsp), %edx
je 0x30a6
xorl %ebp, %ebp
movq %rdx, 0x28(%rsp)
cmpl 0x4(%rsp), %ebp
je 0x309f
movl (%r14), %eax
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%r14), %eax
movslq %eax, %rbx
addq 0x10(%r14), %rbx
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%rcx), %eax
movslq %eax, %r14
addq 0x10(%rcx), %r14
movl (%r12), %eax
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%r12), %eax
movslq %eax, %r15
addq 0x10(%r12), %r15
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x3089
movzbl (%r15,%r12), %eax
cvtsi2sd %eax, %xmm0
movzbl (%r14,%r12), %eax
cvtsi2sd %eax, %xmm1
mulsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x23b0
movsd 0x8(%rsp), %xmm2
cvttsd2si %xmm0, %eax
movb %al, (%rbx,%r12)
incq %r12
jmp 0x304c
incl %ebp
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r12
movq 0x28(%rsp), %rdx
jmp 0x2ffd
incl %edx
jmp 0x2fed
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0cc(%rip), %rdi      # 0xf18b
leaq 0xc01d(%rip), %rsi      # 0xf0e3
leaq 0xc0d7(%rip), %rcx      # 0xf1a4
movl $0xb9, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]image-morph/src/morph.cpp
// Function: morphImages(Image const&, Image const&, std::vector<LineSegment, std::allocator<LineSegment>> const&, std::vector<LineSegment, std::allocator<LineSegment>> const&, double, double, double, double)
Image
morphImages(Image const & img1,
            Image const & img2,
            std::vector<LineSegment> const & seg1,
            std::vector<LineSegment> const & seg2,
            double t,
            double a, double b, double p)
{
  assert(img1.hasSameDimsAs(img2));

  // First distort img1 from 0 to t
  // using seg1 as the initial segments and seg2 as the final ones.
  Image distorted1 = distortImage(img1, seg1, seg2, t, a, b, p);

  // Then distort img2 from 1 to (1 - t)
  // using seg2 as the initial segments and seg1 as the final ones.
  Image distorted2 = distortImage(img2, seg2, seg1, 1-t, a, b, p);

  // Now blend the results by linearly interpolating ("lerping")
  Image blended = blendImages(distorted1, distorted2, 1-t);

  // return Image();
  return blended;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x290c
testb %al, %al
je 0x31ba
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x2ba2
movsd 0xbf41(%rip), %xmm0     # 0xf090
subsd (%rsp), %xmm0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x2ba2
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x2f47
leaq 0x20(%rsp), %rdi
callq 0x27b4
leaq 0x38(%rsp), %rdi
callq 0x27b4
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xbfca(%rip), %rdi      # 0xf18b
leaq 0xbf1b(%rip), %rsi      # 0xf0e3
leaq 0xc020(%rip), %rcx      # 0xf1ef
movl $0xe3, %edx
callq 0x2150
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27b4
jmp 0x31eb
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x27b4
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]image-morph/src/LineSegment.hpp
// Function: LineSegment::segmentDistance(Vec2 const&, double, double) const
double segmentDistance(Vec2 const & p, double u, double v) const
    {
      // projects before start()
      if(u < 0)
        return (p - start()).length();
      // projects on the line
      else if (u > 1)
        return (p - start()).length();
      // projects after end()
      else
        return abs(v);
      return 0;
    }

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
ja 0x3c04
ucomisd 0xb48e(%rip), %xmm0     # 0xf090
jbe 0x3c27
movsd (%rsi), %xmm0
subsd (%rdi), %xmm0
movsd 0x8(%rsi), %xmm1
subsd 0x8(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
retq
cvttsd2si %xmm1, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cvtsi2sd %ecx, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/gap.cpp
// Function: GapStat::calculate(Msa&)
void
GapStat :: calculate(Msa & msa)
{
	int L = msa.getNcol();
	int N = msa.getNseq();
	for (int x(0); x < L; ++x){
		col_stat.push_back((float) msa.getGap(x) / (float) N);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xcc(%rsi), %r12d
addq $0x8, %r14
cvtsi2ssl 0xc8(%rsi), %xmm0
movss %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
leaq 0xc(%rsp), %r15
cmpl %ebp, %r12d
je 0x4803
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9c0c
cvtsi2ss %eax, %xmm0
divss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c80
incl %ebp
jmp 0x47d5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/statistic.h
// Function: Stat1D::print(Msa&)
void print(Msa & msa){
		ofstream file(Options::Get().output_fname.c_str());
		if (!file.is_open()){
			cerr << "Cannot open file " << Options::Get().output_fname << "\n";
			exit(0);
		}
		if (Options::Get().global){
			float total = 0.0;
			for (int col(0); col < (int) col_stat.size(); ++col){
				total += col_stat[col];
			}
			file << total / (int) col_stat.size() << "\n";
		} else {
			for (int col(0); col < (int) col_stat.size(); ++col){
				file << col + 1 << "\t" << col_stat[col] << "\n";
			}
		}
		file.close();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
callq 0x4a00
movq 0xa8(%rax), %rsi
movq %rsp, %rdi
pushq $0x10
popq %rdx
callq 0x42a0
leaq 0x70(%rsp), %rdi
callq 0x4080
testb %al, %al
je 0x493d
callq 0x4a00
cmpb $0x0, 0xed(%rax)
je 0x489d
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
subq %rcx, %rax
shrq $0x2, %rax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
xorps %xmm0, %xmm0
cmpq %rdx, %rsi
je 0x48fd
addss (%rcx,%rdx,4), %xmm0
incq %rdx
jmp 0x488e
xorl %r13d, %r13d
movq %rsp, %r14
leaq 0x8788(%rip), %r15      # 0xd032
leaq 0x8c45(%rip), %r12      # 0xd4f6
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x2, %rax
cltq
cmpq %rax, %r13
jge 0x491c
leal 0x1(%r13), %esi
movq %r14, %rdi
callq 0x4420
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq 0x8(%rbx), %rcx
movss (%rcx,%r13,4), %xmm0
movq %rax, %rdi
callq 0x41e0
incq %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
jmp 0x48b1
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movq %rsp, %rdi
callq 0x41e0
leaq 0x8be2(%rip), %rsi      # 0xd4f6
movq %rax, %rdi
callq 0x4250
movq %rsp, %rdi
callq 0x4360
movq %rsp, %rdi
callq 0x4380
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xe6a4(%rip), %rdi      # 0x12fe8
leaq 0x86d5(%rip), %rsi      # 0xd020
callq 0x4250
movq %rax, %rbx
callq 0x4a00
addq $0xa8, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4240
leaq 0x8b86(%rip), %rsi      # 0xd4f6
movq %rax, %rdi
callq 0x4250
xorl %edi, %edi
callq 0x42d0
jmp 0x4983
jmp 0x4983
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4380
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/kabat.cpp
// Function: KabatStat::calculate(Msa&)
void
KabatStat :: calculate(Msa & msa)
{
	int k;                    // number of amino acid types in a given column
	int n1;                   // number of occurences of the most represented residue in a column
	int N = msa.getNseq();    // number of sequences in the msa
	int ncol = msa.getNcol(); // number of columns in the multiple alignment
	vector<int> naa;

	for (int x(0); x < ncol; ++x){
		k = msa.getNtype(x);
  	/* Find the most represented amino acid type (n1) */
		string aa_type = msa.getTypeList(x);
		vector<int> nb_aa(aa_type.size(), 0);
		for (int s(0); s < N; ++s){
			nb_aa[aa_type.find(msa.getSymbol(s, x))]++;
		}
		n1 = 0;
		for (int i(0); i < (int) nb_aa.size(); ++i)
			if (nb_aa[i] > n1)
				n1 = nb_aa[i];
		/* Calculate conservation from Wu & Kabat formula */
		col_stat.push_back((float)k / (float) n1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movl 0xc8(%rsi), %r14d
movl 0xcc(%rsi), %eax
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
testl %eax, %eax
cmovlel %r15d, %eax
movq %rax, 0x20(%rsp)
shlq $0x5, %r14
leaq 0x58(%rsp), %r12
leaq 0x28(%rsp), %rbp
cmpq 0x20(%rsp), %r15
je 0x5ae9
movq 0xb0(%rbx), %rax
movl (%rax,%r15,4), %eax
movl %eax, 0x14(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5b36
movq 0x60(%rsp), %rsi
andl $0x0, 0xc(%rsp)
movq %rbp, %r13
movq %rbp, %rdi
leaq 0xc(%rsp), %rdx
leaq 0x13(%rsp), %rcx
callq 0x5b52
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x5a7f
movq 0x38(%rbx), %rax
movq (%rax,%rbp), %rax
movsbl (%rax,%r15), %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x4340
movq 0x28(%rsp), %rcx
incl (%rcx,%rax,4)
addq $0x20, %rbp
jmp 0x5a55
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorl %esi, %esi
movq %r13, %rbp
cmpq %rdx, %rcx
je 0x5aae
movl (%rax,%rdx,4), %edi
cmpl %esi, %edi
cmovgl %edi, %esi
incq %rdx
jmp 0x5a9c
cvtsi2ssl 0x14(%rsp), %xmm0
cvtsi2ss %esi, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x4c80
movq %rbp, %rdi
callq 0x5bbe
movq %r12, %rdi
callq 0x4110
incq %r15
jmp 0x5a0c
leaq 0x40(%rsp), %rdi
callq 0x5bbe
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5b23
movq %rax, %rbx
jmp 0x5b19
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5bbe
leaq 0x58(%rsp), %rdi
callq 0x4110
leaq 0x40(%rsp), %rdi
callq 0x5bbe
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/options.h
// Function: Options::Parse(int, char* const*)
static void Parse(int argc_, char * const argv_[])
		{
			Options & opt = GetNC();
			try{
				opt.Init(argc_,argv_);
			} catch (exception &e) {
				throw;
			}
		}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x4a00
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x640a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x5ef8
movq %rbx, %rdi
callq 0x40e0
callq 0x4370
movq %rax, %rbx
callq 0x43f0
movq %rbx, %rdi
callq 0x4430
movq %rax, %rdi
callq 0x49c1
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/options.h
// Function: Options::getEnvVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string getEnvVar(string env)
		{
			char * env_p;
			string env_s;
			env_p = getenv(env.c_str());
			if (env_p != NULL)
				env_s = env_p;
			else
				cerr << "Warning: Environment variable " << env << " is not found\n";
			return env_s;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movb $0x0, 0x10(%rdi)
movq (%rdx), %rdi
callq 0x42e0
testq %rax, %rax
je 0x7a6a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x44b0
jmp 0x7a97
movq 0xb577(%rip), %rdi      # 0x12fe8
leaq 0x59fe(%rip), %rsi      # 0xd476
callq 0x4250
movq %rax, %rdi
movq %r14, %rsi
callq 0x4240
leaq 0x5a06(%rip), %rsi      # 0xd495
movq %rax, %rdi
callq 0x4250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/options.h
// Function: SwitchArg::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void find(vector<string> & command_line)
		{
			vector<string>::iterator it = command_line.begin();
			while (it != command_line.end()){
				if (*it == _small_flag || *it == _long_flag){
					if (_small_flag == "-h"){
						throw runtime_error("");
					}
					command_line.erase(it);
					_value = true;
					return;
				}
				it++;
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x8(%rdi), %r12
leaq 0x28(%rdi), %r13
cmpq 0x8(%r14), %r15
je 0x7d4a
movq %r15, %rdi
movq %r12, %rsi
callq 0x8e0c
testb %al, %al
jne 0x7d28
movq %r15, %rdi
movq %r13, %rsi
callq 0x8e0c
testb %al, %al
jne 0x7d28
addq $0x20, %r15
jmp 0x7cfe
leaq 0x55c0(%rip), %rsi      # 0xd2ef
movq %r12, %rdi
callq 0x8e35
testb %al, %al
jne 0x7d54
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e42
movb $0x1, 0x6a(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x52cd(%rip), %rsi      # 0xd033
movq %rax, %rdi
callq 0x40d0
movq 0xb27b(%rip), %rsi      # 0x12ff0
movq 0xb23c(%rip), %rdx      # 0x12fb8
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::defineAlphabet()
void
Msa :: defineAlphabet(){
	alphabet.clear();
	for(int col(0); col < ncol; ++col){
		for(int row(0); row < nseq; ++row){
			if (alphabet.find(mali_seq[row][col]) >= alphabet.size()){
				alphabet.push_back(mali_seq[row][col]);
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
xorl %r14d, %r14d
movslq 0xcc(%rbx), %rax
cmpq %rax, %r14
jge 0x973f
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0xc8(%rbx), %rax
cmpq %rax, %r12
jge 0x973a
movq 0x38(%rbx), %rax
movq (%rax,%r15), %rax
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4340
cmpq 0x8(%rbx), %rax
jb 0x9731
movq 0x38(%rbx), %rax
movq (%rax,%r15), %rax
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x4220
incq %r12
addq $0x20, %r15
jmp 0x96f3
incq %r14
jmp 0x96e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::countGap()
void
Msa :: countGap(){
	for(int col(0); col < ncol; ++col){
		int gap = 0;
		for(int row(0); row < nseq; ++row){
			if (mali_seq[row][col] == '-' || mali_seq[row][col] == ' '){
				gap++;
			}
		}
		gap_counts.push_back(gap);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
movslq 0xcc(%rbx), %rax
cmpq %rax, %r12
jge 0x97bf
andl $0x0, 0x4(%rsp)
movl 0xc8(%rbx), %eax
movq 0x38(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
shlq $0x5, %rax
xorl %esi, %esi
cmpq %rdx, %rax
je 0x97af
movq (%rcx,%rdx), %rdi
movzbl (%rdi,%r12), %edi
cmpl $0x2d, %edi
je 0x97a3
cmpl $0x20, %edi
jne 0x97a9
incl %esi
movl %esi, 0x4(%rsp)
addq $0x20, %rdx
jmp 0x978b
movq %r14, %rdi
movq %r15, %rsi
callq 0xa13c
incq %r12
jmp 0x9763
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::countFreq()
void
Msa :: countFreq(){
	int total = 0;
	vector<int> tmp_freq(alphabet.size(), 0);
	
	aa_freq = vector<float>(alphabet.size());
	/* Count the number of each amino acid type defined in alphabet */
	for(int col(0); col < ncol; ++col){
		for(int row(0); row < nseq; ++row){
			if (mali_seq[row][col] != '-' && mali_seq[row][col] != ' '){
				total++;
			}
			int pos = (int) alphabet.find(mali_seq[row][col]);
			if (pos >= (int) alphabet.size()){
			  cerr << "error : symbol is not in the alphabet\n";
				exit(0);
			}
			tmp_freq[pos]++;
		}
	}

	/* Divide by the total */
	for (int i(0); i < (int) aa_freq.size(); ++i){
		aa_freq[i] = (float) tmp_freq[i] ;
		aa_freq[i] /= (float) total;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x20(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x5b52
movq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa15a
leaq 0x80(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0xa4ce
movq %r14, %rdi
callq 0x49cc
xorl %r14d, %r14d
xorl %ebp, %ebp
movslq 0xcc(%rbx), %rax
cmpq %rax, %r14
jge 0x989a
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0xc8(%rbx), %rax
cmpq %rax, %r12
jge 0x9895
movq 0x38(%rbx), %rax
movq (%rax,%r15), %rax
movb (%rax,%r14), %r13b
movsbl %r13b, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4340
cmpl 0x8(%rbx), %eax
jge 0x98f0
cmpb $0x2d, %r13b
setne %cl
cmpb $0x20, %r13b
setne %dl
movq 0x8(%rsp), %rsi
cltq
incl (%rsi,%rax,4)
andb %cl, %dl
movzbl %dl, %eax
addl %eax, %ebp
incq %r12
addq $0x20, %r15
jmp 0x983e
incq %r14
jmp 0x982c
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movq 0x8(%rsp), %rdx
cvtsi2ss %ebp, %xmm0
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x98d7
cvtsi2ssl (%rdx,%rsi,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rax,%rsi,4)
incq %rsi
jmp 0x98bf
leaq 0x8(%rsp), %rdi
callq 0x5bbe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x96f1(%rip), %rdi      # 0x12fe8
leaq 0x3dd3(%rip), %rsi      # 0xd6d1
callq 0x4250
xorl %edi, %edi
callq 0x42d0
jmp 0x990c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5bbe
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::countEntropy()
void 
Msa :: countEntropy(){
	entropy = vector<float>(ncol,0.0);
 
  for(int col(0); col < ncol; ++col){
		vector<float> lfreq(alphabet.size(), 0.0);
		for(int row(0); row < nseq; ++row){
			lfreq[getAaPos(mali_seq[row][col])] += 1.0;
		}
		for (int i(0); i < (int) lfreq.size(); ++i){
		  lfreq[i] /= (float) nseq;
			if (lfreq[i] > 0.0){
				if (lfreq[i] == 1.0){
				  entropy[col] = 0.0;	
				} else {
				  entropy[col] -= lfreq[i] * log(lfreq[i]);	
				}
			}
		}
		entropy[col] /= log(alphabet.size()-1); /* -1 because gaps are in the alphabet */
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0xcc(%rdi), %rsi
leaq 0x8(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rcx
movq %r15, %rdi
callq 0xa1ac
leaq 0x98(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xa4ce
movq %r15, %rdi
callq 0x49cc
xorl %ebp, %ebp
movslq 0xcc(%rbx), %rax
cmpq %rax, %rbp
jge 0x9b94
movq 0x8(%rbx), %rsi
andl $0x0, 0x8(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xa1ac
xorl %r12d, %r12d
xorl %r14d, %r14d
movslq 0xc8(%rbx), %rax
cmpq %rax, %r14
jge 0x9ae3
movq 0x38(%rbx), %rax
movq (%rax,%r12), %rax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x9bdc
cltq
movq 0x10(%rsp), %rcx
movss (%rcx,%rax,4), %xmm0
addss 0x357f(%rip), %xmm0     # 0xd054
movss %xmm0, (%rcx,%rax,4)
incq %r14
addq $0x20, %r12
jmp 0x9aa1
xorl %r12d, %r12d
xorps %xmm1, %xmm1
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x9b5f
cvtsi2ssl 0xc8(%rbx), %xmm2
movss (%rax,%r12,4), %xmm0
divss %xmm2, %xmm0
movss %xmm0, (%rax,%r12,4)
ucomiss %xmm1, %xmm0
jbe 0x9b5a
ucomiss 0x352e(%rip), %xmm0     # 0xd054
jne 0x9b34
jp 0x9b34
movq (%r13), %rax
andl $0x0, (%rax,%rbp,4)
jmp 0x9b5a
movss %xmm0, 0xc(%rsp)
callq 0x4490
movq (%r13), %rax
movss (%rax,%rbp,4), %xmm1
mulss 0xc(%rsp), %xmm0
subss %xmm0, %xmm1
movss %xmm1, (%rax,%rbp,4)
xorps %xmm1, %xmm1
incq %r12
jmp 0x9ae9
movq 0x8(%rbx), %rdi
decq %rdi
callq 0xa202
movq 0x98(%rbx), %rax
cvtss2sd (%rax,%rbp,4), %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rax,%rbp,4)
movq %r15, %rdi
callq 0x49cc
incq %rbp
jmp 0x9a70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::getFreq(char)
float 
Msa :: getFreq(char aa){
  int pos = getAaPos(aa);
	if (pos == -1){
	  cerr << "Error, symbol not in alphabet\n";
		exit(0);
	}
	return aa_freq[pos];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9bdc
cmpl $-0x1, %eax
je 0x9bc2
cltq
movq 0x80(%rbx), %rcx
movss (%rcx,%rax,4), %xmm0
popq %rbx
retq
movq 0x941f(%rip), %rdi      # 0x12fe8
leaq 0x3b28(%rip), %rsi      # 0xd6f8
callq 0x4250
xorl %edi, %edi
callq 0x42d0
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::isInclude(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool
Msa :: isInclude(string alph1){
  for (int i(0); i < (int) alphabet.size(); ++i){
		if (alph1.find(alphabet[i]) >= alph1.size() && alphabet[i] != '-' && alphabet[i] != ' '){
		  return false;	
		}
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x8(%r14), %r12
cmpq %r12, %r15
jge 0x9c61
movq (%r14), %rax
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4340
cmpq 0x8(%rbx), %rax
jb 0x9c5c
movq (%r14), %rax
movzbl (%rax,%r15), %eax
cmpl $0x2d, %eax
je 0x9c5c
cmpl $0x20, %eax
jne 0x9c61
incq %r15
jmp 0x9c29
cmpq %r12, %r15
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::getCol[abi:cxx11](int)
string 
Msa :: getCol(int col)
{
  string column;
	for (int i(0); i < nseq; ++i){
		column.push_back(mali_seq[i][col]);
	}
	return column;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movslq %edx, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0xc8(%r14), %rax
cmpq %rax, %r13
jge 0x9cc6
movq 0x38(%r14), %rax
movq (%rax,%r12), %rax
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x4220
incq %r13
addq $0x20, %r12
jmp 0x9c9c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/msa.cpp
// Function: Msa::fitToAlphabet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
Msa :: fitToAlphabet(string alph1){
	int alph_size = (int) alph1.size();
	for (int i(0); i < nseq; i++){
		for (int j(0); j < ncol; j++){
			if (mali_seq[i][j] != '-' && mali_seq[i][j] != ' ' && (int) alph1.find(mali_seq[i][j]) >= alph_size){
				int k = (int) alphabet.find(mali_seq[i][j]);
				if (k < (int) alphabet.size()){
					alphabet.erase(alphabet.begin() + k);
				}
				int pos = (int) aa_type_list[j].find(mali_seq[i][j]);
				if (pos < (int) aa_type_list[j].size()){
					aa_type_list[j].erase(aa_type_list[j].begin() + pos);
					nb_type[j]--;
				}
				mali_seq[i][j] = '-';
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %ebp
xorl %r12d, %r12d
movslq 0xc8(%r14), %rax
cmpq %rax, %r12
jge 0x9dea
movq %r12, (%rsp)
shlq $0x5, %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0xcc(%r14), %rax
cmpq %rax, %r15
jge 0x9dde
movq 0x38(%r14), %rax
movq (%rax,%r12), %rax
movzbl (%rax,%r15), %eax
cmpl $0x20, %eax
je 0x9dd2
cmpl $0x2d, %eax
je 0x9dd2
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4340
cmpl %ebp, %eax
jl 0x9dd2
movq 0x38(%r14), %rax
movq (%rax,%r12), %rax
movsbl (%rax,%r15), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4340
cmpl 0x8(%r14), %eax
jge 0x9d86
movslq %eax, %rsi
addq (%r14), %rsi
movq %r14, %rdi
callq 0x4300
movq 0x50(%r14), %rdi
addq %r13, %rdi
movq 0x38(%r14), %rax
movq (%rax,%r12), %rax
movsbl (%rax,%r15), %esi
xorl %edx, %edx
callq 0x4340
movq 0x50(%r14), %rdi
cmpl 0x8(%rdi,%r13), %eax
jge 0x9dc5
addq %r13, %rdi
movslq %eax, %rsi
addq (%rdi), %rsi
callq 0x4300
movq 0xb0(%r14), %rax
decl (%rax,%r15,4)
movq 0x38(%r14), %rax
movq (%rax,%r12), %rax
movb $0x2d, (%rax,%r15)
incq %r15
addq $0x20, %r13
jmp 0x9d1b
movq (%rsp), %r12
incq %r12
jmp 0x9cfd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop