LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Konano[P]UselessDatabase/FileManager.cpp
// Function: FileManager::alloc()
inline int FileManager::alloc() { // 0 means no flag, so find lowest 0 bit
    int wh = 0;
    __uint128_t flag_tmp = flag;
    for (int i = MAX_FILE_NUM_INDEX - 1; i >= 0; i--) {
        if ((PREFIX_128(1 << i) & flag_tmp) == PREFIX_128(1 << i)) {
            wh += 1 << i;
            flag_tmp >>= 1 << i;
        }
    }
    if (flag_tmp & 1) return -1; // all bits are 1
    return wh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0x0, -0x14(%rbp)
movq 0x200(%rcx), %rax
movq 0x208(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movl $0x6, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x3599b
movb -0x34(%rbp), %cl
movl $0x1, %eax
shll %cl, %eax
movb %al, %sil
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %eax
movb %sil, %cl
movq %rdx, %rdi
shldq %cl, %rax, %rdi
movq %rdi, -0x40(%rbp)
movb %sil, %cl
shlq %cl, %rax
movq -0x40(%rbp), %rcx
testb $0x40, %sil
cmovneq %rax, %rcx
cmovneq %rdx, %rax
addq $-0x1, %rax
adcq $-0x1, %rcx
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rsi
notq %rsi
andq %rsi, %rcx
notq %rdx
andq %rdx, %rax
orq %rcx, %rax
jne 0x3598b
jmp 0x35937
movb -0x34(%rbp), %cl
movl $0x1, %eax
movl %eax, %edx
shll %cl, %edx
movl -0x14(%rbp), %ecx
addl %edx, %ecx
movl %ecx, -0x14(%rbp)
movb -0x34(%rbp), %cl
shll %cl, %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movb %cl, %sil
movb %sil, %cl
movq %rdx, %rdi
shrq %cl, %rdi
movq %rdi, -0x48(%rbp)
movb %sil, %cl
shrdq %cl, %rdx, %rax
movq -0x48(%rbp), %rcx
xorl %edx, %edx
testb $0x40, %sil
cmovneq %rcx, %rax
cmovneq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
jmp 0x3598d
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x358d0
movb -0x30(%rbp), %al
testb $0x1, %al
je 0x359ad
jmp 0x359a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x359b3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/FileManager.cpp
// Function: FileManager::setFlag(int, bool)
inline void FileManager::setFlag(int wh, bool val) {
    if (val) {
        flag |= (__uint128_t)1 << wh; 
    } else {
        flag -= (__uint128_t)1 << wh;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x35a32
movq -0x18(%rbp), %rax
movb -0xc(%rbp), %dl
xorl %ecx, %ecx
movl %ecx, %edi
movq %rdi, -0x20(%rbp)
movl $0x1, %esi
movb %dl, %cl
shldq %cl, %rsi, %rdi
movb %dl, %cl
shlq %cl, %rsi
movq -0x20(%rbp), %rcx
testb $0x40, %dl
cmovneq %rsi, %rdi
cmovneq %rcx, %rsi
movq 0x200(%rax), %rdx
movq 0x208(%rax), %rcx
orq %rdi, %rcx
orq %rsi, %rdx
movq %rdx, 0x200(%rax)
movq %rcx, 0x208(%rax)
jmp 0x35a82
movq -0x18(%rbp), %rax
movb -0xc(%rbp), %dl
xorl %ecx, %ecx
movl %ecx, %esi
movq %rsi, -0x28(%rbp)
movl $0x1, %edi
movb %dl, %cl
shldq %cl, %rdi, %rsi
movb %dl, %cl
shlq %cl, %rdi
movq -0x28(%rbp), %rcx
testb $0x40, %dl
cmovneq %rdi, %rsi
cmovneq %rcx, %rdi
movq 0x200(%rax), %rdx
movq 0x208(%rax), %rcx
subq %rdi, %rdx
sbbq %rsi, %rcx
movq %rdx, 0x200(%rax)
movq %rcx, 0x208(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]UselessDatabase/Hash.cpp
// Function: Hash::find(int, int)
int Hash::find(int fileID, int pageID) {
    int id = hash(fileID, pageID);
    while (flag[id] && bpm->check(fileID, pageID, table[id]) == false) {
        id++;
    }
    if (flag[id] == false) return -1;
    return table[id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x35c80
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
xorl %eax, %eax
testb $0x1, 0x80000(%rcx,%rdx)
movb %al, -0x29(%rbp)
je 0x35afb
movq -0x28(%rbp), %rax
movq 0xc0000(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
callq 0x7340
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x35b04
jmp 0x35b0f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35ab8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb 0x80000(%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x35b31
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35b40
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Hash.cpp
// Function: Hash::add(int, int, int)
void Hash::add(int fileID, int pageID, int index) {
    int id = hash(fileID, pageID);
    while (flag[id]) id++;
    flag[id] = true;
    table[id] = (uint16_t)index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x35c80
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
testb $0x1, 0x80000(%rax,%rcx)
je 0x35b98
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x35b7b
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x1, 0x80000(%rax,%rcx)
movl -0x14(%rbp), %ecx
movw %cx, %dx
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Hash.cpp
// Function: Hash::del(int, int)
void Hash::del(int fileID, int pageID) {
    int id = hash(fileID, pageID);
    while (flag[id] && bpm->check(fileID, pageID, table[id]) == false) {
        id++;
    }
    if (flag[id]) flag[id] = false, table[id] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x35c80
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
testb $0x1, 0x80000(%rcx,%rdx)
movb %al, -0x21(%rbp)
je 0x35c2b
movq -0x20(%rbp), %rax
movq 0xc0000(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
callq 0x7340
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x35c34
jmp 0x35c3f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35be8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, 0x80000(%rax,%rcx)
je 0x35c6b
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, 0x80000(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movw $0x0, (%rax,%rcx,2)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/Index.cpp
// Function: Index::Btree_remove(BtreeNode*)
void Index::Btree_remove(BtreeNode* node) {
    if (node == nullptr) return;
    Btree_remove(node->left_page);
    Btree_remove(node->right_page);
    if (node->record_cnt) {
        for (int i = 0; i <= node->record_cnt; i++) {
            Btree_remove(node->child_ptr[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36c01
jmp 0x36c6a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x36be0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x36be0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x36c6a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x36c68
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3d440
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x36be0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x36c34
jmp 0x36c6a
addq $0x20, %rsp
popq %rbp
retq
// File: Konano[P]UselessDatabase/./Type.h
// Function: Type::size()
uint size() {
        switch (ty) {
        case INT: return 4;
        case CHAR: return char_len;
        case VARCHAR: return 8;
        case DATE: return 4;
        case DECIMAL: return 16;
        default: return -1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x24(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x3d432
movq -0x18(%rbp), %rax
leaq 0x463d0(%rip), %rcx     # 0x837c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, -0x4(%rbp)
jmp 0x3d439
movq -0x20(%rbp), %rax
movzbl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d439
movl $0x8, -0x4(%rbp)
jmp 0x3d439
movl $0x4, -0x4(%rbp)
jmp 0x3d439
movl $0x10, -0x4(%rbp)
jmp 0x3d439
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/./BtreeNode.h
// Function: BtreeNode::BtreeNode()
BtreeNode() {
        this->is_leaf = true;
        this->fa_index = -1;
        this->record_cnt = 0;
        this->record.clear();
        this->child.clear();
        this->child.push_back(-1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
callq 0xd880
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3df40
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3df60
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movb $0x1, 0x68(%rax)
movl $0xffffffff, 0x6c(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x1c(%rax)
callq 0x3d6a0
movq -0x28(%rbp), %rdi
callq 0x3d660
movq -0x28(%rbp), %rdi
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq -0xc(%rbp), %rsi
callq 0x3d6c0
jmp 0x3d621
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3df80
movq -0x40(%rbp), %rdi
callq 0x3dfe0
movq -0x28(%rbp), %rdi
callq 0xde10
movq -0x18(%rbp), %rdi
callq 0x6890
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/Key.cpp
// Function: ForeignKey::toJson[abi:cxx11]()
json ForeignKey::toJson() {
    json j;
    j["data"] = Key::toJson();
    j["sid"] = p->table->table_id;
    return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xadd0
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43920
jmp 0x43662
movq -0x60(%rbp), %rdi
leaq 0x4028b(%rip), %rsi     # 0x838f8
callq 0xae60
movq %rax, -0x68(%rbp)
jmp 0x43678
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0xb0a0
movq -0x78(%rbp), %rdi
callq 0xb110
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x48(%rax), %rsi
addq $0x50, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb150
movq -0x60(%rbp), %rdi
leaq 0x3b37d(%rip), %rsi     # 0x7ea33
callq 0xae60
movq %rax, -0x70(%rbp)
jmp 0x436c1
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb0a0
leaq -0x48(%rbp), %rdi
callq 0xb110
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x43728
jmp 0x4371f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x43735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb110
jmp 0x43735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb110
jmp 0x43735
movq -0x60(%rbp), %rdi
callq 0xb110
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xb110
movq -0x30(%rbp), %rdi
callq 0x6890
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/./Key.h
// Function: Key::toJson[abi:cxx11]()
json toJson() {
        json j;
        j["name"] = name.c_str();
        for (uint i = 0; i < v_size; i++) j["cols"].push_back(v[i]);
        return j;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xadd0
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
callq 0x6210
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x43b60
jmp 0x43973
movq -0x68(%rbp), %rdi
leaq 0x40298(%rip), %rsi     # 0x83c16
callq 0xae60
movq %rax, -0x70(%rbp)
jmp 0x43989
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb0a0
leaq -0x28(%rbp), %rdi
callq 0xb110
movl $0x0, -0x40(%rbp)
movq -0x58(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x43a4d
movq -0x68(%rbp), %rdi
leaq 0x3ff3c(%rip), %rsi     # 0x838fd
callq 0xae60
movq %rax, -0x78(%rbp)
jmp 0x439cc
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x3cf40
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb150
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xb1f0
jmp 0x439fd
leaq -0x50(%rbp), %rdi
callq 0xb110
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x439a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x43a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb110
jmp 0x43a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xb110
jmp 0x43a6d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x43a60
movq -0x68(%rbp), %rdi
callq 0xb110
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xb110
movq -0x38(%rbp), %rdi
callq 0x6890
nop
// File: Konano[P]UselessDatabase/MemPool.cpp
// Function: MemPool::access(int)
void MemPool::access(int index) {

    if (index == head) {
        return;
    } else if (index == tail) {
        tail = pool[index].pre;
    } else {
        link(pool[index].pre, pool[index].next);
    }
    link(index, head);
    head = index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x80004(%rcx), %eax
jne 0x44b24
jmp 0x44b7f
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x80008(%rcx), %eax
jne 0x44b46
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
movl %ecx, 0x80008(%rax)
jmp 0x44b5e
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movl (%rdi,%rax,8), %esi
movslq -0xc(%rbp), %rax
movl 0x4(%rdi,%rax,8), %edx
callq 0x44c50
jmp 0x44b60
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x80004(%rdi), %edx
callq 0x44c50
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x80004(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/MemPool.cpp
// Function: MemPool::alloc()
int MemPool::alloc() {
    if (num == 0) {
        head = tail = num;
        return num++;
    } 
    if (num < MAX_BUF_NUM) {
        link(num, head);
        head = num;
        return num++;
    }
    access(tail);
    return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x80000(%rax)
jne 0x44bd9
movq -0x18(%rbp), %rcx
movl 0x80000(%rcx), %eax
movl %eax, 0x80008(%rcx)
movl %eax, 0x80004(%rcx)
movl 0x80000(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x80000(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x44c40
movq -0x18(%rbp), %rax
cmpl $0x10000, 0x80000(%rax) # imm = 0x10000
jge 0x44c24
movq -0x18(%rbp), %rdi
movl 0x80000(%rdi), %esi
movl 0x80004(%rdi), %edx
callq 0x44c50
movq -0x18(%rbp), %rcx
movl 0x80000(%rcx), %eax
movl %eax, 0x80004(%rcx)
movl 0x80000(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x80000(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x44c40
movq -0x18(%rbp), %rdi
movl 0x80008(%rdi), %esi
callq 0x44b00
movq -0x18(%rbp), %rax
movl 0x80004(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Print.cpp
// Function: lenLimit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
string lenLimit(string str, uint len) {
    if (str.length() > len) 
        return str.substr(0, len-2) + ".."; 
    else 
        return str + string(len - str.length(), ' ');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq %rax, %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x6740
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x44d23
movq -0x88(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x64d0
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq 0x39dd9(%rip), %rdx     # 0x7eacd
callq 0x15070
jmp 0x44cfb
leaq -0x38(%rbp), %rdi
callq 0x6340
jmp 0x44dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6340
jmp 0x44de0
movq -0x88(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0xa8(%rbp)
callq 0x6740
movq %rax, %rcx
movq -0xa8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xa0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x68a0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rcx
leaq -0x68(%rbp), %rdi
movl $0x20, %edx
callq 0x13770
jmp 0x44d7b
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x45e90
jmp 0x44d91
leaq -0x68(%rbp), %rdi
callq 0x6340
leaq -0x69(%rbp), %rdi
callq 0x6530
jmp 0x44dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x44dc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6340
leaq -0x69(%rbp), %rdi
callq 0x6530
jmp 0x44de0
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6890
nopl (%rax)
// File: Konano[P]UselessDatabase/Print.cpp
// Function: Type2Str[abi:cxx11](enumType)
string Type2Str(enumType ty) {
    switch (ty) {
    case INT: return "INT";
    case CHAR: return "CHAR";
    case VARCHAR: return "VARCHAR";
    case DATE: return "DATE";
    case DECIMAL: return "DECIMAL";
    default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x44fa0
movq -0x30(%rbp), %rax
leaq 0x3ec6e(%rip), %rcx     # 0x83a94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3ec71(%rip), %rsi     # 0x83abc
callq 0xc020
jmp 0x44e52
leaq -0xd(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x6530
jmp 0x44fef
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3ec2d(%rip), %rsi     # 0x83ac3
callq 0xc020
jmp 0x44e9d
leaq -0x1d(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x6530
jmp 0x44fef
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x3ebdf(%rip), %rsi     # 0x83ac0
callq 0xc020
jmp 0x44ee8
leaq -0x1e(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x6530
jmp 0x44fef
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x3f49c(%rip), %rsi     # 0x843c8
callq 0xc020
jmp 0x44f33
leaq -0x1f(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x6530
jmp 0x44fef
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x3eb51(%rip), %rsi     # 0x83ac8
callq 0xc020
jmp 0x44f7e
leaq -0x20(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6530
jmp 0x44fef
leaq -0x21(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x4166e(%rip), %rsi     # 0x8662a
callq 0xc020
jmp 0x44fc3
leaq -0x21(%rbp), %rdi
callq 0x6530
jmp 0x44fe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6530
jmp 0x44fef
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6890
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/Print.cpp
// Function: Aggr2Str[abi:cxx11](enumAggr)
string Aggr2Str(enumAggr ty) {
    switch (ty) {
    case AG_COUNT: return "COUNT()";
    case AG_MIN: return "MIN()";
    case AG_MAX: return "MAX()";
    case AG_SUM: return "SUM()";
    case AG_AVG: return "AVG()";
    default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x451b0
movq -0x30(%rbp), %rax
leaq 0x3ea72(%rip), %rcx     # 0x83aa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3ea75(%rip), %rsi     # 0x83ad0
callq 0xc020
jmp 0x45062
leaq -0xd(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x6530
jmp 0x451ff
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3ea32(%rip), %rsi     # 0x83ad8
callq 0xc020
jmp 0x450ad
leaq -0x1d(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x6530
jmp 0x451ff
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x3e9ed(%rip), %rsi     # 0x83ade
callq 0xc020
jmp 0x450f8
leaq -0x1e(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x6530
jmp 0x451ff
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x3e9a8(%rip), %rsi     # 0x83ae4
callq 0xc020
jmp 0x45143
leaq -0x1f(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x6530
jmp 0x451ff
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x3e963(%rip), %rsi     # 0x83aea
callq 0xc020
jmp 0x4518e
leaq -0x20(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6530
jmp 0x451ff
leaq -0x21(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x68a0
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x4145e(%rip), %rsi     # 0x8662a
callq 0xc020
jmp 0x451d3
leaq -0x21(%rbp), %rdi
callq 0x6530
jmp 0x451f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6530
jmp 0x451ff
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6890
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/Print.cpp
// Function: Print::end()
void Print::end() {
    string str = "+";
    for (int i = 0; i < col_num; i++) str += string(2 + t[i].second, '-') + '+';
    cout << str << endl;
    t.clear();
    col_num = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x21(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x68a0
movq -0x88(%rbp), %rdx
leaq 0x3da8f(%rip), %rsi     # 0x83788
leaq -0x20(%rbp), %rdi
callq 0xc020
jmp 0x45d04
leaq -0x21(%rbp), %rdi
callq 0x6530
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x6b84b(%rip), %eax     # 0xb1568
jge 0x45e1b
movslq -0x38(%rbp), %rsi
leaq 0x6b822(%rip), %rdi     # 0xb1550
callq 0x462b0
movl 0x20(%rax), %eax
addl $0x2, %eax
cltq
movq %rax, -0x98(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x68a0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rcx
leaq -0x78(%rbp), %rdi
movl $0x2d, %edx
callq 0x13770
jmp 0x45d70
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x2b, %edx
callq 0x46260
jmp 0x45d84
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6630
jmp 0x45d93
leaq -0x58(%rbp), %rdi
callq 0x6340
leaq -0x78(%rbp), %rdi
callq 0x6340
leaq -0x79(%rbp), %rdi
callq 0x6530
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x45d14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6530
jmp 0x45e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x45e10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x45e07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6340
leaq -0x78(%rbp), %rdi
callq 0x6340
leaq -0x79(%rbp), %rdi
callq 0x6530
jmp 0x45e7d
movq 0x6b196(%rip), %rdi     # 0xb0fb8
leaq -0x20(%rbp), %rsi
callq 0x6440
movq %rax, -0xa0(%rbp)
jmp 0x45e34
movq -0xa0(%rbp), %rdi
movq 0x6b146(%rip), %rsi     # 0xb0f88
callq 0x64f0
jmp 0x45e49
leaq 0x6b700(%rip), %rdi     # 0xb1550
callq 0x46320
movl $0x0, 0x6b709(%rip)     # 0xb1568
leaq -0x20(%rbp), %rdi
callq 0x6340
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6340
movq -0x30(%rbp), %rdi
callq 0x6890
nop
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::Pointer::next()
bool Table::Pointer::next() {
    pid++;
    if (!s->sel) {
        if (pid % s->record_onepg == 0) {
            buf = s->bpm->getPage(s->main_file, pid / s->record_onepg);
        }
        while ((uint)pid < s->record_num && !exist(buf, pid % s->record_onepg)) {
            pid++;
            if (pid % s->record_onepg == 0) {
                buf = s->bpm->getPage(s->main_file, pid / s->record_onepg);
            }
        }
    }
    return pid < s->record_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq (%rax), %rax
cmpl $0x0, 0x9fb0(%rax)
jne 0x4712b
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x9fac(%rcx)
cmpl $0x0, %edx
jne 0x47058
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq 0x48(%rax), %rdi
movq (%rcx), %rax
movl 0x9fa4(%rax), %esi
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x9fac(%rcx)
movl %eax, %edx
callq 0x70b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4705a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq (%rax), %rdx
xorl %eax, %eax
cmpl 0x9fa0(%rdx), %ecx
movb %al, -0x11(%rbp)
jae 0x470c7
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rcx), %eax
movq (%rcx), %rsi
xorl %edx, %edx
divl 0x9fac(%rsi)
movq -0x20(%rbp), %rax
shrl $0x3, %edx
movl %edx, %edx
movzbl (%rax,%rdx), %eax
movl %eax, -0x18(%rbp)
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x9fac(%rcx)
movl -0x18(%rbp), %eax
movl %edx, %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x470d0
jmp 0x47129
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x9fac(%rcx)
cmpl $0x0, %edx
jne 0x47124
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq 0x48(%rax), %rdi
movq (%rcx), %rax
movl 0x9fa4(%rax), %esi
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x9fac(%rcx)
movl %eax, %edx
callq 0x70b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4705a
jmp 0x4712b
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
cmpl 0x9fa0(%rcx), %eax
setb %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::Pointer::get()
Anys Table::Pointer::get() {
    if (s->sel) return s->data[pid];
    BufType _buf = buf + (s->record_onepg - 1) / 8 + 1 + s->record_size * (pid % s->record_onepg);
    Anys as; Any a;
    for (uint i = 0; i < s->col_num; i++) {
        s->fetch(_buf, s->col_ty[i].ty, s->col_ty[i].size(), a);
        as.push_back(a);
    }
    return as;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
cmpl $0x0, 0x9fb0(%rax)
je 0x47218
movq -0x48(%rbp), %rax
movq (%rax), %rdi
addq $0x9fb8, %rdi           # imm = 0x9FB8
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x52170
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc400
jmp 0x47363
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq (%rax), %rdx
movl 0x9fa8(%rdx), %esi
movl %esi, -0x5c(%rbp)
movl 0x9fac(%rdx), %esi
movl %esi, %edx
decl %edx
shrl $0x3, %edx
addq %rdx, %rcx
movl 0x8(%rax), %eax
xorl %edx, %edx
divl %esi
movl -0x5c(%rbp), %eax
imull %edx, %eax
leaq 0x1(%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xc310
leaq -0x28(%rbp), %rdi
callq 0xd240
jmp 0x4726a
movl $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rcx
movl -0x38(%rbp), %eax
movq (%rcx), %rcx
cmpl 0x54(%rcx), %eax
jae 0x4732d
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x38(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x58(%rax,%rcx), %rdi
movl 0x7c(%rax,%rcx), %eax
movl %eax, -0x64(%rbp)
callq 0x3d3d0
movl %eax, -0x60(%rbp)
jmp 0x472ac
movl -0x60(%rbp), %ecx
movl -0x64(%rbp), %edx
movq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %r8
callq 0x47380
jmp 0x472c5
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xca00
jmp 0x472d4
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc330
jmp 0x472e3
leaq -0x40(%rbp), %rdi
callq 0xc3c0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x47271
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x47358
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x47342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3c0
jmp 0x47342
movb $0x1, -0x19(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc3c0
testb $0x1, -0x19(%rbp)
jne 0x47356
jmp 0x4734d
leaq -0x28(%rbp), %rdi
callq 0xc3c0
jmp 0x47358
movq -0x58(%rbp), %rdi
callq 0xc430
jmp 0x47363
movq -0x58(%rbp), %rdi
callq 0xc430
jmp 0x4736d
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6890
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::~Table()
Table::~Table() {
    if (sel == false) {
        fm->closeFile(main_file);
        if (p_key) delete p_key;
        for (uint i = 0; i < f_key.size(); i++) delete f_key[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x9fb0(%rax)
jne 0x4881a
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movl 0x9fa4(%rax), %esi
callq 0x34df0
jmp 0x48786
movq -0x18(%rbp), %rax
cmpq $0x0, 0x758(%rax)
je 0x487b5
movq -0x18(%rbp), %rax
movq 0x758(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x487b3
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x487b5
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x760, %rdi            # imm = 0x760
callq 0x447e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x48818
movq -0x18(%rbp), %rdi
addq $0x760, %rdi            # imm = 0x760
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x52cd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4880b
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x4880d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x487bc
jmp 0x4881a
movq -0x18(%rbp), %rdi
addq $0x9fd0, %rdi           # imm = 0x9FD0
callq 0xc430
movq -0x18(%rbp), %rdi
addq $0x9fb8, %rdi           # imm = 0x9FB8
callq 0xead0
movq -0x18(%rbp), %rax
addq $0x7a0, %rax            # imm = 0x7A0
movq %rax, -0x40(%rbp)
addq $0x9800, %rax           # imm = 0x9800
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $-0x98, %rdi
movq %rdi, -0x48(%rbp)
callq 0xea70
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x48852
movq -0x18(%rbp), %rdi
addq $0x780, %rdi            # imm = 0x780
callq 0xde10
movq -0x18(%rbp), %rdi
addq $0x760, %rdi            # imm = 0x760
callq 0xeb30
movq -0x18(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x58(%rbp)
addq $0x700, %rax            # imm = 0x700
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $-0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0xe9f0
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x488ad
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7460
nopl (%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::createColumn(Type)
int Table::createColumn(Type ty) {
    if (record_num > 0 && ty.beNull() == false) return -1;
    col_ty[col_num++] = ty;
    rebuild(1, col_num);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x9fa0(%rax)
jbe 0x48f21
movq -0x28(%rbp), %rdi
callq 0x53200
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x48f21
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48f61
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq %rcx, %rdi
addq $0x58, %rdi
movl 0x54(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x54(%rcx)
movl %eax, %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x53220
movq -0x20(%rbp), %rdi
movl 0x54(%rdi), %edx
movl $0x1, %esi
callq 0x4b890
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::getStr(unsigned char*, unsigned int)
char* Table::getStr(BufType buf, uint size) {
    char* str = new char[size + 1];
    memcpy(str, buf, size);
    str[size] = '\0';
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x6040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x63f0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::insert(Any&, enumType, unsigned int, unsigned char*&)
void Table::insert(Any& val, enumType ty, uint size, BufType& buf) {
    if (val.isNull()) {
        for (uint i = 0; i < size; i++) {
            *(uint8_t*)buf = 255;
            buf += 1;
        }
    }
    else {
        switch (ty) {
        case INT: 
            *(int*)buf = *val.anyCast<int>(); 
            break;
        case CHAR: 
            memcpy(buf, *val.anyCast<char*>(), strlen(*val.anyCast<char*>()));
            break; 
        case VARCHAR: 
            *(uint64_t*)buf = db->storeVarchar(*val.anyCast<char*>());
            break;
        case DATE: 
            *(uint32_t*)buf = *val.anyCast<uint32_t>(); 
            break;
        case DECIMAL: 
            *(long double*)buf = *val.anyCast<long double>(); 
            break;
        }
        buf += size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0x496d1
jmp 0x49708
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x49703
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb $-0x1, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x496d8
jmp 0x497f0
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x497de
movq -0x38(%rbp), %rax
leaq 0x3a3ec(%rip), %rcx     # 0x83b10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x10b40
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
jmp 0x497de
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a50
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a50
movq (%rax), %rdi
callq 0x6250
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x63f0
jmp 0x497de
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a50
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x85a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x497de
movq -0x10(%rbp), %rdi
callq 0x10d20
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
jmp 0x497de
movq -0x10(%rbp), %rdi
callq 0x10c30
fldt (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
fstpt (%rax)
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::constraintRow(Any*, unsigned int, bool)
int Table::constraintRow(Any* data, uint record_id, bool ck_unique) {
    for (uint i = 0; i < col_num; i++) {
        if (col_ty[i].beNull() == false && data[i].isNull()) return -1;
    }
    if (p_key != nullptr && constraintRowKey(data, p_key)) return -3;
    for (auto it: f_key) if (constraintRowKey(data, it)) return -4;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x54(%rcx), %eax
jae 0x49d28
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
movl -0x24(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x53200
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x49d1b
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xc920
testb $0x1, %al
jne 0x49d0f
jmp 0x49d1b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x49dd6
jmp 0x49d1d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x49cc9
movq -0x50(%rbp), %rax
cmpq $0x0, 0x758(%rax)
je 0x49d58
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x758(%rdi), %rdx
callq 0x4e9e0
cmpl $0x0, %eax
je 0x49d58
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x49dd6
movq -0x50(%rbp), %rax
addq $0x760, %rax            # imm = 0x760
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x446e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x44530
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x525a0
testb $0x1, %al
jne 0x49d93
jmp 0x49dcf
leaq -0x38(%rbp), %rdi
callq 0x44ab0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x4e9e0
cmpl $0x0, %eax
je 0x49dc2
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x49dd6
jmp 0x49dc4
leaq -0x38(%rbp), %rdi
callq 0x525e0
jmp 0x49d80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::findIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Table::findIndex(std::string s) {
    for (uint i = 0; i < index_num; i++) 
        if (s == std::string(this->index[i].name)) 
            return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x60(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x798(%rcx), %eax
jae 0x4b80d
movq -0x60(%rbp), %rax
movl -0x1c(%rbp), %ecx
imulq $0x98, %rcx, %rcx
leaq 0x7a8(%rax,%rcx), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x68a0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xc020
jmp 0x4b7b3
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc470
movb %al, -0x79(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6340
leaq -0x41(%rbp), %rdi
callq 0x6530
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x4b7de
jmp 0x4b7fd
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4b814
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x6530
jmp 0x4b820
jmp 0x4b7ff
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b766
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6890
nopl (%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::genOffset(unsigned int)
uint Table::genOffset(uint index) {
    uint ans = 0;
    for (uint i = 0; i < index; i++) {
        ans += this->col_ty[i].size();
    }
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x4b885
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x3d3d0
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b855
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::removePrimaryKey()
int Table::removePrimaryKey() {
    if (p_key == nullptr) return -1;
    for (auto it: p_key->f) it->p = nullptr;
    for (auto col: p_key->v) col_ty[col].key = enumKeyType::Common;
    int index_id = p_key_index;
    removeIndex(index_id);
    delete p_key;
    p_key = nullptr;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0x758(%rax)
jne 0x4c45a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c580
movq -0x58(%rbp), %rax
movq 0x758(%rax), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x446e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44530
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x525a0
testb $0x1, %al
jne 0x4c49a
jmp 0x4c4c1
leaq -0x20(%rbp), %rdi
callq 0x44ab0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x50(%rax)
leaq -0x20(%rbp), %rdi
callq 0x525e0
jmp 0x4c487
movq -0x58(%rbp), %rax
movq 0x758(%rax), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3d210
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3d240
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3d270
testb $0x1, %al
jne 0x4c501
jmp 0x4c536
leaq -0x40(%rbp), %rdi
callq 0x3d2b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x4c(%rbp)
addq $0x58, %rax
movl -0x4c(%rbp), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl $0x2, 0x2c(%rax)
leaq -0x40(%rbp), %rdi
callq 0x3d3b0
jmp 0x4c4ee
movq -0x58(%rbp), %rdi
movl 0x778(%rdi), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %esi
callq 0x49120
movq -0x58(%rbp), %rax
movq 0x758(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x4c56a
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x58(%rbp), %rax
movq $0x0, 0x758(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::modifyColumn(unsigned int, Type)
int Table::modifyColumn(uint col_id, Type ty) {
    switch (col_ty[col_id].ty) {
    case INT: 
    case DATE: 
    case DECIMAL:
        if (ty.ty != col_ty[col_id].ty) return -1;
        break;
    case CHAR:
    case VARCHAR:
        if (ty.ty == CHAR || ty.ty == VARCHAR) {
            if (col_ty[col_id].char_len > ty.char_len) return -2;
        } else return -1;
        break;
    }
    Type tmp = col_ty[col_id];
    col_ty[col_id] = ty;
    col_ty[col_id].key = tmp.key;
    if (constraintCol(col_id)) {
        col_ty[col_id] = tmp;
        return -3;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %ecx
imulq $0x38, %rcx, %rcx
movl 0x7c(%rax,%rcx), %eax
movl %eax, -0x6c(%rbp)
testl %eax, %eax
je 0x4c823
jmp 0x4c806
movl -0x6c(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x4c84f
jmp 0x4c812
movl -0x6c(%rbp), %eax
addl $-0x3, %eax
subl $0x1, %eax
ja 0x4c8a1
jmp 0x4c823
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rax
movl 0x24(%rax), %eax
addq $0x58, %rcx
movl -0x14(%rbp), %edx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x24(%rcx), %eax
je 0x4c84d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c95e
jmp 0x4c8a1
movq -0x80(%rbp), %rax
cmpl $0x1, 0x24(%rax)
je 0x4c863
movq -0x80(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x4c893
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
addq $0x58, %rax
movl -0x14(%rbp), %edx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movzbl 0x28(%rax), %eax
movzbl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jle 0x4c891
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4c95e
jmp 0x4c89f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c95e
jmp 0x4c8a1
movq -0x78(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x58(%rax,%rcx), %rsi
leaq -0x58(%rbp), %rdi
callq 0x52cf0
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rsi
movl -0x14(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x58(%rax,%rcx), %rdi
callq 0x53220
jmp 0x4c8d5
movq -0x78(%rbp), %rdi
movl -0x2c(%rbp), %ecx
movl -0x14(%rbp), %eax
imulq $0x38, %rax, %rax
movl %ecx, 0x84(%rdi,%rax)
movl -0x14(%rbp), %esi
callq 0x4c980
movl %eax, -0x84(%rbp)
jmp 0x4c8fa
movl -0x84(%rbp), %eax
cmpl $0x0, %eax
je 0x4c947
movq -0x78(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x58(%rax,%rcx), %rdi
leaq -0x58(%rbp), %rsi
callq 0x53220
jmp 0x4c920
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl $0x1, -0x68(%rbp)
jmp 0x4c955
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe9f0
jmp 0x4c96a
movl $0x0, -0x4(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe9f0
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6890
nopw %cs:(%rax,%rax)