LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/utils.cpp
// Function: words(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> words(const string &str) {
    vector<string> v;
    int start_pos = 0;
    bool in_word = false;

    for (size_t i = 0; i < str.size(); i++) {
        if (str[i] == ' ' || str[i] == '\n' || str[i] == '\t') {
            if (!in_word)
                continue;
            in_word = false;
            v.push_back(str.substr(start_pos, i - start_pos));
            continue;
        }

        if (in_word)
            continue;

        in_word = true;
        start_pos = i;
    }

    if (in_word) {
        v.push_back(str.substr(start_pos, str.size() - start_pos));
    }

    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x3a95
movq %rsi, %r14
xorl %r13d, %r13d
movabsq $0x100000600, %r12      # imm = 0x100000600
leaq 0x8(%rsp), %r15
xorl %eax, %eax
xorl %ebp, %ebp
movq (%r14), %rdx
movzbl (%rdx,%r13), %edx
cmpq $0x20, %rdx
ja 0x3a3c
btq %rdx, %r12
jae 0x3a3c
testb $0x1, %al
je 0x3a4d
movslq %ebp, %rdx
movq %r13, %rcx
subq %rdx, %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x32c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4004
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq 0x8(%r14), %rcx
xorl %eax, %eax
jmp 0x3a4d
testb $0x1, %al
cmovel %r13d, %ebp
movzbl %al, %eax
movl $0x1, %edx
cmovel %edx, %eax
incq %r13
cmpq %rcx, %r13
jb 0x39e1
testb $0x1, %al
je 0x3a95
movslq %ebp, %rdx
subq %rdx, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4004
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ab0
jmp 0x3aab
movq %rax, %r14
jmp 0x3acf
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3acf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3fa6
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/utils.cpp
// Function: cat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void cat(string filename) {
    ifstream ifs(filename);
    string str;
    while (getline(ifs, str))
        cout << str << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x33c0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x8(%rsp), %r14
movq 0xe4aa(%rip), %r15      # 0x11fd0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3440
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq 0x8(%rsp), %rsi
jne 0x3b96
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x32f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31c0
jmp 0x3b26
cmpq %r13, %rsi
je 0x3bae
movq 0x18(%rsp), %rax
incq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x32a0
leaq 0x28(%rsp), %rdi
callq 0x3090
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3be3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/utils.cpp
// Function: crc32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int crc32(string str) {
    unsigned int crcinit = 0;
    unsigned int crc = 0;

    crc = crcinit ^ 0xFFFFFFFF;
    for (size_t i = 0; i < str.size(); i++) {
        crc = ((crc >> 8) & 0x00FFFFFF) ^ crc32tab[(crc ^ (str[i])) & 0xFF];
    }
    return crc ^ 0xFFFFFFFF;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3fa3
movq (%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq 0x812d(%rip), %rdi      # 0xc0b0
movl %eax, %r8d
shrl $0x8, %r8d
xorb (%rdx,%rsi), %al
movzbl %al, %r9d
movl %r8d, %eax
xorl (%rdi,%r9,4), %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3f83
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Transaction::begin()
void Transaction::begin() {
    TXLOG;
    unique_lock<mutex> lock(giant_mtx_);
    lock_ = move(lock);
    wait();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x818e(%rip), %rdi      # 0xc4c0
leaq 0x7d21(%rip), %rdx      # 0xc05a
movl $0x20, %ecx
xorl %eax, %eax
callq 0x3060
leaq 0xdf24(%rip), %rax      # 0x12270
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x846e
movb $0x1, 0x8(%r14)
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x7312
movq %rbx, %rdi
callq 0x438e
movq %r14, %rdi
callq 0x7376
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: DataBase::apply_tx(Transaction*)
void DataBase::apply_tx(Transaction* tx) {
    string buf = serialize(tx->write_set);
    size_t nbytes_written = 0;
    while (nbytes_written < buf.size()) {
        nbytes_written += write(fd_log_,
                buf.c_str() + nbytes_written,
                buf.size() - nbytes_written);
    }
    fsync(fd_log_);

    // apply write_set to table
    for (const auto& [key, value] : tx->write_set) {
        if (value.first == New)
            table[key].value = value.second;
        else
            table.erase(key);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x7fce
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6214
leaq 0x28(%rsp), %rdi
callq 0x7f56
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x453d
xorl %r15d, %r15d
movl 0x78(%r14), %edi
movq 0x8(%rsp), %rsi
addq %r15, %rsi
subq %r15, %rdx
callq 0x30f0
addq %rax, %r15
movq 0x10(%rsp), %rdx
cmpq %rdx, %r15
jb 0x451c
movl 0x78(%r14), %edi
callq 0x3240
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x4591
leaq 0x20(%r15), %rsi
cmpl $0x0, 0x40(%r15)
je 0x4573
movq %r14, %rdi
callq 0x9664
movq %r14, %rdi
movq %rax, %rsi
callq 0x9718
jmp 0x4581
movl 0x44(%r15), %ebp
movq %r14, %rdi
callq 0x7446
movl %ebp, (%rax)
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x4553
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45ca
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7f56
jmp 0x45e8
jmp 0x45ca
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Transaction::finish()
void Transaction::finish() {
    for (const auto& entry : write_set) {
        Key key = entry.first;
        db_->table[key].nlock = 0;
    }
    for (const auto& key : lock_set) {
        db_->table[key].nlock = 0;
    }
    write_set = {};
    is_done = true;
    turn_ = false;
    lock_.unlock();
    scheduler_->notify();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r13
cmpq %r13, %r14
je 0x466d
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x839a
movq 0xd8(%rbx), %rdi
movq %r15, %rsi
callq 0x7446
movl $0x0, 0x4(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x465d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %r13, %rax
jne 0x4618
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
cmpq %r15, %r14
je 0x4696
movq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x7446
movl $0x0, 0x4(%rax)
addq $0x20, %r14
jmp 0x4675
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8e16
movb $0x1, %bpl
movb %bpl, 0x48(%rbx)
movb $0x0, 0x70(%rbx)
leaq 0x90(%rbx), %rdi
callq 0x74c2
movq 0xe0(%rbx), %rdi
movb %bpl, 0x50(%rdi)
addq $0x58, %rdi
callq 0x3140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x46f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Transaction::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Transaction::set(Key key, int val) {
    TXLOG;

    if (db_->table.count(key) > 0) {
        while (!db_->get_lock(this, key, Write)) {
            wait();
        }
    }
    write_log_.push_back(key);
    write_set[key] = make_pair(New, val);
    wait();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x7d78(%rip), %rdi      # 0xc4c0
leaq 0x78b5(%rip), %rdx      # 0xc004
movl $0x35, %ecx
xorl %eax, %eax
callq 0x3060
movq 0xd8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x84aa
addq $0x8, %r15
cmpq %r15, %rax
je 0x47da
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0xd8(%rbx), %r12
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x839a
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x4836
movl %eax, %r12d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x47cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %r12b, %r12b
jne 0x47da
movq %rbx, %rdi
callq 0x438e
jmp 0x4780
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x738c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73ca
movl $0x0, (%rax)
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0x438e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x482d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: DataBase::get_lock(Transaction*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, BaseOp)
bool DataBase::get_lock(Transaction* tx, Key key, BaseOp locktype) {
    if (table.count(key) <= 0) {
        UNREACHABLE;
        return false;
    }

    if (vexists(tx->lock_set, key)) {
        return ((locktype == Write && table[key].nlock == -1) ||
                (locktype == Read && table[key].nlock > 0));
    }

    if (locktype == Write) {
        if (table[key].nlock != 0)
            return false;
        table[key].nlock = -1;
        tx->lock_set.push_back(key);
        return true;
    }

    if (table[key].nlock < 0)
        return false;

    table[key].nlock++;
    tx->lock_set.push_back(key);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x84aa
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x4992
movl %ebp, 0xc(%rsp)
addq $0x30, %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x767a
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0x839a
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %rbp
movq %r13, 0x18(%rsp)
cmpq %rbp, %r12
je 0x48e2
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x9802
movzbl %al, %eax
addq %rax, %r14
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x48ba
testq %r14, %r14
setne %bpl
movq 0x10(%rsp), %r14
jmp 0x48e4
xorl %ebp, %ebp
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x4900
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x20(%rsp), %rdi
callq 0x3fa6
testb %bpl, %bpl
je 0x4930
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x497e
cmpl $0x1, %eax
jne 0x4997
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7446
cmpl $-0x1, 0x4(%rax)
sete %al
jmp 0x4999
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7446
movl 0x4(%rax), %eax
cmpl $0x1, 0xc(%rsp)
jne 0x495d
testl %eax, %eax
jne 0x4997
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7446
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x496f
testl %eax, %eax
js 0x4997
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7446
incl 0x4(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x738c
movb $0x1, %al
jmp 0x4999
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7446
cmpl $0x0, 0x4(%rax)
setg %al
jmp 0x4999
callq 0x34b1
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3fa6
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Transaction::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Transaction::del(Key key) {
    TXLOG;

    if (!has_key(key)) {
        return true;
    }
    while (!db_->get_lock(this, key, Write)) {
        wait();
    }
    write_log_.push_back(key);
    write_set[key] = make_pair(Delete, 0);
    wait();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x77fc(%rip), %rdi      # 0xc4c0
leaq 0x738b(%rip), %rdx      # 0xc056
movl $0x60, %ecx
xorl %eax, %eax
callq 0x3060
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x839a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c56
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4d1b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %bpl, %bpl
je 0x4dae
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0xd8(%rbx), %r12
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x839a
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x4836
movl %eax, %r12d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4d79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %r12b, %r12b
jne 0x4d88
movq %rbx, %rdi
callq 0x438e
jmp 0x4d2e
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x738c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73ca
movq $0x1, (%rax)
movq %rbx, %rdi
callq 0x438e
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x4dd5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4de6
movq (%r13), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Transaction::keys[abi:cxx11]()
vector<string> Transaction::keys() {
    TXLOG;

    vector<string> v;
    for (const auto& entry : db_->table) {
        Key key = entry.first;
        if (write_set.count(key) > 0 && write_set[key].first == Delete)
            continue;
        v.push_back(key);
    }
    for (const auto& [key, val] : write_set) {
        if (db_->table.count(key) <= 0 || val.first == Delete)
            continue;
        v.push_back(key);
    }

    wait();
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rsi), %esi
leaq 0x76b4(%rip), %rdi      # 0xc4c0
leaq 0x726d(%rip), %rdx      # 0xc080
movl $0x6f, %ecx
xorl %eax, %eax
callq 0x3060
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, (%rsp)
movq $0x0, 0x10(%rbx)
movq 0xd8(%r14), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0x4ebe
leaq 0x18(%rsp), %rbp
leaq 0x8(%r14), %rbx
leaq 0x8(%rsp), %r12
movq %rbp, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x839a
movq %r14, %rdi
movq %r12, %rsi
callq 0x8a36
cmpq %rbx, %rax
je 0x4e8b
movq %r14, %rdi
movq %r12, %rsi
callq 0x73ca
cmpl $0x1, (%rax)
je 0x4e97
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x738c
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4eae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r13, %rax
jne 0x4e53
movq 0x18(%r14), %r15
leaq 0x8(%r14), %rbx
cmpq %rbx, %r15
je 0x4f0d
leaq 0x20(%r15), %r12
movq 0xd8(%r14), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x84aa
addq $0x8, %r13
cmpq %r13, %rax
je 0x4efd
cmpl $0x1, 0x40(%r15)
je 0x4efd
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x738c
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x4ecb
movq %r14, %rdi
callq 0x438e
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f2a
movq %rax, %r14
jmp 0x4f49
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq (%rsp), %rdi
callq 0x3fa6
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: ConflictGraph::emit()
void ConflictGraph::emit() {
    FILE* fp_out = fopen(graphfilename_.c_str(), "w");

    vector<int> serial_schedule = serialize();

    fprintf(fp_out, "/*\n");
    fprintf(fp_out, "serial schedule:\n");
    for (const auto& n : serial_schedule) {
        fprintf(fp_out, "%d\n", n);
    }
    fprintf(fp_out, " */\n");

    fprintf(fp_out, "digraph g {\n");
    for (const auto& n : nodes_) {
        fprintf(fp_out, "    Tx%d;\n", n);
    }
    for (const auto& e : edges_) {
        string conflict_type =
            (e.type == ReadWrite) ? "r-w" :
            (e.type == WriteRead) ? "w-r" : "w-w";
        fprintf(fp_out, "    Tx%d -> Tx%d [label = \"%s\"];\n",
                e.from, e.to, conflict_type.c_str());
    }
    fprintf(fp_out, "}\n");
    fclose(fp_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rdi
leaq 0x7449(%rip), %rsi      # 0xc599
callq 0x3320
movq %rax, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6fc4
leaq 0x73f7(%rip), %rdi      # 0xc564
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
leaq 0x73e2(%rip), %rdi      # 0xc568
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq (%r12), %r15
movq 0x8(%r12), %r13
cmpq %r13, %r15
je 0x51c9
leaq 0x736e(%rip), %r12      # 0xc51b
movq %r15, %rbp
movl (%rbp), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3370
addq $0x4, %rbp
cmpq %r13, %rbp
jne 0x51b0
leaq 0x73aa(%rip), %rdi      # 0xc57a
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
leaq 0x7396(%rip), %rdi      # 0xc57f
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x5228
leaq 0x737e(%rip), %r12      # 0xc58c
movl (%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3370
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x520e
movq 0x18(%r14), %r12
movq 0x20(%r14), %r13
cmpq %r13, %r12
je 0x52bf
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %r14
leaq 0x7359(%rip), %r15      # 0xc5a3
movl 0x8(%r12), %eax
leaq 0x7345(%rip), %rsi      # 0xc59b
cmpl $0x1, %eax
je 0x5262
leaq 0x733d(%rip), %rsi      # 0xc59f
testl %eax, %eax
leaq 0x732c(%rip), %rax      # 0xc597
cmoveq %rax, %rsi
movq %rbp, 0x18(%rsp)
leaq 0x3(%rsi), %rdx
movq %r14, %rdi
callq 0x9834
movl (%r12), %edx
movl 0x4(%r12), %ecx
movq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3370
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x52b2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32a0
addq $0xc, %r12
cmpq %r13, %r12
jne 0x524a
movq (%rsp), %r15
leaq 0x7287(%rip), %rdi      # 0xc54d
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq %rbx, %rdi
callq 0x3280
testq %r15, %r15
je 0x52f5
movq 0x10(%rsp), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x32a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x531d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Scheduler::add_tx(std::function<void (Transaction*)>)
void Scheduler::add_tx(Transaction::Logic logic) {
    LOG;
    // create transaction objects and store it
    unique_ptr<Transaction> tx = db_->generate_tx(move(logic));
    transactions.push(move(tx));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x71ce(%rip), %rdi      # 0xc508
leaq 0x71de(%rip), %rsi      # 0xc51f
movl $0xb1, %edx
xorl %eax, %eax
callq 0x3060
movq 0xb0(%rbx), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x538d
movups (%r14), %xmm1
addq $0x10, %r14
movaps %xmm1, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movups %xmm0, (%r14)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5426
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x53b5
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9170
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x53d6
leaq 0x8(%rsp), %rdi
callq 0x90f8
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x541d
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x5415
leaq 0x8(%rsp), %rdi
callq 0x90f8
jmp 0x5415
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5415
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x7586
nop
// File: /workspace/github_cpp_makefile_star2_O3/momohatt[P]seccampDB/database.cpp
// Function: Scheduler::start()
void Scheduler::start() {
    // spawn transaction threads
    unique_lock<mutex> lock(giant_mtx_);
    lock_ = move(lock);
    LOG;
    for (const auto& tx : transactions) {
        thread th(tx->logic, tx.get());
        tx->set_thread(move(th));
    }
    run();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xcd84(%rip), %rax      # 0x12270
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x846e
movb $0x1, 0x8(%r14)
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x7312
leaq 0x6fec(%rip), %rdi      # 0xc508
leaq 0x7003(%rip), %rsi      # 0xc526
movl $0xbb, %edx
xorl %eax, %eax
callq 0x3060
movq 0x10(%rbx), %r13
movq %rbx, (%rsp)
movq 0x30(%rbx), %r12
cmpq %r12, %r13
je 0x55a5
movq (%rsp), %rax
movq 0x20(%rax), %rbx
movq 0x28(%rax), %rbp
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq (%r13), %rsi
movq %rsi, 0x8(%rsp)
addq $0x50, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x75f0
movq (%r13), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x55c7
movq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rax)
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x55a0
movq 0x8(%rbp), %r13
addq $0x8, %rbp
leaq 0x200(%r13), %rbx
cmpq %r12, %r13
jne 0x5556
movq (%rsp), %rdi
callq 0x55e4
leaq 0x18(%rsp), %rdi
callq 0x7376
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30a0
jmp 0x55ce
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7376
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6821(%rip), %rdi      # 0xc508
leaq 0x683e(%rip), %rsi      # 0xc52c
movl $0xf9, %edx
xorl %eax, %eax
callq 0x3060
leaq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x3460
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x5d8f
leaq 0x8(%rsp), %r15
leaq 0x6810(%rip), %r12      # 0xc536
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x32f0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
movl 0x40(%r14), %esi
movq %r13, %rdi
callq 0x3400
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x5d26
leaq 0x8(%rsp), %rdi
callq 0x3360
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
movq 0xc206(%rip), %rax      # 0x11fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x3230
leaq 0x100(%rsp), %rdi
callq 0x30e0
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x5e05
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x5e1d
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x7ede
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e39
movq %rax, %rdi
callq 0x7586
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x634f(%rip), %rsi      # 0xc589
leaq 0x634a(%rip), %rdx      # 0xc58b
callq 0x9834
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x62e9
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r12
movl 0x40(%r15), %ebp
movq %r13, 0x28(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x839a
movl 0x44(%r15), %r8d
leaq 0x8(%rsp), %rdi
movl %ebp, %edx
movq %r12, %rcx
callq 0x636c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x62be
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x62d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r14, %rax
jne 0x6261
leaq 0x625d(%rip), %rsi      # 0xc54d
movq %rbx, %rdi
callq 0x3450
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x630c
movq %rax, %r14
jmp 0x634c
movq %rax, %r14
jmp 0x6335
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6335
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x634c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x6364
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ccf(%rip), %rsi      # 0xc7a0
leaq 0x1ccc(%rip), %rdx      # 0xc7a4
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x9834
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4728
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xab0c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c89(%rip), %rsi      # 0xc7a5
leaq 0x1c86(%rip), %rdx      # 0xc7a9
movq %rsp, %r14
movq %r14, %rdi
callq 0x9834
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x4728
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xab54
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xab77
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xab87
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ad7(%rip), %rsi      # 0xc7a0
leaq 0x1ad4(%rip), %rdx      # 0xc7a4
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x9834
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f5a
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xad01
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a94(%rip), %rsi      # 0xc7a5
leaq 0x1a91(%rip), %rdx      # 0xc7a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9834
addl $0xa, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4728
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xad4c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xad71
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xad81
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19fa(%rip), %rsi      # 0xc7a5
leaq 0x19f7(%rip), %rdx      # 0xc7a9
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x9834
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f5a
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xade3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19ad(%rip), %rsi      # 0xc7a0
leaq 0x19aa(%rip), %rdx      # 0xc7a4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9834
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4728
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xae2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xae52
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xae62
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x60, %rsp
leaq 0x40(%rsp), %rsi
movq $0x0, 0x8(%rsi)
leaq -0x3d7(%rip), %rax      # 0xaab0
movq %rax, (%rsi)
leaq 0x293(%rip), %rbx       # 0xb124
movq %rbx, 0x18(%rsi)
leaq 0x290(%rip), %r14       # 0xb12c
movq %r14, 0x10(%rsi)
leaq 0x7439(%rip), %rdi      # 0x122e0
callq 0x5326
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xaec5
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rsp), %rsi
movq $0x0, 0x8(%rsi)
leaq -0x232(%rip), %r15      # 0xaca7
movq %r15, (%rsi)
movq %rbx, 0x18(%rsi)
movq %r14, 0x10(%rsi)
leaq 0x73f5(%rip), %rdi      # 0x122e0
callq 0x5326
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xaf09
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
movq %r15, (%rsi)
movq %rbx, 0x18(%rsi)
movq %r14, 0x10(%rsi)
leaq 0x73ba(%rip), %rdi      # 0x122e0
callq 0x5326
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaf42
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x7397(%rip), %rdi      # 0x122e0
callq 0x54d4
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xafc2
jmp 0xafc2
jmp 0xafc2
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xafba
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xafba
jmp 0xafc2
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xafba
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xafba
jmp 0xafc2
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xafba
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x7586
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f30(%rip), %rdi      # 0x6fd0
leaq 0x1fd9(%rip), %rsi      # 0x4080
movl $0x20, %edx
callq 0x1120
movq 0x4f28(%rip), %rdi      # 0x6fe0
leaq -0x10(%rbp), %rbx
movq %rbx, %rsi
callq 0x10a0
movl (%rbx), %edx
leaq -0x40(%rbp), %rbx
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x2130
leaq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x2682
movl -0x10(%rbp), %edx
leaq -0x9(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2510
leaq -0x28(%rbp), %rdi
callq 0x271e
leaq -0x40(%rbp), %rdi
callq 0x271e
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x271e
jmp 0x211e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x271e
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
movq 0x4a9e(%rip), %r15      # 0x6fd0
leaq 0x1b68(%rip), %rsi      # 0x40a1
movl $0x5, %edx
movq %r15, %rdi
callq 0x1120
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
movq %r15, %rdi
callq 0x10b0
movq %rax, %r12
leaq 0x1b36(%rip), %rsi      # 0x40a7
movl $0xe, %edx
movq %rax, %rdi
callq 0x1120
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %r12, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10c0
movq (%rbx), %r12
movq 0x8(%rbx), %r14
cmpq %r14, %r12
je 0x2647
leaq -0x68(%rbp), %r13
leaq -0x50(%rbp), %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1cc6
movl $0xa, %edx
movq %r15, %rdi
leaq 0x1ade(%rip), %rsi      # 0x40b6
callq 0x1120
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1cc6
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x3720
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x262c
callq 0x10f0
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x263a
callq 0x10f0
addq $0x18, %r12
cmpq %r14, %r12
jne 0x25be
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x266c
callq 0x10f0
jmp 0x266c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x267a
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0x37df
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edx, %r13d
leaq (,%r13,4), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movq 0x387b(%rip), %r14      # 0x6fd0
leaq 0x943(%rip), %r15       # 0x409f
xorl %eax, %eax
movq %r13, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq %r12, -0x48(%rbp)
movq (%rbx), %rax
movl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x1180
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1120
addq $0x4, %r12
decq %r13
jne 0x376a
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %r14, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10c0
movq -0x40(%rbp), %rax
incq %rax
movq -0x48(%rbp), %r12
addq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
cmpq %r13, %rax
jne 0x3762
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, 0x38(%rsp)
movq %rdx, %rsi
callq 0x2a20
testb %al, %al
je 0x3408
movq 0x18d35(%rip), %r12     # 0x1bfd0
leaq 0x12f5a(%rip), %rsi     # 0x161fc
movl $0x12, %edx
movq %r12, %rdi
callq 0x2220
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movl (%r14), %esi
movl 0x4(%r14), %ebp
movq %r14, 0x30(%rsp)
movl 0x8(%r14), %r13d
movq %rbx, 0x20(%rsp)
movq %rbx, %rdi
movl %esi, 0xc(%rsp)
movl %ebp, %edx
movl %r13d, %ecx
callq 0x2594
movl %ebp, 0x1c(%rsp)
testl %ebp, %ebp
movsd 0x28(%rsp), %xmm2
jle 0x33f4
movsd 0x12da1(%rip), %xmm3    # 0x160b8
subsd %xmm2, %xmm3
movq $0x0, 0x10(%rsp)
movsd %xmm3, 0x40(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x33de
xorl %ebp, %ebp
testl %r13d, %r13d
jle 0x33d2
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
movq 0x10(%rsp), %rdx
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%rcx), %eax
movslq %eax, %rbx
addq 0x10(%rcx), %rbx
movq 0x38(%rsp), %rcx
movl (%rcx), %eax
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%rcx), %eax
movslq %eax, %r14
addq 0x10(%rcx), %r14
movq 0x30(%rsp), %rcx
movl (%rcx), %eax
imull %edx, %eax
addl %ebp, %eax
imull 0x8(%rcx), %eax
movslq %eax, %r15
addq 0x10(%rcx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movzbl (%r14,%r12), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2340
movsd 0x40(%rsp), %xmm3
movsd 0x28(%rsp), %xmm2
cvttsd2si %xmm0, %eax
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r13
jne 0x338d
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x3337
movq 0x10(%rsp), %rax
incl %eax
movq %rax, 0x10(%rsp)
cmpl 0x1c(%rsp), %eax
jne 0x332a
movq 0x20(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12d9c(%rip), %rdi     # 0x161ab
leaq 0x12ced(%rip), %rsi     # 0x16103
leaq 0x12da7(%rip), %rcx     # 0x161c4
movl $0xb9, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a20
testb %al, %al
je 0x350a
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 0x2d6f
movsd 0x12c19(%rip), %xmm0    # 0x160b8
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 0x2d6f
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x3262
leaq 0x20(%rsp), %rdi
callq 0x2826
leaq 0x38(%rsp), %rdi
callq 0x2826
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12c9a(%rip), %rdi     # 0x161ab
leaq 0x12beb(%rip), %rsi     # 0x16103
leaq 0x12cf0(%rip), %rcx     # 0x1620f
movl $0xe3, %edx
callq 0x2110
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2826
jmp 0x353b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2826
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x4f1c
movq 0xa8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x4290
leaq 0x78(%rsp), %rdi
callq 0x4070
testb %al, %al
je 0x4e54
callq 0x4f1c
cmpb $0x0, 0xed(%rax)
je 0x4d6a
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
subq %rcx, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x4dd9
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorps %xmm0, %xmm0
xorl %esi, %esi
addss (%rcx,%rsi,4), %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x4d5b
jmp 0x4ddc
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0xb2ba(%rip), %r15      # 0x10032
leaq 0xb7a5(%rip), %r12      # 0x10524
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x2, %rax
cltq
cmpq %rax, %rbp
jge 0x4e06
leal 0x1(%rbp), %esi
movq %r14, %rdi
callq 0x4420
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x42a0
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbp,4), %xmm0
movq %r13, %rdi
callq 0x43c0
incq %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x42a0
jmp 0x4d7f
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
callq 0x43c0
leaq 0xb72b(%rip), %rsi      # 0x10524
movl $0x1, %edx
movq %rax, %rdi
callq 0x42a0
leaq 0x8(%rsp), %rdi
callq 0x4340
movq 0x11191(%rip), %rax     # 0x15fa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x41f0
leaq 0x100(%rsp), %rdi
callq 0x40c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1118d(%rip), %rdi     # 0x15fe8
leaq 0xb1be(%rip), %rsi      # 0x10020
movl $0x11, %edx
callq 0x42a0
callq 0x4f1c
movq 0xa8(%rax), %rsi
movq 0xb0(%rax), %rdx
movq 0x11162(%rip), %rdi     # 0x15fe8
callq 0x42a0
leaq 0xb692(%rip), %rsi      # 0x10524
movq %rax, %rdi
callq 0x4230
xorl %edi, %edi
callq 0x42e0
jmp 0x4ea5
jmp 0x4ea5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4370
movq %rbx, %rdi
callq 0x4440
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f1c
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6e6e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x66c6
movq %rbx, %rdi
callq 0x40f0
callq 0x4360
movq %rax, %rbx
callq 0x43f0
movq %rbx, %rdi
callq 0x4440
movq %rax, %rdi
callq 0x4f11