LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Print.cpp
// Function: Any2Str[abi:cxx11](Any)
string Any2Str(Any val) {
    if (val.anyCast<int>() != NULL) {
        return to_string(*val.anyCast<int>());
    } else if (val.anyCast<char*>() != NULL) {
        return string(*val.anyCast<char*>());
    } else if (val.anyCast<uint32_t>() != NULL) {
        string str = to_string(*val.anyCast<uint32_t>());
        return str.substr(0, 4) + "-" + str.substr(4, 2) + "-" + str.substr(6, 2);
    } else if (val.anyCast<long double>() != NULL) {
        return to_string(*val.anyCast<long double>());
    } else return "NULL";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9410
testq %rax, %rax
je 0x19cfd
movq %r14, %rdi
callq 0x9410
movl (%rax), %esi
movq %rbx, %rdi
callq 0xacb8
jmp 0x19e62
movq %r14, %rdi
callq 0x9398
testq %rax, %rax
je 0x19d27
movq %r14, %rdi
callq 0x9398
movq (%rax), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x84b8
jmp 0x19e62
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
je 0x19e40
movq %r14, %rdi
callq 0x94f8
movl (%rax), %esi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1a4c2
leaq 0x78(%rsp), %rdi
pushq $0x4
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x5410
leaq 0x1e18f(%rip), %rdx     # 0x37ef7
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xaa60
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
pushq $0x4
popq %rdx
pushq $0x2
popq %rcx
callq 0x5410
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xac51
leaq 0x1e147(%rip), %rdx     # 0x37ef7
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xaa60
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
pushq $0x6
popq %rdx
pushq $0x2
popq %rcx
callq 0x5410
leaq 0xd8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0xac51
leaq 0x38(%rsp), %rdi
callq 0x5200
leaq 0xd8(%rsp), %rdi
callq 0x5200
leaq 0xb8(%rsp), %rdi
callq 0x5200
leaq 0x58(%rsp), %rdi
callq 0x5200
leaq 0x98(%rsp), %rdi
callq 0x5200
leaq 0x78(%rsp), %rdi
callq 0x5200
leaq 0x18(%rsp), %rdi
callq 0x5200
jmp 0x19e62
movq %r14, %rdi
callq 0x947e
testq %rax, %rax
je 0x19e70
movq %r14, %rdi
callq 0x947e
fldt (%rax)
fstpt (%rsp)
movq %rbx, %rdi
callq 0x1a501
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
leaq 0x20c56(%rip), %rsi     # 0x3aacd
jmp 0x19d15
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5200
jmp 0x19e8e
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x5200
jmp 0x19ea0
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x5200
jmp 0x19eb2
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5200
jmp 0x19ec1
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x5200
leaq 0x78(%rsp), %rdi
callq 0x5200
leaq 0x18(%rsp), %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x56f0
movq %rax, %rbx
jmp 0x19ece
movq %rax, %rbx
jmp 0x19ed8
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x1d7a9(%rip), %rsi     # 0x37b46
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rdx
callq 0x84b8
pushq $0x20
popq %r13
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
pushq $0x2d
popq %rbp
pushq $0x2b
popq %r12
movslq 0x360b0(%rip), %rax     # 0x50478
cmpq %rax, %rbx
jge 0x1a424
movq 0x3608c(%rip), %rax     # 0x50460
movslq (%rax,%r13), %rsi
addq $0x2, %rsi
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r15, %rdi
movl %ebp, %edx
callq 0x5490
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1a612
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x57d0
movq %r14, %rdi
callq 0x5200
movq %r15, %rdi
callq 0x5200
incq %rbx
addq $0x28, %r13
jmp 0x1a3c1
movq 0x35b8d(%rip), %rdi     # 0x4ffb8
leaq 0x8(%rsp), %rsi
callq 0x5390
movq %rax, %rdi
callq 0x5230
leaq 0x3601c(%rip), %rdi     # 0x50460
callq 0x1a65a
andl $0x0, 0x36028(%rip)     # 0x50478
leaq 0x8(%rsp), %rdi
callq 0x5200
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a489
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5200
jmp 0x1a47d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5200
jmp 0x1a48c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
cmpl $0x0, 0x9fb0(%rsi)
je 0x1a9b0
movl 0x9fa0(%rsi), %edi
cmpl %edi, %ecx
setb %al
popq %rbx
retq
movq %rdi, %rbx
movl %ecx, %eax
xorl %edx, %edx
divl 0x9fac(%rsi)
testl %edx, %edx
jne 0x1a9d6
movq 0x48(%rsi), %rdi
movl 0x9fa4(%rsi), %esi
movl %eax, %edx
callq 0x5c8e
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %ecx
movq (%rbx), %rsi
movl 0x9fa0(%rsi), %edi
cmpl %edi, %ecx
jae 0x1a9a9
movq 0x10(%rbx), %r9
movl 0x9fac(%rsi), %r8d
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
movl %edx, %eax
shrl $0x3, %eax
movzbl (%r9,%rax), %eax
andl $0x7, %edx
btl %edx, %eax
jb 0x1a9a9
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
jmp 0x1a9bd
// File: /workspace/github_cpp_makefile_star2_O2/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), %rbp
cmpl $0x0, 0x9fb0(%rbp)
je 0x1aa86
movl 0x8(%r14), %eax
imulq $0x18, %rax, %rsi
addq 0x9fb8(%rbp), %rsi
movq %rbx, %rdi
callq 0x9158
jmp 0x1ab4a
movl 0x9fac(%rbp), %ecx
leal -0x1(%rcx), %esi
shrl $0x3, %esi
addq 0x10(%r14), %rsi
movl 0x8(%r14), %eax
xorl %r12d, %r12d
xorl %edx, %edx
divl %ecx
imull 0x9fa8(%rbp), %edx
leaq (%rdx,%rsi), %rax
incq %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
andq $0x0, 0x10(%rbx)
movq %rsp, %rax
andq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
pushq $0x58
popq %r13
movl 0x54(%rbp), %eax
cmpq %rax, %r12
jae 0x1ab3b
movq %rbp, %rdi
addq %r13, %rdi
movl 0x24(%rbp,%r13), %r15d
callq 0x17ffa
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movl %r15d, %edx
movl %eax, %ecx
movq %rsp, %r8
callq 0x1ab94
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ab0b
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x1ab0d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8ea0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab2f
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
movq (%r14), %rbp
addq $0x38, %r13
jmp 0x1aacd
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ab4a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab74
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1ab74
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ab83
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x9268
movq %r14, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x9fb0(%rdi)
je 0x1b6e9
leaq 0x9fd0(%rbx), %rdi
callq 0x9268
leaq 0x9fb8(%rbx), %rdi
callq 0x20f30
movl $0x9f08, %r14d          # imm = 0x9F08
leaq (%rbx,%r14), %rdi
callq 0x20bc6
addq $-0x98, %r14
cmpq $0x708, %r14            # imm = 0x708
jne 0x1b694
leaq 0x780(%rbx), %rdi
callq 0x8c8c
leaq 0x760(%rbx), %rdi
callq 0x21c6a
movl $0x700, %r14d           # imm = 0x700
movq 0x50(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x1b6db
movq (%rdi), %rax
callq *0x8(%rax)
addq $-0x38, %r14
jne 0x1b6cb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rbx), %rdi
movl 0x9fa4(%rbx), %esi
callq 0x14678
movq 0x758(%rbx), %rdi
testq %rdi, %rdi
je 0x1b70a
movq (%rdi), %rax
callq *0x10(%rax)
xorl %r14d, %r14d
movl %r14d, %r14d
movq 0x760(%rbx), %rax
movq 0x768(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x1b676
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1b73d
movq (%rdi), %rax
callq *0x10(%rax)
incl %r14d
jmp 0x1b70d
movq %rax, %rdi
callq 0x5e9c
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x9fa0(%rdi)
je 0x1baf4
cmpb $0x1, (%rsi)
jne 0x1bb20
movl 0x54(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x54(%rbx)
imulq $0x38, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0x58, %rdi
callq 0x210aa
movl 0x54(%rbx), %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1d160
xorl %eax, %eax
jmp 0x1bb23
pushq $-0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
cmpq $0x0, (%rsi)
je 0x1bf18
cmpl $0x4, %edx
ja 0x1bf8c
movq %rsi, %r14
movl %edx, %eax
leaq 0x1c018(%rip), %rcx     # 0x37f14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x9410
jmp 0x1bf57
movq (%rbx), %rax
movb $-0x1, (%rax)
incq (%rbx)
subl $0x1, %ebp
jae 0x1bf0f
jmp 0x1bf91
movq %r14, %rdi
callq 0x947e
fldt (%rax)
movq (%rbx), %rax
fstpt (%rax)
jmp 0x1bf8c
movq 0x38(%rdi), %r15
movq %r14, %rdi
callq 0x9398
movq (%rax), %rsi
movq %r15, %rdi
callq 0x6974
movq (%rbx), %rcx
movq %rax, (%rcx)
jmp 0x1bf8c
movq %r14, %rdi
callq 0x94f8
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
jmp 0x1bf8c
movq (%rbx), %r15
movq %r14, %rdi
callq 0x9398
movq (%rax), %r12
movq %r14, %rdi
callq 0x9398
movq (%rax), %rdi
callq 0x51e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5350
movl %ebp, %eax
addq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rsi, %rbx
movq (%rsi), %rax
movl %r9d, %r15d
leaq (%rax,%r15), %rsi
movq %rsi, (%rbx)
addq %r15, %rax
incq %rax
movl %ecx, %r8d
subl $0x1, %r8d
jb 0x1bfd3
cmpb $-0x1, -0x1(%rax)
jne 0x1bfdc
movq %rax, (%rbx)
incq %rax
jmp 0x1bfbf
movq %rsi, (%rbx)
andq $0x0, (%r14)
jmp 0x1c039
movq %rsi, (%rbx)
cmpl $0x4, %edx
ja 0x1c039
movl %edx, %eax
leaq 0x1bf3b(%rip), %rdx     # 0x37f28
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x20f70
jmp 0x1c039
movq %r14, %rdi
callq 0x21006
jmp 0x1c039
movq 0x38(%rdi), %rdi
movq (%rsi), %rsi
callq 0x68b8
jmp 0x1c029
movq %r14, %rdi
callq 0x20fd4
jmp 0x1c039
movl %ecx, %edx
callq 0x1bea0
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x20fa2
subq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x58(%rdi), %rcx
xorl %edx, %edx
pushq $-0x1
popq %rbp
cmpq %rdx, %rax
je 0x1c258
cmpb $0x0, (%rcx)
jne 0x1c24f
cmpq $0x0, (%rbx,%rdx,8)
je 0x1c2a8
incq %rdx
addq $0x38, %rcx
jmp 0x1c23e
movq 0x758(%r14), %rdx
testq %rdx, %rdx
je 0x1c278
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ed86
testl %eax, %eax
je 0x1c278
pushq $-0x3
popq %rbp
jmp 0x1c2a8
movq 0x760(%r14), %r15
movq 0x768(%r14), %r12
pushq $-0x4
popq %rbp
cmpq %r12, %r15
je 0x1c2a6
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ed86
addq $0x8, %r15
testl %eax, %eax
je 0x1c289
jmp 0x1c2a8
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movl 0x9fa4(%r14), %esi
movl %ebp, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
movl %eax, %edx
callq 0x5c8e
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 0x1cc3c
decl %esi
shrl $0x3, %esi
addq %rsi, %rcx
imull 0x9fa8(%r14), %edx
leaq (%rdx,%rcx), %rax
incq %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movl 0x54(%r14), %ebp
leaq (,%rbp,8), %r13
leaq 0x8(,%rbp,8), %rdi
callq 0x5040
movq %rbp, (%rax)
leaq 0x8(%rax), %rdi
movq %rdi, (%rbx)
xorl %esi, %esi
movq %r13, %rdx
callq 0x5270
leaq 0x58(%r14), %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movl %ebp, %eax
cmpq %rax, %r15
jae 0x1cc38
movl 0x24(%r13), %ebp
movq %r13, %rdi
callq 0x17ffa
movq (%rbx), %r8
addq %r12, %r8
movq %r14, %rdi
movq %rsp, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x1ab94
incq %r15
movl 0x54(%r14), %ebp
addq $0x38, %r13
addq $0x8, %r12
jmp 0x1cbff
xorl %eax, %eax
jmp 0x1cc3f
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1cc95
movslq %ebp, %rax
imulq $0x18, %rax, %rsi
addq 0x9fb8(%r14), %rsi
movq %rbx, %rdi
callq 0x9158
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x48(%r14), %rdi
movl 0x9fa4(%r14), %esi
movl %ebp, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
movl %eax, %edx
callq 0x5c8e
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 0x1cc83
decl %esi
shrl $0x3, %esi
addq %rsi, %rcx
imull 0x9fa8(%r14), %edx
leaq (%rdx,%rcx), %rax
incq %rax
leaq 0x10(%rsp), %rcx
movq %rsp, %rdx
andq $0x0, (%rdx)
movq %rax, (%rcx)
leaq 0x58(%r14), %r13
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbp
movl 0x54(%r14), %eax
cmpq %rax, %r12
jae 0x1cd78
movl 0x24(%r13), %r15d
movq %r13, %rdi
callq 0x17ffa
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movl %r15d, %edx
movl %eax, %ecx
movq %rsp, %r8
callq 0x1ab94
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1cd4d
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x1cd4f
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x8ea0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd6f
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
addq $0x38, %r13
jmp 0x1cd12
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1cc83
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1cc83
movq %rax, %r14
jmp 0x1cdbc
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cdad
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1cdad
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1cdbc
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x9268
movq %r14, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7a8(%rdi), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movl 0x798(%r15), %eax
cmpq %rax, %rbp
jae 0x1d11b
movq %r13, %rdi
movq %r12, %rsi
leaq 0x7(%rsp), %rdx
callq 0x84b8
movq %r14, %rdi
movq %r13, %rsi
callq 0x85c0
movl %eax, %ebx
movq %r13, %rdi
callq 0x5200
testb %bl, %bl
jne 0x1d120
incq %rbp
addq $0x98, %r12
jmp 0x1d0da
pushq $-0x1
popq %rax
jmp 0x1d122
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x58, %rbx
movl %esi, %r14d
xorl %ebp, %ebp
subq $0x1, %r14
jb 0x1d158
movq %rbx, %rdi
callq 0x17ffa
addl %eax, %ebp
addq $0x38, %rbx
jmp 0x1d142
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Table.cpp
// Function: Table::removeColumn(unsigned int)
int Table::removeColumn(uint col_id) {
    // if (col_ty[col_id].key == Primary) {
    //     printf("Need to remove primary key \"%s\" first.", p_key->name.c_str());
    //     return -1;
    // }
    // for (auto it: f_key) for (auto _i: it->v) if (_i == col_id) {
    //     printf("Need to remove foreign key \"%s\" first.", it->name.c_str());
    //     return -2;
    // }
    // for (uint i = 0; i < index_num; i++) for (auto _i: index[i].key) if (_i == col_id) {
    //     printf("Need to remove index \"%s\" first.", index[i].name);
    //     return -3;
    // }
    rebuild(0, col_id);
    for (uint i = col_id; i < col_num - 1; i++) col_ty[i] = col_ty[i + 1];
    col_num -= 1;

    if (p_key) {
        for (auto it = p_key->v.begin(); it != p_key->v.end(); it++) if (*it == col_id) {
            removePrimaryKey();
            break;
        } else if (*it > col_id) *it -= 1;
    }
    if (f_key.size()) for (uint i = 0; i < f_key.size(); i++) {
        for (auto it = f_key[i]->v.begin(); it != f_key[i]->v.end(); it++) if (*it == col_id) {
            removeForeignKey(f_key[i--]);
            break;
        } else if (*it > col_id) *it -= 1;
    }
    for (uint i = 0; i < index_num; i++) {
        for (auto it = index[i].key.begin(); it != index[i].key.end(); it++) if (*it == col_id) {
            removeIndex(i--);
            break;
        } else if (*it > col_id) *it -= 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
movl %ebx, %edx
callq 0x1d160
movl %ebx, %r12d
imulq $0x38, %r12, %rax
leaq (%rax,%r14), %rdi
addq $0x58, %rdi
movl 0x54(%r14), %eax
decl %eax
cmpq %rax, %r12
jae 0x1d688
incq %r12
leaq 0x38(%rdi), %r15
movq %r15, %rsi
callq 0x210aa
movq %r15, %rdi
jmp 0x1d669
movl %eax, 0x54(%r14)
movq 0x758(%r14), %rcx
testq %rcx, %rcx
je 0x1d6bf
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
cmpq %rcx, %rax
je 0x1d6bf
movl (%rax), %edx
cmpl %ebx, %edx
je 0x1d6b7
jbe 0x1d6b1
decl %edx
movl %edx, (%rax)
addq $0x4, %rax
jmp 0x1d6a0
movq %r14, %rdi
callq 0x1d784
movq 0x760(%r14), %rax
movq 0x768(%r14), %rcx
cmpq %rax, %rcx
je 0x1d725
xorl %ebp, %ebp
subq %rax, %rcx
sarq $0x3, %rcx
movl %ebp, %edx
cmpq %rdx, %rcx
jbe 0x1d725
movq (%rax,%rdx,8), %rsi
movq 0x30(%rsi), %rdx
movq 0x38(%rsi), %rdi
cmpq %rdi, %rdx
je 0x1d709
movl (%rdx), %r8d
cmpl %ebx, %r8d
je 0x1d70d
jbe 0x1d703
decl %r8d
movl %r8d, (%rdx)
addq $0x4, %rdx
jmp 0x1d6ee
incl %ebp
jmp 0x1d6db
movq %r14, %rdi
callq 0x1d804
movq 0x760(%r14), %rax
movq 0x768(%r14), %rcx
jmp 0x1d6d4
leaq 0x7a0(%r14), %r15
xorl %ebp, %ebp
movl %ebp, %eax
imulq $0x98, %rax, %rax
leaq (%r15,%rax), %r12
addq $0x30, %r12
cmpl 0x798(%r14), %ebp
jae 0x1d778
movq (%r12), %rax
movq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x1d774
movl (%rax), %edx
cmpl %ebx, %edx
je 0x1d768
jbe 0x1d762
decl %edx
movl %edx, (%rax)
addq $0x4, %rax
jmp 0x1d751
movq %r14, %rdi
movl %ebp, %esi
callq 0x1bbb4
jmp 0x1d73f
incl %ebp
jmp 0x1d72e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d800
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rax), %rcx
movq 0x58(%rax), %rdx
cmpq %rdx, %rcx
je 0x1d7af
movq (%rcx), %rsi
andq $0x0, 0x50(%rsi)
addq $0x8, %rcx
jmp 0x1d79c
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rax
leaq 0x58(%rbx), %rdx
cmpq %rax, %rcx
je 0x1d7d4
movl (%rcx), %esi
imulq $0x38, %rsi, %rsi
movl $0x2, 0x2c(%rdx,%rsi)
addq $0x4, %rcx
jmp 0x1d7bb
movl 0x778(%rbx), %esi
movq %rbx, %rdi
callq 0x1bbb4
movq 0x758(%rbx), %rdi
testq %rdi, %rdi
je 0x1d7f4
movq (%rdi), %rax
callq *0x10(%rax)
andq $0x0, 0x758(%rbx)
xorl %eax, %eax
popq %rbx
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Table.cpp
// Function: Table::removeForeignKey(ForeignKey*)
int Table::removeForeignKey(ForeignKey* fk) {
    int i = 0;
    for (auto it = f_key.begin(); it != f_key.end(); it++){
        if (*it == fk) { 
            for (auto _it = fk->p->f.begin(); _it != fk->p->f.end(); _it++) if (*_it == fk) {
                removeIndex(f_key_index[i]);
                f_key_index.erase(f_key_index.begin()+i);
                f_key.erase(it);
                updateColumns();
                fk->p->f.erase(_it);
                delete fk;
                return 0;
            }
            return -1;
        }
        i ++;
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x760(%rdi), %rdx
movq 0x760(%rdi), %r12
movq 0x768(%rdi), %rcx
xorl %ebp, %ebp
pushq $-0x1
popq %rax
cmpq %rcx, %r12
je 0x1d8d7
cmpq %rbx, (%r12)
je 0x1d84b
addq $0x8, %r12
addq $0x4, %rbp
jmp 0x1d832
movq 0x50(%rbx), %rax
movq 0x50(%rax), %r13
movq 0x58(%rax), %r15
cmpq %r15, %r13
je 0x1d8cd
cmpq %rbx, (%r13)
je 0x1d868
addq $0x8, %r13
jmp 0x1d857
leaq 0x780(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x780(%r14), %rax
movl (%rax,%rbp), %esi
movq %rdx, 0x10(%rsp)
movq %r14, %rdi
callq 0x1bbb4
addq 0x780(%r14), %rbp
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x18146
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x210fe
movq %r14, %rdi
callq 0x1bb26
movq 0x50(%rbx), %rdi
addq $0x50, %rdi
movq %r13, %rsi
callq 0x210fe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
xorl %eax, %eax
cmpq %r15, %r13
sete %al
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
imulq $0x38, %rax, %rax
leaq (%rdi,%rax), %rbx
addq $0x58, %rbx
movl 0x24(%rbx), %eax
cmpl $0x4, %eax
ja 0x1d938
pushq $0x19
popq %rcx
btl %eax, %ecx
jae 0x1d920
cmpl %eax, 0x24(%r15)
jne 0x1d965
jmp 0x1d938
movl 0x24(%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x1d965
movb 0x28(%rbx), %al
cmpb 0x28(%r15), %al
jbe 0x1d938
pushq $-0x2
jmp 0x1d967
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1d96a
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r12
jmp 0x1d96d
pushq $-0x1
popq %rbx
jmp 0x1d9b8
xorl %r12d, %r12d
movq %r12, 0x30(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x210aa
movl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0x1d9e2
testl %eax, %eax
je 0x1d9a7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x210aa
pushq $-0x3
popq %rbx
movq 0x30(%rsp), %r12
jmp 0x1d9a9
xorl %ebx, %ebx
testq %r12, %r12
je 0x1d9b8
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9da
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1da3e
leaq 0x18(%rsp), %r14
movq %rdi, (%r14)
orl $-0x1, 0x8(%r14)
movq %rsp, %r15
movq %r14, %rdi
callq 0x1a98e
testb %al, %al
je 0x1da3e
movq %r15, %rdi
movq %r14, %rsi
callq 0x1aa4a
movq (%rsp), %rax
movq (%rax,%r12,8), %r13
movq %r15, %rdi
callq 0x9268
testq %r13, %r13
jne 0x1da0f
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x758(%rdi)
je 0x1da69
pushq $-0x1
jmp 0x1da7a
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1dbd4
testl %eax, %eax
je 0x1da89
pushq $-0x2
popq %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x68
popq %rdi
callq 0x53e0
leaq 0x10(%rax), %rdi
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movb $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movq %rbx, 0x48(%rax)
leaq 0x32223(%rip), %rcx     # 0x4fce0
movq %rcx, (%rax)
movups %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %rax, 0x758(%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
leaq 0x10(%r14), %rsi
callq 0x5260
movq 0x758(%rbx), %rax
movq 0x30(%rax), %rcx
cmpq %rcx, 0x38(%rax)
je 0x1daf5
movq %rcx, 0x38(%rax)
movq 0x30(%r14), %r12
movq 0x38(%r14), %r13
leaq 0x4(%rsp), %r15
cmpq %r13, %r12
je 0x1db28
movl (%r12), %eax
movl %eax, 0x4(%rsp)
movq 0x758(%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x17fbe
addq $0x4, %r12
jmp 0x1db02
movq 0x48(%r14), %rax
movq 0x758(%rbx), %rcx
movq %rax, 0x48(%rcx)
movq %rbx, %rdi
callq 0x1bb26
movl 0x778(%rbx), %esi
cmpl $-0x1, %esi
je 0x1db52
movq %rbx, %rdi
callq 0x1bbb4
movq 0x758(%rbx), %rsi
addq $0x30, %rsi
leaq 0x8(%rsp), %rdi
callq 0x17f70
leaq 0x1a4c5(%rip), %rsi     # 0x38033
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x84b8
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x1bc0e
movl %eax, 0x778(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x5200
leaq 0x8(%rsp), %rdi
callq 0x18566
xorl %eax, %eax
jmp 0x1da7b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5200
jmp 0x1dbc2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18566
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Table.cpp
// Function: Table::print()
void Table::print() {
    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);
    if (sel == 1) {
        for (auto it: data) {
            Print::row(it);
        }
    } else if (sel == 2) {
        Print::row(val);
    } else {
        Pointer p(this);
        while (p.next()) Print::row(p.get());
    }
    Print::end();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x5a(%rdi), %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x60(%rsp), %r12
movl 0x54(%rbx), %eax
cmpq %rax, %r13
jae 0x1e35d
leaq -0x2(%r15), %rdi
callq 0x21138
movl %eax, %ebp
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x51e0
movl %eax, 0x8(%rsp)
movq %r14, %rdx
cmpl %eax, %ebp
jl 0x1e334
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x21168
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x140da
movq %r12, %rdi
callq 0x5200
incq %r13
addq $0x38, %r15
jmp 0x1e305
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8516
leaq 0x48(%rsp), %rdi
callq 0x19ef4
leaq 0x48(%rsp), %rdi
callq 0x8570
movl 0x9fb0(%rbx), %eax
cmpl $0x2, %eax
je 0x1e3e8
cmpl $0x1, %eax
jne 0x1e431
movq 0x9fb8(%rbx), %r14
movq 0x9fc0(%rbx), %r12
leaq 0x60(%rsp), %rbx
leaq 0xa0(%rsp), %r15
cmpq %r12, %r14
je 0x1e410
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9158
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9158
movq %r15, %rdi
callq 0x1a1e4
movq %r15, %rdi
callq 0x9268
movq %rbx, %rdi
callq 0x9268
addq $0x18, %r14
jmp 0x1e3af
addq $0x9fd0, %rbx           # imm = 0x9FD0
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x9158
leaq 0x30(%rsp), %rdi
callq 0x1a1e4
leaq 0x30(%rsp), %rdi
callq 0x9268
callq 0x1a388
leaq 0x10(%rsp), %rdi
callq 0x8570
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60(%rsp), %r14
movq %rbx, (%r14)
orl $-0x1, 0x8(%r14)
leaq 0x88(%rsp), %rbx
movq %r14, %rdi
callq 0x1a98e
testb %al, %al
je 0x1e410
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa4a
movq %rbx, %rdi
callq 0x1a1e4
movq %rbx, %rdi
callq 0x9268
jmp 0x1e446
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x1e4b3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8570
jmp 0x1e4d0
jmp 0x1e4cd
jmp 0x1e4cd
movq %rax, %rbx
jmp 0x1e4ae
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x1e4b3
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x9268
leaq 0x60(%rsp), %rdi
callq 0x9268
jmp 0x1e4d0
jmp 0x1e4cd
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5200
jmp 0x1e4d0
jmp 0x1e4cd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8570
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ecbc
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movb %al, 0x3(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x5a(%rdi), %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x60(%rsp), %r13
movl 0x54(%r14), %eax
cmpq %rax, %rbx
jae 0x1ec37
leaq -0x2(%r12), %rdi
callq 0x21138
movl %eax, %ebp
movl %eax, 0xc(%rsp)
movq %r12, %rdi
callq 0x51e0
movl %eax, 0x8(%rsp)
movq %r15, %rdx
cmpl %eax, %ebp
jl 0x1ec0e
leaq 0xc(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x21168
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x140da
movq %r13, %rdi
callq 0x5200
incq %rbx
addq $0x38, %r12
jmp 0x1ebdd
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8516
leaq 0x30(%rsp), %rdi
callq 0x19ef4
leaq 0x30(%rsp), %rdi
callq 0x8570
movl 0x9fa0(%r14), %eax
movl %eax, %ebx
subl 0x4(%rsp), %ebx
imulq $0x18, %rbx, %r12
leaq 0x48(%rsp), %r15
movl %eax, %eax
cmpq %rax, %rbx
jae 0x1eca9
movq 0x9fb8(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x9158
movq %r15, %rdi
callq 0x1a1e4
movq %r15, %rdi
callq 0x9268
incq %rbx
movl 0x9fa0(%r14), %eax
addq $0x18, %r12
jmp 0x1ec70
callq 0x1a388
leaq 0x10(%rsp), %rdi
callq 0x8570
movb 0x3(%rsp), %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8570
jmp 0x1ed04
jmp 0x1ed01
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x9268
jmp 0x1ed04
jmp 0x1ed01
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5200
jmp 0x1ed04
jmp 0x1ed01
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8570
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x5, %ecx
ja 0x1f1af
movl %ecx, %eax
leaq 0x18dec(%rip), %rcx     # 0x37f50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x85ea
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x866e
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x865a
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8664
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8650
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8700
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x20(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x68(%rsp), %rax
movq %rdi, (%rax)
orl $-0x1, 0x8(%rax)
movl %r8d, 0x10(%rsp)
movl %r8d, %r13d
xorb $0x1, %r13b
leaq 0x80(%rsp), %rbp
leaq 0x50(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a98e
testb %al, %al
je 0x1f288
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1aa4a
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x19190
movq %rbp, %rdi
callq 0x9268
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x9158
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9158
movq %r14, %rsi
movq %r15, %rdx
movl 0x14(%rsp), %ecx
callq 0x1f156
movl %eax, %ebx
movq %r15, %rdi
callq 0x9268
movq %r14, %rdi
callq 0x9268
movl %ebx, %r12d
andb 0xc(%rsp), %r12b
orb %r13b, %bl
cmpb %bl, %r12b
jne 0x1f20a
jmp 0x1f295
movl 0xc(%rsp), %eax
notb %al
andb 0x10(%rsp), %al
movl %eax, %r12d
leaq 0x20(%rsp), %rdi
callq 0x9268
movl %r12d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1f2c6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x9268
leaq 0x50(%rsp), %rdi
callq 0x9268
jmp 0x1f2d7
jmp 0x1f2d4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9268
movq %rbx, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
leaq 0x4(%rsp), %r15
movl %ecx, 0x4(%rsp)
cmpl 0x9fa0(%r14), %ecx
jae 0x1f769
movl %ecx, %eax
xorl %edx, %edx
divl 0x9fac(%r14)
testl %edx, %edx
jne 0x1f744
movq 0x48(%r14), %rdi
movl 0x9fa4(%r14), %esi
movl %eax, %edx
callq 0x5c8e
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 0x1f765
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17fbe
movl 0x4(%rsp), %ecx
incl %ecx
jmp 0x1f704
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x18566
movq %r14, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Table.cpp
// Function: Table::removeRecords(std::vector<WhereStmt, std::allocator<WhereStmt>>&)
int Table::removeRecords(vector<WhereStmt> &where) {
    vector<uint> cols = findWheres(where);
    for (auto i: cols) {
        Pointer p(this, i);
        if (checkWheres(p.get(), where)) {
            removeRecord(i);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rdx, 0x8(%rsp)
callq 0x1f78c
movq (%r15), %rbx
movq 0x8(%r15), %r15
leaq 0x28(%rsp), %r12
cmpq %r15, %rbx
je 0x1faa0
movl (%rbx), %ebp
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1aa18
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
callq 0x1aa4a
movq %r14, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x1f634
movl %eax, %r13d
movq %r12, %rdi
callq 0x9268
testb %r13b, %r13b
je 0x1fa9a
movq %r14, %rdi
movl %ebp, %esi
callq 0x1c2b4
addq $0x4, %rbx
jmp 0x1fa4d
leaq 0x10(%rsp), %rdi
callq 0x18566
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9268
jmp 0x1facd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x18566
movq %rbx, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/./Type.h
// Function: Type::toJson[abi:cxx11]()
json toJson() {
        json j;
        j["name"] = name;
        j["ty"] = ty;
        j["char_len"] = char_len;
        j["key"] = key;
        j["null"] = null;
        if (def.anyCast<int>() != nullptr) {
            j["def"] = def.anyRefCast<int>();
        } else if (def.anyCast<char*>() != nullptr) {
            j["def"] = def.anyRefCast<char*>();
        }
        return j;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x7c48
leaq 0x2(%r14), %rsi
leaq 0x40(%rsp), %rdi
callq 0x7c64
leaq 0x1765b(%rip), %rsi     # 0x3802e
movq %rbx, %rdi
callq 0x7c7e
leaq 0x40(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
leaq 0x24(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x17f56
leaq 0x175c5(%rip), %rsi     # 0x37fcd
movq %rbx, %rdi
callq 0x7c7e
leaq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
leaq 0x28(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x212ba
leaq 0x17644(%rip), %rsi     # 0x38081
movq %rbx, %rdi
callq 0x7c7e
leaq 0x20(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
leaq 0x2c(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x212d4
leaq 0x14f17(%rip), %rsi     # 0x35989
movq %rbx, %rdi
callq 0x7c7e
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x122fe
leaq 0x12e8b(%rip), %rsi     # 0x3392f
movq %rbx, %rdi
callq 0x7c7e
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
addq $0x30, %r14
movq %r14, %rdi
callq 0x9410
testq %rax, %rax
je 0x20afc
movq %r14, %rdi
callq 0x8b08
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x20bac
leaq 0x17598(%rip), %rsi     # 0x3808a
movq %rbx, %rdi
callq 0x7c7e
jmp 0x20b30
movq %r14, %rdi
callq 0x9398
testq %rax, %rax
je 0x20b43
movq %r14, %rdi
callq 0x212ee
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21318
leaq 0x17562(%rip), %rsi     # 0x3808a
movq %rbx, %rdi
callq 0x7c7e
movq %rax, %rdi
movq %r14, %rsi
callq 0x7da0
movq %r14, %rdi
callq 0x7de0
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
jmp 0x20b92
movq %rax, %r14
leaq 0x60(%rsp), %rdi
jmp 0x20b92
movq %rax, %r14
movq %rsp, %rdi
jmp 0x20b92
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x20b92
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x20b92
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x20b92
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x7de0
jmp 0x20b9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7de0
movq %r14, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/./Any.h
// Function: Any& Any::operator=<int>(int const&)
Any &operator=(const ValueType &value)
    {
        Any tmp(value);
        if (_pValue)
            delete _pValue;
        _pValue = tmp._pValue;
        tmp._pValue = nullptr;
        return *this;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8948
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20f90
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/./Key.h
// Function: Key::operator==(Key const&)
bool operator==(const Key& b) {
        if (v_size != b.size()) return false;
        for (uint i = 0; i < v_size; i++) {
            if (v[i] != b[i]) return false;
        }
        return true;
    }

// Assembly:
movl 0x8(%rdi), %ecx
xorl %edx, %edx
movl $0x0, %eax
cmpl 0x8(%rsi), %ecx
jne 0x21ab4
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
cmpl %edx, %ecx
sete %al
je 0x21ab4
movl %edx, %r8d
movl (%rdi,%r8,4), %r8d
movslq %edx, %r9
incl %edx
cmpl (%rsi,%r9,4), %r8d
je 0x21a9b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/main.cpp
// Function: copyStr(char const*)
inline char* copyStr(const char* _str) {
    uint size = strlen(_str);
    char* str = new char[size + 1];
    strcpy(str, _str);
    str[size] = '\0';
    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x51e0
movq %rax, %r14
leal 0x1(%rax), %edi
callq 0x5040
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53b0
movl %r14d, %eax
movb $0x0, (%r15,%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/ssr.cpp
// Function: main
int main()
{
	SSR ssr1();
	SSR ssr2("ACGT", 4, 32);

	//cout << ssr2.toString() << endl;

	cout << "\n\033[0;34mSSR Test: ";

	bool pass = true;

	if (pass)
	{
		cout << "\033[0;32mOK\033[0m" << endl;
	}
	else
	{
		cout << "\033[0;31mFAIL\033[0m" << endl;
	}

	return 0;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
leaq 0xc4c(%rip), %rsi       # 0x3004
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2452
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
pushq $0x20
popq %rcx
callq 0x253a
leaq 0x8(%rsp), %rdi
callq 0x2090
movq 0x2beb(%rip), %rdi      # 0x4fd8
leaq 0xc15(%rip), %rsi       # 0x3009
callq 0x2150
movq 0x2bd8(%rip), %rdi      # 0x4fd8
leaq 0xc15(%rip), %rsi       # 0x301c
callq 0x2150
movq %rax, %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x257a
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x243c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
jmp 0x2449
movq %rax, %rbx
jmp 0x2449
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x257a
movq %rbx, %rdi
callq 0x2210
nop