LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movl $0x3ffff, %eax          # imm = 0x3FFFF
leal (%r14,%rax), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
movq %rdi, %rbx
movl $0xfffc0000, %edx       # imm = 0xFFFC0000
andl %edx, %ecx
movl %r14d, %esi
subl %ecx, %esi
imull $0x83, %esi, %ecx
addl %ebp, %ecx
addl %ecx, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
andl %edx, %eax
subl %eax, %ecx
movslq %ecx, %r15
movb 0x80000(%rdi,%r15), %al
cmpb $0x1, %al
jne 0x183e2
movq 0xc0000(%rbx), %rdi
movzwl (%rbx,%r15,2), %ecx
movl %ebp, %esi
movl %r14d, %edx
callq 0x68b6
testb %al, %al
jne 0x183da
movb 0x80001(%rbx,%r15), %al
incq %r15
jmp 0x183af
movb 0x80000(%rbx,%r15), %al
testb $0x1, %al
je 0x183f6
movb $0x0, 0x80000(%rbx,%r15)
movw $0x0, (%rbx,%r15,2)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Index.cpp
// Function: Index::insertRecord(Anys*, int, int)
void Index::insertRecord(Anys* info, int record_id, int now_index) {

    BtreeNode* now = Index::convert_buf_to_BtreeNode(now_index);

    //BtreeNode *now = Index::convert_buf_to_BtreeNode(index);
    //cout << "insert" << now->index << " "  << now->record_cnt;
    //cout << " " << (*info)[0].anyCast<int>() << " " << record_id << endl;
    int i = 0;
    vector<BtreeRecord>::iterator it;
    for (it = now->record.begin(); it!=now->record.end(); it++)
    {
        if (it->key > *info) {
            break;
        }
        if (it->key == *info && it->record_id > record_id) {
            break;
        }
        i ++;
    }

    if (now->is_leaf) {
        now->record.insert(it, BtreeRecord(record_id, *info));
        now->record_cnt++;
        now->child.push_back(-1);
        Index::convert_BtreeNode_to_buf(now);
        overflow_upstream(now->index);
        return;
    }
    else {
        Index::convert_BtreeNode_to_buf(now);
        Index::insertRecord(info, record_id, now->child[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
movq %rdi, 0x8(%rsp)
movq %r13, %rdi
movl %ecx, %esi
callq 0x19412
movq %rax, %r14
movq 0x50(%rax), %r12
cmpq 0x58(%rax), %r12
je 0x1a744
xorl %ebx, %ebx
leaq 0x8(%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x9aa6
testb %al, %al
jne 0x1a73b
movq %r13, %rdi
movq %r15, %rsi
callq 0x9996
testb %al, %al
je 0x1a72f
cmpl %ebp, (%r12)
jg 0x1a73b
incl %ebx
addq $0x20, %r12
cmpq 0x58(%r14), %r12
jne 0x1a706
movl %ebx, %ebx
movq 0x8(%rsp), %r13
jmp 0x1a746
xorl %ebx, %ebx
cmpb $0x1, 0x68(%r14)
je 0x1a761
movq %r13, %rdi
movq %r14, %rsi
callq 0x1984c
movq 0x20(%r14), %rax
movl (%rax,%rbx,4), %ecx
jmp 0x1a6ed
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xa26a
leaq 0x30(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %r13, %rsi
callq 0xa26a
leaq 0x50(%r14), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
callq 0x1d774
movq %r15, %rdi
callq 0xa37e
leaq 0x10(%rsp), %rdi
callq 0xa37e
incl 0x1c(%r14)
movl $0xffffffff, 0x28(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%r14), %rsi
cmpq 0x30(%r14), %rsi
movq 0x8(%rsp), %rbx
je 0x1a7d3
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, 0x28(%r14)
jmp 0x1a7e4
movq %r14, %rdi
addq $0x20, %rdi
leaq 0x28(%rsp), %rdx
callq 0x1cbbc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1984c
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x1a368
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xa37e
jmp 0x1a81a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa37e
movq %rbx, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x60(%rdi)
movb $0x1, 0x68(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x6c(%rdi)
movl $0x0, 0x1c(%rdi)
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x30(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1cbbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
leaq 0x50(%r14), %rdi
callq 0x1c79a
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x1c699
movq 0x48(%r14), %rsi
subq %rdi, %rsi
callq 0x53a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5baf
movq %r12, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
callq 0xd118
movq %rbx, %rdi
callq 0xd118
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1dcc6
leaq 0x22f09(%rip), %rsi     # 0x408f6
movq %rbx, %rdi
callq 0x8eb2
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xd118
movb (%r15), %al
movb (%r12), %cl
movb %cl, (%r15)
movb %al, (%r12)
leaq 0x18(%rsp), %r13
movq 0x8(%r15), %rax
movq (%r13), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r13)
movq %r15, %rdi
callq 0xd118
movq %r12, %rdi
callq 0xd118
movzbl -0x8(%r13), %esi
movq %r13, %rdi
callq 0xd1ba
movq 0x50(%r14), %rax
movq 0x48(%rax), %rax
movl 0x50(%rax), %eax
movq %rsp, %r14
movb $0x6, (%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd118
movq %r14, %rdi
callq 0xd118
leaq 0x1ec7d(%rip), %rsi     # 0x3c6ef
movq %rbx, %rdi
callq 0x8eb2
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0xd118
movb (%r14), %al
movb (%r12), %cl
movb %cl, (%r14)
movb %al, (%r12)
movq 0x8(%r14), %rax
movq 0x8(%r12), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0xd118
movq %r12, %rdi
callq 0xd118
movzbl (%r12), %esi
movq %r15, %rdi
callq 0xd1ba
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0x1daeb
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x907c
jmp 0x1daf5
movq %rax, %r14
movq %rbx, %rdi
callq 0x907c
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x80004(%rdi), %eax
cmpl %esi, %eax
je 0x1e0e6
movslq %eax, %rcx
movslq %esi, %rdx
movl (%rdi,%rdx,8), %r8d
cmpl %esi, 0x80008(%rdi)
jne 0x1e0c5
leaq 0x80008(%rdi), %r9
jmp 0x1e0d6
movslq %r8d, %r9
movslq 0x4(%rdi,%rdx,8), %r10
movl %r10d, 0x4(%rdi,%r9,8)
leaq (%rdi,%r10,8), %r9
movl %r8d, (%r9)
movl %eax, 0x4(%rdi,%rdx,8)
movl %esi, (%rdi,%rcx,8)
movl %esi, 0x80004(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x80000(%rdi), %rax
testq %rax, %rax
je 0x1e119
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x1e131
movslq 0x80004(%rdi), %rcx
movl %ecx, 0x4(%rdi,%rax,8)
movl %eax, (%rdi,%rcx,8)
movl %eax, 0x80004(%rdi)
leal 0x1(%rax), %ecx
movl %ecx, 0x80000(%rdi)
retq
movl $0x0, 0x80008(%rdi)
movq $0x1, 0x80000(%rdi)
xorl %eax, %eax
retq
movl 0x80004(%rdi), %ecx
movl 0x80008(%rdi), %eax
cmpl %eax, %ecx
je 0x1e118
movslq %eax, %rdx
movslq %ecx, %rsi
movl (%rdi,%rdx,8), %r8d
movl %r8d, 0x80008(%rdi)
movl %ecx, 0x4(%rdi,%rdx,8)
movl %eax, (%rdi,%rsi,8)
movl %eax, 0x80004(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
subq 0x8(%r14), %rsi
jae 0x1e1bd
movl %edx, %ecx
addl $-0x2, %ecx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53d0
leaq 0x227a9(%rip), %rsi     # 0x4093c
movq %r15, %rdi
callq 0x5780
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1e208
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1e20e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movl $0x20, %edx
callq 0x5460
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5420
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1e24d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1e253
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e240
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x1e233
jmp 0x1e240
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x1e299
jmp 0x1e2a6
movq %rax, %rbx
jmp 0x1e2a6
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e2a6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x4, %esi
ja 0x1e32b
movl %esi, %eax
leaq 0x2264d(%rip), %rcx     # 0x40914
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x22668(%rip), %rsi     # 0x4093f
leaq 0x22664(%rip), %rdx     # 0x40942
jmp 0x1e31e
leaq 0x22664(%rip), %rsi     # 0x4094b
leaq 0x22664(%rip), %rdx     # 0x40952
jmp 0x1e31e
leaq 0x2264c(%rip), %rsi     # 0x40943
leaq 0x2264c(%rip), %rdx     # 0x4094a
jmp 0x1e31e
leaq 0x22f59(%rip), %rsi     # 0x41260
leaq 0x22f56(%rip), %rdx     # 0x41264
jmp 0x1e31e
leaq 0x2262f(%rip), %rsi     # 0x40946
leaq 0x2262c(%rip), %rdx     # 0x4094a
movq %rbx, %rdi
callq 0xa960
movq %rbx, %rax
popq %rbx
retq
leaq 0x2500a(%rip), %rdx     # 0x4333c
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x1e321
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x4, %esi
ja 0x1e3b7
movl %esi, %eax
leaq 0x225d5(%rip), %rcx     # 0x40928
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x225f0(%rip), %rsi     # 0x40953
leaq 0x225f0(%rip), %rdx     # 0x4095a
jmp 0x1e3aa
leaq 0x225fa(%rip), %rsi     # 0x4096d
leaq 0x225f8(%rip), %rdx     # 0x40972
jmp 0x1e3aa
leaq 0x225de(%rip), %rsi     # 0x40961
leaq 0x225dc(%rip), %rdx     # 0x40966
jmp 0x1e3aa
leaq 0x225d4(%rip), %rsi     # 0x40967
leaq 0x225d2(%rip), %rdx     # 0x4096c
jmp 0x1e3aa
leaq 0x225b8(%rip), %rsi     # 0x4095b
leaq 0x225b6(%rip), %rdx     # 0x40960
movq %rbx, %rdi
callq 0xa960
movq %rbx, %rax
popq %rbx
retq
leaq 0x24f7e(%rip), %rdx     # 0x4333c
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x1e3ad
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl 0x8(%rdi), %ecx
incl %ecx
movl %ecx, 0x8(%rdi)
movq (%rdi), %r8
cmpl $0x0, 0x9fb0(%r8)
jne 0x1fa0e
movq %rdi, %rbx
movl %ecx, %eax
xorl %edx, %edx
divl 0x9fac(%r8)
testl %edx, %edx
jne 0x1f9ac
movq 0x48(%r8), %rdi
movl 0x9fa4(%r8), %esi
movl %eax, %edx
callq 0x6722
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %ecx
movq (%rbx), %r8
cmpl 0x9fa0(%r8), %ecx
jae 0x1fa0e
movq 0x10(%rbx), %rsi
movl 0x9fac(%r8), %edi
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movl %edx, %eax
shrl $0x3, %eax
movzbl (%rsi,%rax), %eax
andl $0x7, %edx
btl %edx, %eax
jb 0x1fa0e
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %eax
xorl %edx, %edx
divl %edi
testl %edx, %edx
jne 0x1fa05
movq 0x48(%r8), %rdi
movl 0x9fa4(%r8), %esi
movl %eax, %edx
callq 0x6722
movq %rax, %rsi
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %ecx
movq (%rbx), %r8
cmpl 0x9fa0(%r8), %ecx
jb 0x1f9b9
cmpl 0x9fa0(%r8), %ecx
setb %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
cmpl $0x0, 0x9fb0(%rdi)
je 0x1fa99
movl 0x8(%r14), %eax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x9fb8(%rdi), %rsi
movq %rbx, %rdi
callq 0xa26a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x9fac(%rdi), %ecx
leal -0x1(%rcx), %esi
shrl $0x3, %esi
addq 0x10(%r14), %rsi
movl 0x8(%r14), %eax
xorl %r8d, %r8d
xorl %edx, %edx
divl %ecx
imull 0x9fa8(%rdi), %edx
leaq (%rdx,%rsi), %rax
incq %rax
movq %rax, 0x10(%rsp)
movq %r8, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r8, (%rsp)
cmpl $0x0, 0x54(%rdi)
je 0x1fa87
movl $0x80, %r15d
xorl %r12d, %r12d
leaq 0x20e91(%rip), %r13     # 0x4097c
movl -0x4(%rdi,%r15), %edx
cmpq $0x4, %rdx
ja 0x1fb1c
movslq (%r13,%rdx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x4, %ebp
jmp 0x1fb21
movl $0x10, %ebp
jmp 0x1fb21
movzbl (%rdi,%r15), %ebp
jmp 0x1fb21
movl $0x8, %ebp
jmp 0x1fb21
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rsi
movl %ebp, %ecx
movq %rsp, %r8
xorl %r9d, %r9d
callq 0x21a40
movl %ebp, %eax
addq %rax, 0x10(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fb4b
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x1fb4d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9f9a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1fb6f
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
movq (%r14), %rdi
movl 0x54(%rdi), %eax
addq $0x38, %r15
cmpq %rax, %r12
jb 0x1faeb
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fa87
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1fa87
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1fbb5
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1fbb5
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fbc4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xa37e
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x9fb0(%rdi)
jne 0x20c59
movq 0x40(%rbx), %rdi
movl 0x9fa4(%rbx), %esi
callq 0x17c0a
movq 0x758(%rbx), %rdi
testq %rdi, %rdi
je 0x20c0f
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x760(%rbx), %rax
movq 0x768(%rbx), %rcx
cmpq %rax, %rcx
je 0x20c59
movl $0x1, %ebp
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
je 0x20c46
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x760(%rbx), %rax
movq 0x768(%rbx), %rcx
movl %ebp, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x20c29
leaq 0x9fd0(%rbx), %rdi
callq 0xa37e
leaq 0x9fb8(%rbx), %rdi
callq 0x280c0
movl $0x9f90, %r14d          # imm = 0x9F90
movq -0x10(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x20c8d
movq (%rbx,%r14), %rsi
subq %rdi, %rsi
callq 0x53a0
movq -0x40(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x20ca4
movq -0x30(%rbx,%r14), %rsi
subq %rdi, %rsi
callq 0x53a0
movq -0x58(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x20cbb
movq -0x48(%rbx,%r14), %rsi
subq %rdi, %rsi
callq 0x53a0
addq $-0x98, %r14
cmpq $0x790, %r14            # imm = 0x790
jne 0x20c77
movq 0x780(%rbx), %rdi
testq %rdi, %rdi
je 0x20ce6
movq 0x790(%rbx), %rsi
subq %rdi, %rsi
callq 0x53a0
movq 0x760(%rbx), %rdi
testq %rdi, %rdi
je 0x20d01
movq 0x770(%rbx), %rsi
subq %rdi, %rsi
callq 0x53a0
movl $0x700, %r14d           # imm = 0x700
movq 0x50(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x20d17
movq (%rdi), %rax
callq *0x8(%rax)
addq $-0x38, %r14
jne 0x20d07
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x6925
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x9fa0(%rdi)
je 0x211a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, (%rsi)
jne 0x21200
movl 0x54(%rbx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x54(%rbx)
imulq $0x38, %rax, %rax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x78(%rbx,%rax)
movups %xmm1, 0x68(%rbx,%rax)
movups %xmm0, 0x58(%rbx,%rax)
movq $0x0, 0x88(%rbx,%rax)
movq 0x30(%rsi), %rdi
testq %rdi, %rdi
je 0x211f1
leaq (%rbx,%rax), %r14
addq $0x58, %r14
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x30(%r14)
movl 0x54(%rbx), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22f36
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq (%rsi), %r14
testq %r14, %r14
je 0x21944
cmpl $0x4, %edx
ja 0x21a2c
movl %edx, %eax
leaq 0x1f090(%rip), %rcx     # 0x409b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30da8(%rip), %rsi     # 0x526e0
leaq 0x30dc9(%rip), %rdx     # 0x52708
jmp 0x219c7
testl %ebp, %ebp
je 0x21a31
movq (%rbx), %rax
movb $-0x1, (%rax)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
decl %ebp
jne 0x2194f
jmp 0x21a31
leaq 0x30d75(%rip), %rsi     # 0x526e0
leaq 0x30dae(%rip), %rdx     # 0x52720
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5430
fldt 0x10(%rax)
movq (%rbx), %rax
fstpt (%rax)
jmp 0x21a2c
movq 0x38(%rdi), %r15
leaq 0x30d4c(%rip), %rsi     # 0x526e0
leaq 0x30d55(%rip), %rdx     # 0x526f0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5430
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x7792
movq (%rbx), %rcx
movq %rax, (%rcx)
jmp 0x21a2c
leaq 0x30d20(%rip), %rsi     # 0x526e0
leaq 0x30d71(%rip), %rdx     # 0x52738
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5430
movl 0x8(%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
jmp 0x21a2c
movq (%rbx), %rax
movq %rax, (%rsp)
leaq 0x30cf7(%rip), %r12     # 0x526e0
leaq 0x30d00(%rip), %r13     # 0x526f0
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x5430
movq 0x8(%rax), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x5430
movq 0x8(%rax), %rdi
callq 0x51f0
movq (%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5310
movl %ebp, %eax
addq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::fetchWithOffset(unsigned char*&, enumType, unsigned int, Any&, unsigned int)
void Table::fetchWithOffset(BufType& buf, enumType ty, uint size, Any& val, uint offset) {
    buf += offset;
    BufType temp = buf;
    bool flag = true;
    for (uint i = 0; i < size; i++) {
        if (*(uint8_t*)buf != 255) {
            flag = false;
            break;
        }
        buf += 1;
    }
    buf = temp;
    if (flag) val = Any();
    else{
        switch (ty) {
        case INT: 
            val = *(int*)buf; 
            break;
        case CHAR:
            val = getStr(buf, size);
            break;
        case VARCHAR: 
            val = db->getVarchar(*(uint64_t*)buf); 
            break;
        case DATE: 
            val = *(uint32_t*)buf; 
            break;
        case DECIMAL: 
            val = *(long double*)buf; 
            break;
        }
    }
    buf -= offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %rbx
movq (%rsi), %rax
movl %r9d, %ebp
leaq (%rax,%rbp), %r15
movq %r15, (%rsi)
testl %ecx, %ecx
je 0x21a7b
movl %ecx, %r12d
addq %rbp, %rax
incq %rax
cmpb $-0x1, -0x1(%rax)
jne 0x21a97
movq %rax, (%rbx)
incq %rax
decl %ecx
jne 0x21a6b
movq %r15, (%rbx)
movq $0x0, (%r14)
subq %rbp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rbx)
cmpl $0x4, %edx
ja 0x21a85
movl %edx, %eax
leaq 0x1ef24(%rip), %rcx     # 0x409cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
callq 0x28108
jmp 0x21a85
movq %r14, %rdi
movq %r15, %rsi
callq 0x28190
jmp 0x21a85
movq 0x38(%rdi), %rdi
movq (%r15), %rsi
callq 0x76be
movq %rax, %r12
movl $0x10, %edi
callq 0x5390
movq %rax, %r15
leaq 0x30f62(%rip), %rax     # 0x52a50
movq %rax, (%r15)
movq %r12, 0x8(%r15)
jmp 0x21b43
movq %r14, %rdi
movq %r15, %rsi
callq 0x2814c
jmp 0x21a85
leal 0x1(%r12), %edi
callq 0x5040
movq %rax, %r13
movl %r12d, %r12d
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5310
movb $0x0, (%r13,%r12)
movl $0x10, %edi
callq 0x5390
movq %rax, %r15
leaq 0x30f14(%rip), %rax     # 0x52a50
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21b51
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, (%r14)
jmp 0x21a85
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rdi), %eax
testq %rax, %rax
je 0x21dae
leaq 0x58(%r14), %rcx
xorl %edx, %edx
cmpb $0x0, (%rcx)
jne 0x21da2
cmpq $0x0, (%rbx,%rdx,8)
je 0x21dfb
incq %rdx
addq $0x38, %rcx
cmpq %rdx, %rax
jne 0x21d96
movq 0x758(%r14), %rdx
testq %rdx, %rdx
je 0x21dce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25712
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
testl %eax, %eax
jne 0x21e07
movq 0x760(%r14), %r15
movq 0x768(%r14), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x21e07
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25712
testl %eax, %eax
jne 0x21e02
addq $0x8, %r15
jmp 0x21dde
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x21e07
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::queryRecord(int, Any*&)
int Table::queryRecord(const int record_id, Any* &data) {
    BufType buf = bpm->getPage(main_file, record_id / record_onepg);
    if (exist(buf, record_id % record_onepg)) {
        buf += (record_onepg - 1) / 8 + 1;
        buf += record_size * (record_id % record_onepg);
        data = new Any[col_num];
        memset(data, 0, col_num * sizeof(Any));
        for (uint i = 0; i < col_num; i++) {
            fetch(buf, col_ty[i].ty, col_ty[i].size(), data[i]);
        }
        return 0;
    } else return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movl 0x9fa4(%r14), %esi
xorl %ebp, %ebp
movl %r15d, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
movl %eax, %edx
callq 0x6722
movq %rax, %rcx
movl 0x9fac(%r14), %esi
movl %r15d, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
shrl $0x3, %eax
movzbl (%rcx,%rax), %eax
movl %edx, %edi
andl $0x7, %edi
btl %edi, %eax
jae 0x228ea
decl %esi
shrl $0x3, %esi
addq %rsi, %rcx
imull 0x9fa8(%r14), %edx
leaq (%rdx,%rcx), %rax
incq %rax
movq %rax, 0x8(%rsp)
movl 0x54(%r14), %ebx
leaq (,%rbx,8), %r15
leaq 0x8(,%rbx,8), %rdi
callq 0x5040
movq %rbx, (%rax)
leaq 0x8(%rax), %rdi
movq %r12, 0x10(%rsp)
movq %rdi, (%r12)
xorl %esi, %esi
movq %r15, %rdx
callq 0x5240
testq %rbx, %rbx
je 0x228ef
leaq 0x80(%r14), %r13
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %ebp, %ebp
movl -0x4(%r13), %edx
cmpq $0x4, %rdx
ja 0x228a8
leaq 0x1e188(%rip), %rcx     # 0x40a08
movslq (%rcx,%rdx,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %r12d
jmp 0x228ae
movl $0x10, %r12d
jmp 0x228ae
movzbl (%r13), %r12d
jmp 0x228ae
movl $0x8, %r12d
jmp 0x228ae
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movq (%rax), %r8
addq %r15, %r8
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movl %r12d, %ecx
xorl %r9d, %r9d
callq 0x21a40
movl %r12d, %eax
addq %rax, 0x8(%rsp)
incq %rbx
movl 0x54(%r14), %eax
addq $0x38, %r13
addq $0x8, %r15
cmpq %rax, %rbx
jb 0x2286f
jmp 0x228ef
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::queryRecord(int)
Anys Table::queryRecord(const int record_id) {
    if (sel) return this->data[record_id];
    Anys data;
    BufType buf = bpm->getPage(main_file, record_id / record_onepg);
    if (exist(buf, record_id % record_onepg)) {
        buf += (record_onepg - 1) / 8 + 1;
        buf += record_size * (record_id % record_onepg);
        Any any;
        for (uint i = 0; i < col_num; i++) {
            fetch(buf, col_ty[i].ty, col_ty[i].size(), any);
            data.push_back(any);
        }
    }
    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x9fb0(%rsi)
je 0x2294b
movslq %ebp, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x9fb8(%r14), %rsi
movq %rbx, %rdi
callq 0xa26a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x48(%r14), %rdi
movl 0x9fa4(%r14), %esi
movl %ebp, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
movl %eax, %edx
callq 0x6722
movq %rax, %rcx
movl 0x9fac(%r14), %esi
movl %ebp, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
shrl $0x3, %eax
movzbl (%rcx,%rax), %eax
movl %edx, %edi
andl $0x7, %edi
btl %edi, %eax
jae 0x22939
decl %esi
shrl $0x3, %esi
addq %rsi, %rcx
imull 0x9fa8(%r14), %edx
leaq (%rdx,%rcx), %rax
incq %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
cmpl $0x0, 0x54(%r14)
je 0x22939
leaq 0x80(%r14), %r15
xorl %r12d, %r12d
leaq 0x1e043(%rip), %r13     # 0x40a1c
movl -0x4(%r15), %edx
cmpq $0x4, %rdx
ja 0x22a08
movslq (%r13,%rdx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x4, %ebp
jmp 0x22a0d
movl $0x10, %ebp
jmp 0x22a0d
movzbl (%r15), %ebp
jmp 0x22a0d
movl $0x8, %ebp
jmp 0x22a0d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %ecx
movq %rsp, %r8
xorl %r9d, %r9d
callq 0x21a40
movl %ebp, %eax
addq %rax, 0x10(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x22a3a
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x22a3c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9f9a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22a5e
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
movl 0x54(%r14), %eax
addq $0x38, %r15
cmpq %rax, %r12
jb 0x229d9
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x22939
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x22939
movq %rax, %r14
jmp 0x22ab6
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22aa7
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x22aa7
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x22ab6
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xa37e
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x798(%rdi)
je 0x22ed1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7a8(%rdi), %r12
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x51f0
leaq (%rax,%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xa960
movq 0x8(%r14), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x22e74
movq 0x8(%rsp), %rbp
testq %rdx, %rdx
je 0x22e7e
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x53c0
testl %eax, %eax
sete %r13b
jmp 0x22e81
movq 0x8(%rsp), %rbp
xorl %r13d, %r13d
jmp 0x22e81
movb $0x1, %r13b
leaq 0x18(%rsp), %rax
cmpq %rax, %rbp
je 0x22e9b
movq 0x18(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x53a0
testb %r13b, %r13b
jne 0x22ec1
incq %rbx
movl 0x798(%r15), %eax
addq $0x98, %r12
cmpq %rax, %rbx
jb 0x22e29
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x22ec3
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
je 0x22f32
movl %esi, %eax
imulq $0x38, %rax, %rcx
xorl %edx, %edx
leaq 0x1db5f(%rip), %rsi     # 0x40a44
xorl %eax, %eax
movl 0x7c(%rdi,%rdx), %r8d
cmpq $0x4, %r8
ja 0x22f1f
movslq (%rsi,%r8,4), %r8
addq %rsi, %r8
jmpq *%r8
movl $0x4, %r8d
jmp 0x22f25
movl $0x10, %r8d
jmp 0x22f25
movzbl 0x80(%rdi,%rdx), %r8d
jmp 0x22f25
movl $0x8, %r8d
jmp 0x22f25
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
addl %r8d, %eax
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x22ee7
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x758(%rdi), %rax
testq %rax, %rax
je 0x2383f
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rax), %rcx
movq 0x58(%rax), %rdx
cmpq %rdx, %rcx
je 0x237e8
movq (%rcx), %rsi
movq $0x0, 0x50(%rsi)
addq $0x8, %rcx
jmp 0x237d2
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rax
cmpq %rax, %rcx
je 0x23810
leaq 0x58(%rbx), %rdx
movl (%rcx), %esi
imulq $0x38, %rsi, %rsi
movl $0x2, 0x2c(%rdx,%rsi)
addq $0x4, %rcx
cmpq %rax, %rcx
jne 0x237f9
movl 0x778(%rbx), %esi
movq %rbx, %rdi
callq 0x2139c
movq 0x758(%rbx), %rdi
testq %rdi, %rdi
je 0x23830
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x758(%rbx)
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
imulq $0x38, %rax, %rax
leaq (%rdi,%rax), %r13
addq $0x58, %r13
movl 0x24(%r13), %eax
cmpl $0x4, %eax
ja 0x23a07
movl $0x19, %ecx
btl %eax, %ecx
jae 0x239de
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %eax, 0x24(%r15)
je 0x23a07
jmp 0x23ae4
movl 0x24(%r15), %eax
decl %eax
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x1, %eax
ja 0x23ae4
movb 0x28(%r13), %al
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
cmpb 0x28(%r15), %al
ja 0x23ae4
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x1c(%r13), %xmm2
movups %xmm2, 0x1c(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl 0x2c(%r13), %r12d
movq 0x30(%r13), %rdi
testq %rdi, %rdi
je 0x23a3c
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
jmp 0x23a3e
xorl %ebx, %ebx
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%r13)
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movq $0x0, 0x30(%r13)
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x23a76
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x30(%r13)
movl %r12d, 0x2c(%r13)
movq %r14, %rdi
movl %ebp, %esi
callq 0x23b14
testl %eax, %eax
je 0x23acb
movups 0x1c(%rsp), %xmm0
movups %xmm0, 0x1c(%r13)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movl %r12d, 0x2c(%r13)
movq $0x0, 0x30(%r13)
testq %rbx, %rbx
je 0x23ade
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %rax, 0x30(%r13)
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
jmp 0x23ad3
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x23ae4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x23ae4
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x23b03
movq %rax, %r14
testq %rbx, %rbx
je 0x23b0c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::constraintCol(unsigned int)
int Table::constraintCol(uint col_id) {
    if (col_ty[col_id].beNull() == false) {
        Pointer p(this);
        while (p.next()) if (p.get()[col_id].isNull()) return -1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %r12d
imulq $0x38, %r12, %rax
xorl %ebx, %ebx
cmpb $0x0, 0x58(%rdi,%rax)
jne 0x23b75
leaq 0x18(%rsp), %r14
movq %rdi, (%r14)
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %rsp, %r15
movq %r14, %rdi
callq 0x1f964
testb %al, %al
je 0x23b75
movq %r15, %rdi
movq %r14, %rsi
callq 0x1fa4c
movq (%rsp), %rax
movq (%rax,%r12,8), %r13
movq %r15, %rdi
callq 0xa37e
testq %r13, %r13
jne 0x23b44
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::createPrimaryKey(PrimaryKey*)
int Table::createPrimaryKey(PrimaryKey* pk) {
    if (p_key) return -1;
    if (constraintKey(pk)) return -2;
    p_key = new PrimaryKey(this);
    p_key->v_size = pk->v_size;
    p_key->name = pk->name;
    p_key->v.clear();
    for (auto i: pk->v)p_key->v.push_back(i);
    p_key->table = pk->table;
    updateColumns();
    if (p_key_index != -1) removeIndex(p_key_index);
    p_key_index = createIndex(p_key->v, "pk");
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x0, 0x758(%rdi)
jne 0x23d20
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23d70
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testl %eax, %eax
jne 0x23d20
movl $0x68, %edi
callq 0x5390
leaq 0x10(%rax), %rdi
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movb $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movq %rcx, 0x40(%rax)
movq %rbx, 0x48(%rax)
leaq 0x2f063(%rip), %rdx     # 0x52c58
movq %rdx, (%rax)
movups %xmm0, 0x50(%rax)
movq %rcx, 0x60(%rax)
movq %rax, 0x758(%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
leaq 0x10(%r14), %rsi
callq 0x5230
movq 0x758(%rbx), %rax
movq 0x30(%rax), %rcx
cmpq %rcx, 0x38(%rax)
je 0x23c2c
movq %rcx, 0x38(%rax)
movq 0x30(%r14), %r12
movq 0x38(%r14), %r13
cmpq %r13, %r12
je 0x23c7f
leaq 0xc(%rsp), %r15
movl (%r12), %eax
movl %eax, 0xc(%rsp)
movq 0x758(%rbx), %rdi
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x23c63
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rdi)
jmp 0x23c6f
addq $0x30, %rdi
movq %r15, %rdx
callq 0x1d0aa
addq $0x4, %r12
cmpq %r13, %r12
jne 0x23c3e
movq 0x758(%rbx), %rax
movq 0x48(%r14), %rcx
movq %rcx, 0x48(%rax)
movq %rbx, %rdi
callq 0x21208
movl 0x778(%rbx), %esi
cmpl $-0x1, %esi
je 0x23ca2
movq %rbx, %rdi
callq 0x2139c
movq 0x758(%rbx), %rsi
addq $0x30, %rsi
leaq 0x10(%rsp), %rdi
callq 0x1c59a
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1cf84(%rip), %rsi     # 0x40c4b
leaq 0x1cf7f(%rip), %rdx     # 0x40c4d
leaq 0x28(%rsp), %rdi
callq 0xa960
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x21478
movl %eax, 0x778(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x23d07
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x10(%rsp), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x23d20
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
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
cmpq %r14, %rdi
je 0x23d50
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x23d50
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23d67
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::printBack(unsigned int)
bool Table::printBack(uint num) {
    if (num == 0 || sel != 1) return false;
    std::vector<std::pair<std::string, int> > v;
    for (uint i = 0; i < col_num; i++) v.push_back(std::pair<std::string, int>(col_ty[i].name, std::max(col_ty[i].printLen(), (int)strlen(col_ty[i].name))));
    Print::title(v);
    for (uint it = record_num - num; it < record_num; it++) { 
        Print::row(data[it]);
    }
    Print::end();
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %esi, %esi
setne %cl
cmpl $0x1, 0x9fb0(%rdi)
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x255da
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movb %al, 0xb(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, 0x54(%rdi)
je 0x2554f
leaq 0x5a(%r14), %r15
xorl %r13d, %r13d
leaq 0x30(%rsp), %r12
leaq -0x2(%r15), %rdi
callq 0x281d4
movl %eax, %ebp
movq %r15, %rdi
callq 0x51f0
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %r15, %rdi
callq 0x51f0
leaq (%rax,%r15), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa960
cmpl %ebx, %ebp
cmovgl %ebp, %ebx
movl %ebx, 0x50(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x1755c
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2553f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53a0
incq %r13
movl 0x54(%r14), %eax
addq $0x38, %r15
cmpq %rax, %r13
jb 0x254d6
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x989e
leaq 0x58(%rsp), %rdi
callq 0x1ea24
movl 0xc(%rsp), %ebp
leaq 0x58(%rsp), %rdi
callq 0x9938
movl 0x9fa0(%r14), %ebx
subl %ebp, %ebx
jb 0x255c7
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %r12
leaq 0x70(%rsp), %r15
movq 0x9fb8(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0xa26a
movq %r15, %rdi
callq 0x1f028
movq %r15, %rdi
callq 0xa37e
incq %rbx
movl 0x9fa0(%r14), %eax
addq $0x18, %r12
cmpq %rax, %rbx
jb 0x25592
callq 0x1f368
leaq 0x10(%rsp), %rdi
callq 0x9938
movb 0xb(%rsp), %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9938
jmp 0x25613
jmp 0x25610
jmp 0x25610
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa37e
jmp 0x25613
jmp 0x25610
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9938
movq %rbx, %rdi
callq 0x56e0
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x25613
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x25613
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::cmpRecord(Anys, Anys, enumOp)
bool Table::cmpRecord(Anys a, Anys b, enumOp op) {
    switch (op) {
    case OP_EQ: return a == b;
    case OP_NEQ: return a != b;
    case OP_LE: return a <= b;
    case OP_LS: return a < b;
    case OP_GE: return a >= b;
    case OP_GT: return a > b;
    default: return false;
    }
}

// Assembly:
pushq %rax
cmpl $0x5, %ecx
ja 0x25b55
movl %ecx, %eax
leaq 0x1b01d(%rip), %rcx     # 0x40b1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9996
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9a04
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9aa6
jmp 0x25b45
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9a04
jmp 0x25b45
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9996
xorb $0x1, %al
jmp 0x25b57
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9aa6
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::cmpRecords(Anys, enumOp, bool, bool)
bool Table::cmpRecords(Anys data, enumOp op, bool any, bool all) {
    bool cmp;
    Anys _data;
    Pointer p(this);
    while (p.next()) {
        _data = p.get();
        cmp = cmpRecord(data, _data, op);
        if (any && cmp) return true;
        if (all && !cmp) return false;
    }
    // for (uint record_id = 0; record_id < record_num; record_id++) {
    //     if ((_data = queryRecord(record_id)).size() == 0) continue;
    //     cmp = cmpRecord(data, _data, op);
    //     if (any && cmp) return true;
    //     if (all && !cmp) return false;
    // }
    if (any) return false;
    if (all) return true;
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, 0x4(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0xa0(%rsp), %r13
movq %rdi, (%r13)
movl $0xffffffff, 0x8(%r13)  # imm = 0xFFFFFFFF
movl %r8d, 0x8(%rsp)
movl %r8d, %ebx
xorb $0x1, %bl
leaq 0x88(%rsp), %r12
leaq 0x70(%rsp), %r14
movq %r13, %rdi
callq 0x1f964
leaq 0x30(%rsp), %r15
testb %al, %al
je 0x25c73
movq %r15, %rdi
movq %r13, %rsi
callq 0x1fa4c
movq 0x20(%rsp), %rax
movaps 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movaps 0x10(%rsp), %xmm1
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, 0x50(%rsp)
movq %rax, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xa37e
movq %r15, %rdi
callq 0xa37e
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0xa26a
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0xa26a
movq %r12, %rsi
movq %r14, %rdx
movl 0xc(%rsp), %ecx
callq 0x25af0
movl %eax, %ebp
movq %r14, %rdi
callq 0xa37e
movq %r12, %rdi
callq 0xa37e
movl %ebp, %r15d
andb 0x4(%rsp), %r15b
orb %bl, %bpl
cmpb %bpl, %r15b
jne 0x25bb7
jmp 0x25c80
movl 0x4(%rsp), %eax
notb %al
andb 0x8(%rsp), %al
movl %eax, %r15d
leaq 0x10(%rsp), %rdi
callq 0xa37e
movl %r15d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x25cb1
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa37e
leaq 0x88(%rsp), %rdi
callq 0xa37e
jmp 0x25cc5
jmp 0x25cc2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa37e
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::existentRecords()
vector<uint> Table::existentRecords() {
    vector<uint> ret;
    BufType buf;
    for (uint record_id = 0; record_id < record_num; record_id++) {
        if (record_id % record_onepg == 0) {
            buf = bpm->getPage(main_file, record_id / record_onepg);
        }
        if (exist(buf, record_id % record_onepg)) {
            ret.push_back(record_id);
        }
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x4(%rsp)
cmpl $0x0, 0x9fa0(%rsi)
je 0x26239
movq %rsi, %r14
xorl %ecx, %ecx
leaq 0x4(%rsp), %r15
movl %ecx, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
testl %edx, %edx
jne 0x261f3
movq 0x48(%r14), %rdi
movl 0x9fa4(%r14), %esi
movl %eax, %edx
callq 0x6722
movq %rax, %r12
movl 0x4(%rsp), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
movl %edx, %eax
shrl $0x3, %eax
movzbl (%r12,%rax), %eax
andl $0x7, %edx
btl %edx, %eax
jae 0x26226
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2621b
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x26226
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1d0aa
movl 0x4(%rsp), %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
cmpl 0x9fa0(%r14), %ecx
jb 0x261c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2625f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53a0
movq %r14, %rdi
callq 0x56e0
nop