LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq 0x14c47(%rip), %rdi     # 0x1c518
leaq 0x14c64(%rip), %rsi     # 0x1c53c
xorl %eax, %eax
movl $0xf9, %edx
callq 0x3070
jmp 0x78e6
movq -0x240(%rbp), %rsi
addq $0x38, %rsi
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x35a0
jmp 0x7904
movq -0x240(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x210(%rbp), %rdi
callq 0x97e0
movq %rax, -0x218(%rbp)
movq -0x210(%rbp), %rdi
callq 0x9810
movq %rax, -0x220(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x9840
testb $0x1, %al
jne 0x7954
jmp 0x7a0b
leaq -0x218(%rbp), %rdi
callq 0x9870
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0xa180
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0xa1a0
movq %rax, -0x238(%rbp)
movq -0x230(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x32d0
movq %rax, -0x248(%rbp)
jmp 0x79a9
movq -0x248(%rbp), %rdi
leaq 0x14b8f(%rip), %rsi     # 0x1c546
callq 0x3300
movq %rax, -0x250(%rbp)
jmp 0x79c5
movq -0x250(%rbp), %rdi
movq -0x238(%rbp), %rax
movl (%rax), %esi
callq 0x3530
movq %rax, -0x258(%rbp)
jmp 0x79e3
movq -0x258(%rbp), %rdi
movq 0x245af(%rip), %rsi     # 0x2bfa0
callq 0x3360
jmp 0x79f8
jmp 0x79fa
leaq -0x218(%rbp), %rdi
callq 0x9890
jmp 0x7938
leaq -0x208(%rbp), %rdi
callq 0x3460
jmp 0x7a19
movq -0x240(%rbp), %rax
movl 0x78(%rax), %edi
callq 0x35c0
jmp 0x7a2a
movq -0x240(%rbp), %rdi
addq $0x58, %rdi
callq 0x3140
movq %rax, %rdi
xorl %eax, %eax
movl $0x200, %esi            # imm = 0x200
callq 0x3260
movl %eax, -0x25c(%rbp)
jmp 0x7a51
movq -0x240(%rbp), %rax
movl -0x25c(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl 0x78(%rax), %edi
callq 0x35c0
jmp 0x7a6b
leaq -0x208(%rbp), %rdi
callq 0x34b0
movq -0x240(%rbp), %rdi
addq $0x58, %rdi
callq 0x35f8
movq -0x240(%rbp), %rdi
addq $0x38, %rdi
callq 0x35f8
movq -0x240(%rbp), %rdi
callq 0xa160
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rdi
callq 0x4750
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xc8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3550
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x14706(%rip), %rsi     # 0x1c599
callq 0x4440
jmp 0x7e9a
leaq -0x1a(%rbp), %rdi
callq 0x3380
movq -0xc8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x98c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x98f0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9920
testb $0x1, %al
jne 0x7ede
jmp 0x7fd8
leaq -0x40(%rbp), %rdi
callq 0x9950
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9970
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9990
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xcc(%rbp)
movq -0x58(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x3150
jmp 0x7f23
movl -0xcc(%rbp), %edx
movq -0xb8(%rbp), %rsi
movq -0x60(%rbp), %rax
movl 0x4(%rax), %r8d
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rcx
callq 0x8030
jmp 0x7f4a
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3420
jmp 0x7f5c
leaq -0x80(%rbp), %rdi
callq 0x35f8
leaq -0xa0(%rbp), %rdi
callq 0x35f8
leaq -0x40(%rbp), %rdi
callq 0x99b0
jmp 0x7ec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x3380
jmp 0x801f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x8013
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7fca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x35f8
leaq -0xa0(%rbp), %rdi
callq 0x35f8
jmp 0x8013
movq -0xb0(%rbp), %rdi
leaq 0x14577(%rip), %rsi     # 0x1c55d
callq 0x32f0
jmp 0x7fed
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8003
movq -0xb0(%rbp), %rdi
callq 0x35f8
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x35f8
movq -0x28(%rbp), %rdi
callq 0x3540
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5500
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3550
movq -0x70(%rbp), %rdx
leaq 0x192b(%rip), %rsi      # 0x1c7c3
leaq -0x28(%rbp), %rdi
callq 0x4440
jmp 0x1aea3
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x5b40
jmp 0x1aeb7
leaq -0x28(%rbp), %rdi
callq 0x35f8
leaq -0x29(%rbp), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3550
movq -0x80(%rbp), %rdx
leaq 0x18dc(%rip), %rsi      # 0x1c7c8
leaq -0x60(%rbp), %rdi
callq 0x4440
jmp 0x1aef7
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x2, %edx
callq 0x5b40
jmp 0x1af0e
leaq -0x60(%rbp), %rdi
callq 0x35f8
leaq -0x61(%rbp), %rdi
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x55f0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1af55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35f8
leaq -0x29(%rbp), %rdi
callq 0x3380
jmp 0x1af8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1af83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35f8
leaq -0x61(%rbp), %rdi
callq 0x3380
movq -0x38(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5500
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3550
movq -0x78(%rbp), %rdx
leaq 0x168b(%rip), %rsi      # 0x1c7c3
leaq -0x30(%rbp), %rdi
callq 0x4440
jmp 0x1b143
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x66d0
movl %eax, -0x84(%rbp)
jmp 0x1b158
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3380
movl -0x84(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3550
movq -0x90(%rbp), %rdx
leaq 0x162c(%rip), %rsi      # 0x1c7c8
leaq -0x68(%rbp), %rdi
callq 0x4440
jmp 0x1b1a7
movq -0x98(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0xa, %edx
leaq -0x68(%rbp), %rsi
callq 0x5b40
jmp 0x1b1bf
leaq -0x68(%rbp), %rdi
callq 0x35f8
leaq -0x69(%rbp), %rdi
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x55f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3380
jmp 0x1b23d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35f8
leaq -0x69(%rbp), %rdi
callq 0x3380
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5500
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3550
movq -0x78(%rbp), %rdx
leaq 0x1540(%rip), %rsi      # 0x1c7c8
leaq -0x30(%rbp), %rdi
callq 0x4440
jmp 0x1b293
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x66d0
movl %eax, -0x84(%rbp)
jmp 0x1b2a8
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3380
movl -0x84(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3550
movq -0x90(%rbp), %rdx
leaq 0x14d7(%rip), %rsi      # 0x1c7c3
leaq -0x68(%rbp), %rdi
callq 0x4440
jmp 0x1b2f7
movq -0x98(%rbp), %rdi
movl -0xc(%rbp), %edx
incl %edx
leaq -0x68(%rbp), %rsi
callq 0x5b40
jmp 0x1b30e
leaq -0x68(%rbp), %rdi
callq 0x35f8
leaq -0x69(%rbp), %rdi
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x55f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3380
jmp 0x1b38c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b383
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35f8
leaq -0x69(%rbp), %rdi
callq 0x3380
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x559(%rip), %rsi      # 0x1ae60
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1b520
movq -0x80(%rbp), %rsi
leaq 0x10fbf(%rip), %rdi     # 0x2c390
callq 0x6c50
jmp 0x1b3d8
leaq -0x28(%rbp), %rdi
callq 0x9ce0
leaq -0x2e8(%rip), %rsi      # 0x1b100
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1b520
movq -0x88(%rbp), %rsi
leaq 0x10f8a(%rip), %rdi     # 0x2c390
callq 0x6c50
jmp 0x1b40d
leaq -0x58(%rbp), %rdi
callq 0x9ce0
leaq -0x31d(%rip), %rsi      # 0x1b100
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1b520
movq -0x90(%rbp), %rsi
leaq 0x10f55(%rip), %rdi     # 0x2c390
callq 0x6c50
jmp 0x1b442
leaq -0x78(%rbp), %rdi
callq 0x9ce0
leaq 0x10f3e(%rip), %rdi     # 0x2c390
callq 0x6e30
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9ce0
jmp 0x1b4a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9ce0
jmp 0x1b4a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9ce0
movq -0x30(%rbp), %rdi
callq 0x3540
nop
// File: 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
subq $0x50, %rsp
movq 0xa4b1(%rip), %rdi      # 0xdfd0
leaq 0x553f(%rip), %rsi      # 0x9065
callq 0x10d0
movq 0xa4ae(%rip), %rdi      # 0xdfe0
leaq -0x4(%rbp), %rsi
callq 0x1090
movl -0x4(%rbp), %edx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x5(%rbp), %rsi
callq 0x3bc0
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4210
jmp 0x3b5e
movl -0x4(%rbp), %edx
leaq -0x5(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4090
jmp 0x3b70
leaq -0x38(%rbp), %rdi
callq 0x4300
leaq -0x20(%rbp), %rdi
callq 0x4300
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3bad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4300
leaq -0x20(%rbp), %rdi
callq 0x4300
movq -0x40(%rbp), %rdi
callq 0x1160
nop
// File: 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
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x9f14(%rip), %rdi      # 0xdfd0
leaq 0x4fc3(%rip), %rsi      # 0x9086
callq 0x10d0
movq -0x78(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x5090
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, %rdi
leaq 0x4fa1(%rip), %rsi      # 0x908c
callq 0x10d0
movq %rax, %rdi
movq 0x9ec6(%rip), %rsi      # 0xdfc0
callq 0x10f0
movq -0x78(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4ee0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4d50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8680
testb $0x1, %al
jne 0x4137
jmp 0x41ef
leaq -0x28(%rbp), %rdi
callq 0x86c0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1f10
movq 0x9e7d(%rip), %rdi      # 0xdfd0
leaq 0x4f41(%rip), %rsi      # 0x909b
callq 0x10d0
movq %rax, -0x90(%rbp)
jmp 0x4168
movq -0x90(%rbp), %rdi
movq 0x9e4a(%rip), %rsi      # 0xdfc0
callq 0x10f0
jmp 0x417d
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1f10
jmp 0x418c
movq -0x88(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x70(%rbp), %rsi
callq 0x86e0
jmp 0x41a1
leaq -0x70(%rbp), %rdi
callq 0x2030
leaq -0x48(%rbp), %rdi
callq 0x2030
leaq -0x28(%rbp), %rdi
callq 0x8780
jmp 0x4121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x41e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2030
leaq -0x48(%rbp), %rdi
callq 0x2030
jmp 0x41f8
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1160
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x43d5
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rsi
callq 0x20b0
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x43a8
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8771
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8753
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x20b0
movl (%rax), %esi
movq 0x589c(%rip), %rdi      # 0xdfd0
callq 0x1150
movq %rax, %rdi
leaq 0x941(%rip), %rsi       # 0x9084
callq 0x10d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x870d
movq 0x5876(%rip), %rdi      # 0xdfd0
movq 0x585f(%rip), %rsi      # 0xdfc0
callq 0x10f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x86fe
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm3, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3dc0
testb $0x1, %al
jne 0x4ed7
jmp 0x4ed9
jmp 0x4ef8
leaq 0x1728b(%rip), %rdi     # 0x1c16b
leaq 0x171dc(%rip), %rsi     # 0x1c0c3
movl $0xe3, %edx
leaq 0x172dc(%rip), %rcx     # 0x1c1cf
callq 0x31e0
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
leaq -0x60(%rbp), %rdi
callq 0x4610
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsd -0x30(%rbp), %xmm1
movsd 0x1714e(%rip), %xmm0    # 0x1c088
subsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
leaq -0x78(%rbp), %rdi
callq 0x4610
jmp 0x4f58
movq -0x98(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movsd -0x30(%rbp), %xmm1
movsd 0x17115(%rip), %xmm0    # 0x1c088
subsd %xmm1, %xmm0
leaq -0x60(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x4c60
jmp 0x4f86
movb $0x1, -0x85(%rbp)
testb $0x1, -0x85(%rbp)
jne 0x4fcf
jmp 0x4fc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x4ff1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3b30
jmp 0x4ff1
movq -0x98(%rbp), %rdi
callq 0x3b30
leaq -0x78(%rbp), %rdi
callq 0x3b30
leaq -0x60(%rbp), %rdi
callq 0x3b30
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x3b30
movq -0x80(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x673d
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x6530
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x6690
leaq -0x38(%rbp), %rdi
callq 0x6bb0
movsd %xmm0, -0x8(%rbp)
jmp 0x6796
movsd -0x20(%rbp), %xmm0
movsd 0x1593e(%rip), %xmm1    # 0x1c088
ucomisd %xmm1, %xmm0
jbe 0x6781
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x6530
movq -0x60(%rbp), %rsi
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
callq 0x6690
leaq -0x48(%rbp), %rdi
callq 0x6bb0
movsd %xmm0, -0x8(%rbp)
jmp 0x6796
cvttsd2si -0x28(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ae0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b00
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4ad1
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x12c20
movq -0x30(%rbp), %rdi
cvtsi2ss %eax, %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4b20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a87
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gcollet[P]MstatX/src/jensen.cpp
// Function: JensenStat::calcSeqWeight(Msa&, int)
float
JensenStat :: calcSeqWeight(Msa & msa, int i)
{
	int x;                 /**< used to parse msa columns */
	int seq;               /**< used to parse msa rows */
	int k;                 /**< number of symbol types in a column */
	int n;                 /**< number of occurence of aa[i][x] in the full column x */
	int L = msa.getNcol(); /**< number of columns (length of the alignment) */
	int N = msa.getNseq(); /**< number of rows (number of sequences in the alignment) */
	float w;               /**< weight of sequence i */
	
	w = 0.0;
	for	(x = 0; x < L; ++x){
		k = msa.getNtype(x);
		n = 0;
		for(seq = 0; seq < N; ++seq){
			if (msa.getSymbol(i, x) == msa.getSymbol(seq, x)){
				n++;
			}
		}
		w += (float) 1 / (float) (n * k);
	}
	w /= (float) L;
	return w ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ae0
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b00
movl %eax, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x64f0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7170
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x64c1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x71a0
movsbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x71a0
movb %al, %cl
movl -0x34(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x64b4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x64b6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6473
movl -0x24(%rbp), %eax
imull -0x20(%rbp), %eax
cvtsi2ss %eax, %xmm1
movss 0x14b80(%rip), %xmm0    # 0x1b054
divss %xmm1, %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x644a
cvtsi2ssl -0x28(%rbp), %xmm1
movss -0x30(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x51a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0xa6b0
jmp 0x9d4a
jmp 0x9d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9d93
movq -0x20(%rbp), %rdi
callq 0x4120
movq %rax, -0x30(%rbp)
callq 0x44e0
jmp 0x9da4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4560
jmp 0x9d8b
jmp 0x9d93
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4fd0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x44b0
movq -0x40(%rbp), %rdi
callq 0x4130
movq %rax, %rdi
callq 0x4410
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcce0
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44a0
jmp 0xccc7
jmp 0xcd20
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x41e0
jmp 0xcd3d
movq 0x19301(%rip), %rdi     # 0x25fe8
leaq 0xe788(%rip), %rsi      # 0x1b476
callq 0x4330
movq %rax, -0x58(%rbp)
jmp 0xccf9
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x4320
movq %rax, -0x60(%rbp)
jmp 0xcd0c
movq -0x60(%rbp), %rdi
leaq 0xe77e(%rip), %rsi      # 0x1b495
callq 0x4330
jmp 0xcd1e
jmp 0xcd20
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xcd33
movq -0x50(%rbp), %rdi
callq 0x41e0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe6d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10360
testb $0x1, %al
jne 0xd1e8
jmp 0xd2d8
leaq -0x18(%rbp), %rdi
callq 0xece0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x103a0
testb $0x1, %al
jne 0xd227
leaq -0x18(%rbp), %rdi
callq 0xece0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
callq 0x103a0
testb $0x1, %al
jne 0xd227
jmp 0xd2c4
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq 0xe0b9(%rip), %rsi      # 0x1b2ef
callq 0x10430
testb $0x1, %al
jne 0xd241
jmp 0xd291
movl $0x10, %edi
callq 0x4180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0xddd7(%rip), %rsi      # 0x1b033
callq 0x4110
jmp 0xd263
movq -0x58(%rbp), %rdi
movq 0x18d82(%rip), %rsi     # 0x25ff0
movq 0x18d43(%rip), %rdx     # 0x25fb8
callq 0x45a0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4280
jmp 0xd2de
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x104d0
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x10460
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movb $0x1, 0x6a(%rax)
jmp 0xd2d8
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10510
movq %rax, -0x48(%rbp)
jmp 0xd1c5
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4490
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xcc(%rcx), %eax
jge 0x12218
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc8(%rcx), %eax
jge 0x12208
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x46c0
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x4480
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x4260
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x121f8
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x46c0
movq -0x18(%rbp), %rdi
movsbl (%rax), %esi
callq 0x42f0
jmp 0x121fa
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1217a
jmp 0x1220a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xcc(%rcx), %eax
jge 0x122ea
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc8(%rcx), %eax
jge 0x122cb
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x46c0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x122b5
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x46c0
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x122be
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x122c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1225c
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
leaq -0x10(%rbp), %rsi
callq 0x13740
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1223b
addq $0x20, %rsp
popq %rbp
retq
// File: gcollet[P]MstatX/src/msa.cpp
// Function: Msa::countType()
void
Msa :: countType(){
	string aa_types;
	for(int col(0); col < ncol; ++col){
		aa_types.clear();
		for(int row(0); row < nseq; ++row){
			if (aa_types.find(mali_seq[row][col]) >= aa_types.size()){
			  aa_types.push_back(mali_seq[row][col]);
			}
		}
		aa_type_list.push_back(aa_types);
		nb_type.push_back((int) aa_types.size());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x44b0
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0xcc(%rcx), %eax
jge 0x127a4
leaq -0x28(%rbp), %rdi
callq 0x4490
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0xc8(%rcx), %eax
jge 0x12758
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x30(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x46c0
movq %rax, -0x50(%rbp)
jmp 0x126cd
movq -0x50(%rbp), %rax
leaq -0x28(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x4480
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0x12748
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x30(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x46c0
movq %rax, -0x60(%rbp)
jmp 0x1271d
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x42f0
jmp 0x1272f
jmp 0x12748
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41e0
jmp 0x127b3
jmp 0x1274a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x12697
movq -0x48(%rbp), %rdi
addq $0x50, %rdi
leaq -0x28(%rbp), %rsi
callq 0x13650
jmp 0x1276b
movq -0x48(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4260
movq -0x68(%rbp), %rdi
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x13850
jmp 0x12794
jmp 0x12796
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x12674
leaq -0x28(%rbp), %rdi
callq 0x41e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x12bb0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x12b86
movq 0x13475(%rip), %rdi     # 0x25fe8
leaq 0x8b7e(%rip), %rsi      # 0x1b6f8
callq 0x4330
xorl %edi, %edi
callq 0x4400
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0x10(%rbp), %rsi
callq 0x5180
movss (%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x4260
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x12d02
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x46c0
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x4480
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x4260
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x12cf2
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x46c0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x12cf2
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x46c0
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x12cf2
movb $0x0, -0x1(%rbp)
jmp 0x12d06
jmp 0x12cf4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12c73
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x44b0
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc8(%rcx), %eax
jge 0x12dbe
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x74a0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x46c0
movq %rax, -0x50(%rbp)
jmp 0x12d88
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movsbl (%rax), %esi
callq 0x42f0
jmp 0x12d9a
jmp 0x12d9c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12d56
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41e0
jmp 0x12ddb
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x12dd1
movq -0x48(%rbp), %rdi
callq 0x41e0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::score(char, char)
float
ScoringMatrix :: score(char aa1, char aa2)
{
	int x,y;
  int pos1 = index(aa1);
	int pos2 = index(aa2);
	if (pos1 > pos2){
		x = pos1; y = pos2;
	} else {
	  x = pos2; y = pos1;	
	}
	return matrix[x][y];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x175c0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movsbl -0xa(%rbp), %esi
callq 0x175c0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x17471
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1747d
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::~ScoringMatrix()
ScoringMatrix :: ~ScoringMatrix()
{
	if (is_set){
		for (int i(0); i < (int) alphabet.size(); ++i){
			free(matrix[i]);
		}
		free(matrix);
		for (int i(0); i < (int) alphabet.size(); ++i){
			free(norm_matrix[i]);
		}
		free(norm_matrix);
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xe7ed(%rip), %rcx      # 0x25ca8
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x30(%rax)
je 0x1756e
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x8, %rdi
callq 0x4260
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x17510
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x43f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x174d3
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x43f0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x4260
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x17561
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x43f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x17524
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x43f0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x41e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::index(char)
int 
ScoringMatrix :: index(char aa)
{
	int pos = (int) alphabet.find(aa);
	if (pos >= (int) alphabet.size()){
		cerr << "Symbol " << aa << " is not in alphabet\n";
		exit(0);
	} 
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x9(%rbp), %esi
callq 0x4480
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x8, %rdi
callq 0x4260
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jl 0x17640
movq 0xe9d6(%rip), %rdi      # 0x25fe8
leaq 0x422f(%rip), %rsi      # 0x1b848
callq 0x4330
movq %rax, %rdi
movsbl -0x9(%rbp), %esi
callq 0x43e0
movq %rax, %rdi
leaq 0x421c(%rip), %rsi      # 0x1b850
callq 0x4330
xorl %edi, %edi
callq 0x4400
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::normScore(char, char)
float 
ScoringMatrix :: normScore(char aa1, char aa2)
{
	int x,y;
  int pos1 = index(aa1);
	int pos2 = index(aa2);
	if (pos1 > pos2){
		x = pos1; y = pos2;
	} else {
	  x = pos2; y = pos1;	
	}
	return norm_matrix[x][y];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x175c0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movsbl -0xa(%rbp), %esi
callq 0x175c0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x176a1
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x176ad
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gcollet[P]MstatX/src/trident.cpp
// Function: TridStat::normVect(std::vector<float, std::allocator<float>>)
float
TridStat :: normVect(vector<float> vect){
	float score= 0.0;
	for(int i(0); i < (int) vect.size(); ++i){
		score += vect[i] * vect[i];
	}
	return sqrt(score);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x5160
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x18ef5
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5180
movq -0x20(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x5180
movss -0x28(%rbp), %xmm0
movss (%rax), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18e93
movss -0x14(%rbp), %xmm0
callq 0x19ca0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Pyboon[P]sage/test_mpi_sage.cpp
// Function: ParseFileNum(std::vector<int, std::allocator<int>>)
vector<pair<int, int> > ParseFileNum(vector<int> spots){
    int cycle_start = 1;
    int cycle_end = 197;
    int interval = 4;
    int spots_size = spots.size();
    vector<pair<int, int> > result;
    for(int i_spot = 0; i_spot < spots_size; ++i_spot){
        for(int i_cycle = cycle_start; i_cycle<=cycle_end; i_cycle += interval){
            // 此处将所有spot和cycle拼接在一起，然后均分给多个MPI计算
            result.push_back(make_pair(spots[i_spot], i_cycle));
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0xc5, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
callq 0xafd0
movq -0x50(%rbp), %rdi
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xaff0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xa244
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xa237
movq -0x60(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xb070
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0xb040
movq %rax, -0x68(%rbp)
jmp 0xa1fc
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xb010
jmp 0xa213
jmp 0xa215
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xa1d5
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xb090
jmp 0xa261
jmp 0xa239
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa1c7
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xa257
movq -0x50(%rbp), %rdi
callq 0xb090
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9dc0
nopw (%rax,%rax)