LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/./CatalogManager.h
// Function: IndexTableManager::IndexTableManager()
IndexTableManager()
    {
        std::ifstream fin("index.catalog");
        mp.clear();
        if (!fin) return;
        std::string indexName, tableName;
        int attrIndex;
        while (fin >> indexName >> tableName >> attrIndex) {
            mp[indexName] = make_pair(tableName, attrIndex);
        }
        fin.close();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0xb1ec(%rip), %rsi      # 0x11214
leaq -0x2a0(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3490
movq %rbx, %rdi
callq 0x6210
movq -0x2a0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x280(%rbp,%rax)
jne 0x610d
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq -0x98(%rbp), %r14
leaq -0x2a0(%rbp), %rdi
movq %r15, %rsi
callq 0x3330
movq %rax, %rdi
movq %r12, %rsi
callq 0x3330
movq %rax, %rdi
movq %r13, %rsi
callq 0x3180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x60ef
movq %r14, %rdi
movq %r12, %rsi
callq 0x3380
movl -0x2c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6176
movq %rax, %rdi
movq %r14, %rsi
callq 0x61e0
movq %r14, %rdi
callq 0x34f8
jmp 0x608b
leaq -0x2a0(%rbp), %rdi
callq 0x3080
leaq -0x50(%rbp), %rdi
callq 0x34f8
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x2a0(%rbp), %rdi
callq 0x30a0
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6145
movq %rax, %r14
jmp 0x6166
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x34f8
jmp 0x6148
jmp 0x6145
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x34f8
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x2a0(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x66f0
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/./CatalogManager.h
// Function: IndexTableManager::~IndexTableManager()
~IndexTableManager()
    {
        std::ofstream fout("index.catalog");
        for (auto &x : mp) {
            fout << x.first << " " << x.second.first << " " << x.second.second << std::endl;
        }
        fout.close();
        mp.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0xaaee(%rip), %rsi      # 0x11214
leaq -0x228(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x32d0
movq 0x18(%rbx), %r12
leaq 0x8(%rbx), %r13
leaq -0x228(%rbp), %r14
leaq 0xaea2(%rip), %r15      # 0x115ed
cmpq %r13, %r12
je 0x67a2
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x3250
movq %rax, %rdi
movq %r15, %rsi
callq 0x3280
leaq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
movq %r15, %rsi
callq 0x3280
movl 0x60(%r12), %esi
movq %rax, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x31c0
movq %rax, %r12
jmp 0x674b
leaq -0x228(%rbp), %rdi
callq 0x3390
movq %rbx, %rdi
callq 0x6210
leaq -0x228(%rbp), %rdi
callq 0x33b0
movq %rbx, %rdi
callq 0x66f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67de
movq %rax, %rdi
callq 0x6201
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/bufferManager.cpp
// Function: BFM::BufferManagerWrite(Block const&)
void BFM::BufferManagerWrite(const Block &b)
{
    FILE *fp = fopen(b.fileName.c_str(), "rb");
    FILE *outFile;
    if (fp==NULL){
        outFile = fopen(b.fileName.c_str(), "wb");
    }
    else{
        fclose(fp);
        outFile = fopen(b.fileName.c_str(), "rb+");
    }
    if(outFile==NULL){
        cerr<<"ERROR: Open file "<<b.fileName<<" failed.\n";
        return;
    }
    fseek(outFile, b.offset, SEEK_SET);
    fwrite(&b.data, 1, BLOCKSIZE, outFile);
    fclose(outFile);

    tag T = make_pair(b.fileName, b.offset);
    tableIter tmp = table.find(T);
    if (tmp!=table.end()){ //in the buffer, which means not new written
        bufferIter victim = tmp->second;
        table.erase(table.find(T)); //remove from table
        buffer.erase(victim); //remove from buffer
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
leaq 0x1000(%rsi), %rbx
movq 0x1000(%rsi), %rdi
leaq 0x95bc(%rip), %rsi      # 0x1126d
callq 0x3300
testq %rax, %rax
je 0x7ccc
movq %rax, %rdi
callq 0x3290
leaq 0x95c5(%rip), %rsi      # 0x1128f
jmp 0x7cd3
leaq 0x95b9(%rip), %rsi      # 0x1128c
movq (%rbx), %rdi
callq 0x3300
testq %rax, %rax
je 0x7d8f
movq %rax, %r15
leaq 0x1020(%r14), %r12
movq 0x1020(%r14), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x32e0
pushq $0x1
popq %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %r15, %rcx
callq 0x34d0
movq %r15, %rdi
callq 0x3290
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x80fa
leaq 0x1156d(%rip), %rdi     # 0x192a0
movq %r14, %rsi
callq 0x8118
leaq 0x11566(%rip), %rcx     # 0x192a8
cmpq %rcx, %rax
je 0x7d79
movq 0x48(%rax), %rbx
leaq 0x1154e(%rip), %rdi     # 0x192a0
leaq -0x48(%rbp), %rsi
callq 0x8118
leaq 0x1153e(%rip), %rdi     # 0x192a0
movq %rax, %rsi
callq 0x8534
leaq 0x1155f(%rip), %rdi     # 0x192d0
movq %rbx, %rsi
callq 0x7f9e
leaq -0x48(%rbp), %rdi
callq 0x34f8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x1125a(%rip), %rdi     # 0x18ff0
leaq 0x94d3(%rip), %rsi      # 0x11270
callq 0x3280
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3250
leaq 0x94ce(%rip), %rsi      # 0x11282
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3280
jmp 0x7dca
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/bufferManager.cpp
// Function: BFM::BufferManagerFlush()
void BFM::BufferManagerFlush()
{
    for (bufferIter T = buffer.begin(); T!=buffer.end();){
        BufferManagerWrite(*T++);
    }
    buffer.clear();
    table.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x114c8(%rip), %rsi     # 0x192d0
leaq 0x114c1(%rip), %rbx     # 0x192d0
cmpq %rbx, %rsi
je 0x7e25
movq (%rsi), %r14
addq $0x10, %rsi
callq 0x7c8a
movq %r14, %rsi
jmp 0x7e0f
leaq 0x114a4(%rip), %rdi     # 0x192d0
callq 0x7fc6
leaq 0x11468(%rip), %rdi     # 0x192a0
popq %rbx
popq %r14
popq %rbp
jmp 0x8596
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/bufferManager.cpp
// Function: BFM::deleteFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BFM::deleteFile(const string &fileName)
{
    tableIter tIt = table.lower_bound(make_pair(fileName,0));
    for (; tIt!=table.end() && tIt->first.first==fileName; ){
        BufferManagerWrite(*(tIt++->second));
    }
    cout << remove(fileName.c_str()) << " " <<fileName<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x3380
andl $0x0, 0x20(%r14)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7fe8
leaq 0x11425(%rip), %rdi     # 0x192a0
movq %r15, %rsi
callq 0x85ce
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x48(%rbp), %rdi
callq 0x34f8
leaq 0x11409(%rip), %r12     # 0x192a8
cmpq %r12, %r14
je 0x7ed1
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x5db5
testb %al, %al
je 0x7ed1
movq %r14, %rdi
callq 0x31c0
movq %rax, %r15
movq 0x48(%r14), %rsi
addq $0x10, %rsi
callq 0x7c8a
movq %r15, %r14
jmp 0x7e9f
movq (%rbx), %rdi
callq 0x3470
movq 0x110e8(%rip), %rdi     # 0x18fc8
movl %eax, %esi
callq 0x3440
leaq 0x96ff(%rip), %rsi      # 0x115ed
movq %rax, %rdi
callq 0x3280
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3120
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x48(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: isFileExist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isFileExist(const string &fileName) {
    ifstream f(fileName.c_str());
    if (f.good()) {
        f.close();
        return true;
    } else {
        f.close();
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq (%rdi), %rsi
leaq -0x218(%rbp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3490
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl -0x1f8(%rbp,%rax), %r14d
movq %rbx, %rdi
callq 0x3080
testl %r14d, %r14d
sete %bl
leaq -0x218(%rbp), %rdi
callq 0x30a0
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: writeContent(_IO_FILE*, long, void const*, int)
void writeContent(FILE *file, long offset, const void *p, int n) {
    if (!fseek(file, offset, SEEK_SET)) {
        if (fwrite((const void *)p, sizeof(char), n, file) != n) {
            throw "bad write -- indexManager.writeContent";
        }
    } else {
        throw "bad seek -- indexManager.writeContent";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x32e0
testl %eax, %eax
jne 0x8697
movslq %r15d, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x34d0
cmpq %r15, %rax
jne 0x86a8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x3130
leaq 0x8c29(%rip), %rcx      # 0x112cf
jmp 0x86b7
pushq $0x8
popq %rdi
callq 0x3130
leaq 0x8bf1(%rip), %rcx      # 0x112a8
movq %rcx, (%rax)
movq 0x108f7(%rip), %rsi     # 0x18fb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: badRes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response badRes(const string &info) {
    Response res;
    res.succeed = false;
    res.info = info;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfdbe
movb $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3150
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e02
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: build(std::vector<std::pair<element, long>, std::allocator<std::pair<element, long>>> const&)
map <element, long> build(const vector < pair <element, long> > &v) {
    map <element, long> mp;
    for (auto o : v) 
        mp[o.first] = o.second;
    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r13
leaq -0x60(%rbp), %r12
cmpq %r13, %r15
je 0x8b03
movq %r12, %rdi
movq %r15, %rsi
callq 0xa18e
movq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa1ae
movq %r14, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x34f8
addq $0x38, %r15
jmp 0x8ad2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x8b26
movq %rax, %r15
leaq -0x58(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0xa5c6
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: BT::newNode()
BTNode newNode() {
        FILE *file = fopen(name.c_str(), "rb");
        fseek(file, 0, SEEK_END);
        long off = ftell(file);
        fclose(file);
        BTNode res;
        res.offset = off;
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x107d6(%rip), %rdi     # 0x19320
leaq 0x871c(%rip), %rsi      # 0x1126d
callq 0x3300
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x32e0
movq %r14, %rdi
callq 0x3030
movq %rax, %r15
movq %r14, %rdi
callq 0x3290
movq %rbx, %rdi
callq 0xa130
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: BT::setRoot(long)
void setRoot(long offset) {
        BFM bfm;
        bfm.BufferManagerFlush();
        FILE *file = fopen(name.c_str(), "r+b");
        writeContent(file, 0, &offset, sizeof(long));
        fclose(file);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x20(%rbp), %rbx
movq %rdi, (%rbx)
leaq -0x11(%rbp), %rdi
callq 0x7dfa
movq 0x1076b(%rip), %rdi     # 0x19320
leaq 0x8744(%rip), %rsi      # 0x11300
callq 0x3300
movq %rax, %r14
pushq $0x8
popq %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x8655
movq %r14, %rdi
callq 0x3290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: BT::build(std::vector<std::pair<element, long>, std::allocator<std::pair<element, long>>> const&)
BTNode *build(const vector < pair <element, long> > &v) {
        C = pool;
        C->n = 0;
        C->isLeaf = C->isRoot = 1;
        return C;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0x10754(%rip)     # 0x19344
leaq 0x10749(%rip), %rax     # 0x19340
movq %rax, 0xc116842(%rip)   # 0xc11f440
movw $0x101, 0x10739(%rip)   # imm = 0x101
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: BT::save(BTNode const&)
BTNode save(const BTNode &p) {
        bfm->BufferManagerFlush();
        FILE *file = fopen(name.c_str(), "r+b");
        writeContent(file, p.offset, &p, sizeof(p));
        fclose(file);
        return BTNode();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x106f8(%rip), %rdi     # 0x19318
callq 0x7dfa
movq 0x106f4(%rip), %rdi     # 0x19320
leaq 0x86cd(%rip), %rsi      # 0x11300
callq 0x3300
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl $0xfd0, %ecx            # imm = 0xFD0
callq 0x8655
movq %r15, %rdi
callq 0x3290
movl $0xfd0, %edx            # imm = 0xFD0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3160
movq %rbx, %rdi
callq 0xa130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Table&, AttrType const&)
Response IndexManager::create(const string &indexName, const string &dbName, Table &table, const AttrType &attr) {
    if (DEBUG) cout << "IndexManagerCreate begin" << endl;
    Response res;
    if (isFileExist(getIndexFileName(indexName))) {
        if (DEBUG) cout << "if" << endl;
        return badRes(info_index_exist);
    } else {
        if (DEBUG) cout << "else" << endl;
        save();
        currentFile = getIndexFileName(indexName);
        mp = build(getRecord(bfm, dbName, table, attr));
        save();
        return goodRes();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xc0(%rbp), %rdi
callq 0xfdbe
leaq -0x80(%rbp), %rdi
movq %r15, %rsi
callq 0x8717
leaq -0x80(%rbp), %rdi
callq 0x85e4
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x34f8
testb %r12b, %r12b
je 0x9709
leaq 0xfbf9(%rip), %rsi      # 0x192f8
movq %rbx, %rdi
callq 0x87df
jmp 0x9786
movq %r14, %rdi
callq 0x9574
leaq -0x80(%rbp), %rdi
movq %r15, %rsi
callq 0x8717
leaq 0x38(%r14), %rdi
leaq -0x80(%rbp), %r15
movq %r15, %rsi
callq 0x3310
movq %r15, %rdi
callq 0x34f8
movq (%r14), %rsi
leaq -0x50(%rbp), %rdi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x8837
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8a99
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xa694
movq %r15, %rdi
callq 0xa5c6
leaq -0x50(%rbp), %rdi
callq 0xa104
movq %r14, %rdi
callq 0x9574
movq %rbx, %rdi
callq 0x87c4
leaq -0xc0(%rbp), %rdi
callq 0x5e02
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa104
jmp 0x97cc
jmp 0x97c9
jmp 0x97c9
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x34f8
jmp 0x97cc
jmp 0x97c9
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x5e02
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::drop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response IndexManager::drop(const std::string &indexName) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) {
        return badRes("No such index. -- IndexManager::drop");
    } else {
        bfm.deleteFile(name);
        currentFile = "";
        return goodRes();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r15, %rdi
callq 0x85e4
testb %al, %al
je 0x9837
movq (%r14), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7e42
addq $0x38, %r14
leaq 0x7a66(%rip), %rsi      # 0x1128b
movq %r14, %rdi
callq 0x34c0
movq %rbx, %rdi
callq 0x87c4
jmp 0x9860
leaq 0x7ac6(%rip), %rsi      # 0x11304
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30e0
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x87df
leaq -0x40(%rbp), %rdi
callq 0x34f8
leaq -0x60(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x34f8
jmp 0x988a
jmp 0x9887
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&, long)
Response IndexManager::insert(const string &indexName, const element &e, long offset) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return badRes("No such Index. -- IndexManager::insert");
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    if (mp.count(e)) return badRes("Element exist. -- IndexManager::insert");
    mp[e] = offset;
    return goodRes();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r13, %rdi
callq 0x85e4
testb %al, %al
je 0x993b
leaq 0x38(%r12), %r13
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
callq 0xa526
testb %al, %al
je 0x9905
movq %r12, %rdi
callq 0x9574
leaq -0x70(%rbp), %rsi
movq %r13, %rdi
callq 0x3150
movq %r12, %rdi
callq 0x99c0
addq $0x8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa534
testq %rax, %rax
je 0x997f
leaq 0x7a30(%rip), %rsi      # 0x11350
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x30e0
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x87df
jmp 0x995b
leaq 0x79e7(%rip), %rsi      # 0x11329
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x30e0
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x87df
leaq -0x50(%rbp), %rdi
callq 0x34f8
leaq -0x70(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
callq 0xa1ae
movq %r14, (%rax)
movq %rbx, %rdi
callq 0x87c4
jmp 0x9964
jmp 0x999b
jmp 0x99ab
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x34f8
jmp 0x99ae
jmp 0x99ab
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
Response IndexManager::erase(const string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return badRes("No such Index. -- IndexManager::erase");
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    if (!mp.count(e)) return badRes("No such element. -- IndexManager::erase");
    mp.erase(e);
    return goodRes();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r12, %rdi
callq 0x85e4
testb %al, %al
je 0x9c8a
leaq 0x38(%r15), %r12
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
callq 0xa526
testb %al, %al
je 0x9c61
movq %r15, %rdi
callq 0x9574
leaq -0x68(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r15, %rdi
callq 0x99c0
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa534
testq %rax, %rax
je 0x9cac
movq %r15, %rdi
movq %r14, %rsi
callq 0xb61e
movq %rbx, %rdi
callq 0x87c4
jmp 0x9cd5
leaq 0x76e6(%rip), %rsi      # 0x11377
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x30e0
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x87df
jmp 0x9ccc
leaq 0x76ea(%rip), %rsi      # 0x1139d
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x30e0
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x87df
leaq -0x48(%rbp), %rdi
callq 0x34f8
leaq -0x68(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9cf2
jmp 0x9d02
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x34f8
jmp 0x9d05
jmp 0x9d02
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
long IndexManager::find(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return -1;
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    if (!mp.count(e)) return -1;
    return mp[e];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x8717
movq %r15, %rdi
callq 0x85e4
pushq $-0x1
popq %r15
testb %al, %al
je 0x9d99
leaq 0x38(%r14), %r12
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xa526
testb %al, %al
je 0x9d77
movq %r14, %rdi
callq 0x9574
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x99c0
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa534
testq %rax, %rax
je 0x9d99
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa1ae
movq (%rax), %r15
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::greater(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
set <long> IndexManager::greater(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.upper_bound(e); it != mp.end(); it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r12, %rdi
callq 0x85e4
testb %al, %al
je 0x9e74
leaq 0x38(%r14), %r12
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xa526
testb %al, %al
je 0x9e29
movq %r14, %rdi
callq 0x9574
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x99c0
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xb80c
movq %rax, %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x9e90
leaq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x72f8
movq %r15, %rdi
callq 0x31c0
movq %rax, %r15
jmp 0x9e56
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9eb0
movq %rax, %r14
jmp 0x9ebb
movq %rax, %r14
movq %rbx, %rdi
callq 0x69f0
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::less(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
set <long> IndexManager::less(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.begin(); it != mp.end() && it->first < e; it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r12, %rdi
callq 0x85e4
testb %al, %al
je 0x9f85
leaq 0x38(%r15), %r12
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xa526
testb %al, %al
je 0x9f33
movq %r15, %rdi
callq 0x9574
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r15, %rdi
callq 0x99c0
leaq 0x8(%rbx), %rax
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq 0x20(%r15), %r12
addq $0x10, %r15
cmpq %r15, %r12
je 0x9fa1
leaq 0x20(%r12), %rdi
movq %r14, %rsi
callq 0xfc28
testb %al, %al
je 0x9fa1
leaq 0x50(%r12), %rsi
movq %rbx, %rdi
callq 0x72f8
movq %r12, %rdi
callq 0x31c0
movq %rax, %r12
jmp 0x9f55
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9fcc
jmp 0x9fc1
movq %rax, %r14
movq %rbx, %rdi
callq 0x69f0
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::inRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&, element const&)
set <long> IndexManager::inRange(const std::string &indexName, const element &lhs, const element &rhs) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.lower_bound(lhs); it != mp.end() && it->first <= rhs; it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x8717
movq %r13, %rdi
callq 0x85e4
testb %al, %al
je 0xa0a7
leaq 0x38(%r15), %r13
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0xa526
testb %al, %al
je 0xa04a
movq %r15, %rdi
callq 0x9574
leaq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x3150
movq %r15, %rdi
callq 0x99c0
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0xb822
movq %rax, %r12
addq $0x10, %r15
cmpq %r15, %r12
je 0xa0c3
leaq 0x20(%r12), %rdi
movq %r14, %rsi
callq 0xfd84
testb %al, %al
je 0xa0c3
leaq 0x50(%r12), %rsi
movq %rbx, %rdi
callq 0x72f8
movq %r12, %rdi
callq 0x31c0
movq %rax, %r12
jmp 0xa077
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq -0x48(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa0e7
movq %rax, %r14
jmp 0xa0f2
jmp 0xa0e7
movq %rax, %r14
movq %rbx, %rdi
callq 0x69f0
leaq -0x48(%rbp), %rdi
callq 0x34f8
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::hasTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CatalogManager::hasTable(const std::string &tableName) {
    std::ifstream fin((tableName).c_str());
    if (!fin) return false;
    std::string header;
    fin >> header;
    fin.close();
    return tableName == header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq (%rsi), %rsi
leaq -0x238(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x3490
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0xb873
xorl %ebx, %ebx
jmp 0xb8b8
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3330
leaq -0x238(%rbp), %rdi
callq 0x3080
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5db5
movl %eax, %ebx
movq %r14, %rdi
callq 0x34f8
leaq -0x238(%rbp), %rdi
callq 0x30a0
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x34f8
leaq -0x238(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::createTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<AttrType, std::allocator<AttrType>> const&)
Table CatalogManager::createTable(const std::string &tableName, const std::vector<AttrType> &attrs) {
    assert(!hasTable(tableName));
    Table nt(tableName, attrs);
    nt.write();
    return nt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xb838
testb %al, %al
jne 0xb935
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf7ac
movq %rbx, %rdi
callq 0xf884
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a8a(%rip), %rdi      # 0x113c6
leaq 0x5a98(%rip), %rsi      # 0x113db
leaq 0x5aa3(%rip), %rcx      # 0x113ed
pushq $0x17
popq %rdx
callq 0x31a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e26
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::loadTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Table CatalogManager::loadTable(const std::string &tableName) {
    assert(hasTable(tableName));
    Table nt;
    int attrSum;
    std::ifstream fin((tableName).c_str());
    fin >> nt.name >> nt.entrySize >> attrSum >> nt.blockCount;
    for (int i = 0, n; i < attrSum; ++ i) {
        AttrType attr;
        fin >> attr.name >> attr.type >> attr.length >> attr.unique;
        fin >> n;
        for (int j = 0; j < n; ++ j) {
            std::string index;
            fin >> index;
            attr.indices.insert(index);
        }
        nt.attributes.push_back(attr);
    }
    return nt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rdx, %rbx
movq %rdi, %r15
movq %rdx, %rsi
callq 0xb838
testb %al, %al
je 0xbb19
movq %r15, %rdi
callq 0xf788
movq (%rbx), %rsi
leaq -0x2d0(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3490
leaq 0x8(%r15), %rsi
leaq -0x2d0(%rbp), %rdi
callq 0x3330
movq %rax, %rdi
movq %r15, %rsi
callq 0x3180
leaq -0x34(%rbp), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0x3180
leaq -0x58(%rbp), %rbx
leaq -0x98(%rbp), %r13
leaq 0x28(%r15), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
leaq -0x2d0(%rbp), %r14
leaq -0x68(%rbp), %r12
movq %r15, -0x40(%rbp)
cmpl -0x34(%rbp), %eax
jge 0xbaf8
movl %eax, -0x2c(%rbp)
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
andq $0x0, -0xc0(%rbp)
movb $0x0, -0xb8(%rbp)
andl $0x0, -0x90(%rbp)
andq $0x0, -0x88(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
andq $0x0, -0x70(%rbp)
movq %r14, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x3330
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3180
movq %rax, %rdi
leaq -0xa4(%rbp), %rsi
callq 0x3180
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3230
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3180
xorl %r15d, %r15d
cmpl -0x30(%rbp), %r15d
jge 0xbace
movq %rbx, -0x68(%rbp)
andq $0x0, -0x60(%rbp)
movb $0x0, -0x58(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3330
movq %r13, %rdi
movq %r12, %rsi
callq 0x6e2e
movq %r12, %rdi
callq 0x34f8
incl %r15d
jmp 0xba98
movq -0x48(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movq -0x40(%rbp), %r15
callq 0xbeea
leaq -0xc8(%rbp), %rdi
callq 0x684c
movl -0x2c(%rbp), %eax
incl %eax
jmp 0xba01
leaq -0x2d0(%rbp), %rdi
callq 0x30a0
movq %r15, %rax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58a7(%rip), %rdi      # 0x113c7
leaq 0x58b4(%rip), %rsi      # 0x113db
leaq 0x5915(%rip), %rcx      # 0x11443
pushq $0x1e
popq %rdx
callq 0x31a0
movq %rax, %rbx
jmp 0xbb6d
movq %rax, %rbx
jmp 0xbb61
movq %rax, %rbx
jmp 0xbb55
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x34f8
movq -0x40(%rbp), %r15
leaq -0xc8(%rbp), %rdi
callq 0x684c
leaq -0x2d0(%rbp), %rdi
callq 0x30a0
movq %r15, %rdi
callq 0x5e26
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::dropTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CatalogManager::dropTable(const std::string &tableName) {
    assert(hasTable(tableName));
    std::string name = tableName.substr(0, tableName.find('.'));
    Table nt = loadTable(tableName);
    std::vector<AttrType> &attr = nt.attributes;
    for (size_t i = 0; i < attr.size(); ++ i) {
        bool flag = false;
        for (auto &x : attr[i].indices) {
            flag = true;
            dropIndex(x);
        }
        if (flag) {
            BFM bm;
            std::string indexFileName = name + "." + attr[i].name + ".index";
            bm.deleteFile(indexFileName);
        }
    }

    remove((tableName).c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb838
testb %al, %al
je 0xbce5
pushq $0x2e
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3350
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x32b0
leaq -0xa8(%rbp), %rdi
movq %rbx, -0x38(%rbp)
movq %rbx, %rdx
callq 0xb966
xorl %r13d, %r13d
leaq -0xc8(%rbp), %r12
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
subq %rcx, %rax
cqto
pushq $0x60
popq %rsi
idivq %rsi
cmpq %rax, %r13
jae 0xbcb2
movq %r12, %rbx
movq %r13, -0x40(%rbp)
imulq $0x60, %r13, %r15
leaq (%rcx,%r15), %r13
addq $0x38, %r13
movq 0x10(%r13), %r12
xorl %eax, %eax
cmpq %r13, %r12
je 0xbc36
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0xbd58
movq %r12, %rdi
callq 0x32f0
movq %rax, %r12
movb $0x1, %al
jmp 0xbc15
testb $0x1, %al
movq %rbx, %r12
movq -0x40(%rbp), %r13
leaq -0xe8(%rbp), %rbx
je 0xbcaa
movq %r12, %rdi
leaq -0x60(%rbp), %rsi
leaq 0x5650(%rip), %rdx      # 0x112a6
callq 0x5d7d
addq -0x80(%rbp), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5dd8
leaq -0x108(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x54bc(%rip), %rdx      # 0x1113d
callq 0x5e6e
movq %rbx, %rdi
callq 0x34f8
movq %r12, %rdi
callq 0x34f8
leaq -0x29(%rbp), %rdi
movq %r15, %rsi
callq 0x7e42
movq %r15, %rdi
callq 0x34f8
incq %r13
jmp 0xbbe0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x3470
leaq -0xa8(%rbp), %rdi
callq 0x5e26
leaq -0x60(%rbp), %rdi
callq 0x34f8
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56db(%rip), %rdi      # 0x113c7
leaq 0x56e8(%rip), %rsi      # 0x113db
leaq 0x577e(%rip), %rcx      # 0x11478
pushq $0x32
popq %rdx
callq 0x31a0
movq %rax, %rbx
jmp 0xbd46
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
jmp 0xbd30
jmp 0xbd37
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x34f8
jmp 0xbd29
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x34f8
jmp 0xbd3a
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x5e26
leaq -0x60(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/filter.cc
// Function: Filter::test(std::vector<element, std::allocator<element>> const&) const
bool Filter::test(const std::vector<element> &data) const {
    for (size_t i = 0; i < rules.size(); ++ i) {
        const Rule &rule = rules[i];
        assert((size_t)rule.index < data.size());
        switch (rule.type) {
            case 0:
                if (!(data[rule.index] <  rule.val)) return false;
                break;
            case 1:
                if (!(data[rule.index] <= rule.val)) return false;
                break;
            case 2:
                if (!(data[rule.index] == rule.val)) return false;
                break;
            case 3:
                if (!(data[rule.index] >= rule.val)) return false;
                break;
            case 4:
                if (!(data[rule.index] >  rule.val)) return false;
                break;
            case 5:
                if (!(data[rule.index] != rule.val)) return false;
                break;
            default: 
                assert(false);
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r13
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
movq %rax, %r15
cmpq %rax, %r12
jae 0xc6e1
movslq -0x8(%rsi,%r13), %rcx
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
pushq $0x30
popq %r8
idivq %r8
cmpq %rcx, %rax
jbe 0xc6f6
movl -0x4(%rsi,%r13), %eax
cmpq $0x5, %rax
ja 0xc713
leaq 0x4ea8(%rip), %rdx      # 0x1150c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfc28
jmp 0xc6d1
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfd2c
jmp 0xc6d1
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfc9e
jmp 0xc6d1
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfd58
jmp 0xc6d1
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfd84
jmp 0xc6d1
imulq $0x30, %rcx, %rax
addq %rax, %rdi
addq %r13, %rsi
callq 0xfdb0
testb %al, %al
je 0xc6e1
incq %r12
addq $0x38, %r13
jmp 0xc60f
cmpq %r15, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e27(%rip), %rdi      # 0x11524
leaq 0x4e41(%rip), %rsi      # 0x11545
leaq 0x4e44(%rip), %rcx      # 0x1154f
pushq $0x12
popq %rdx
callq 0x31a0
leaq 0x4a65(%rip), %rdi      # 0x1117f
leaq 0x4e24(%rip), %rsi      # 0x11545
leaq 0x4e27(%rip), %rcx      # 0x1154f
pushq $0x27
jmp 0xc70d
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Interpreter::process(std::string line) {
    static std::string cmd;
    for (size_t i = 0; i < line.length(); ++ i) {
        if (line[i] == ';') {
            std::string now(cmd);
            cmd = "";
            if (parse(now)) return true;
        }
        else cmd += line[i];
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
movb 0xc112ad6(%rip), %al    # 0xc11f478
testb %al, %al
je 0xca5b
xorl %r15d, %r15d
leaq -0x58(%rbp), %r13
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %r12
cmpq %r12, %r15
jae 0xca46
movq (%rbx), %rax
movb (%rax,%r15), %al
cmpb $0x3b, %al
jne 0xca2b
movq %r13, %rdi
leaq 0xc112a81(%rip), %r14   # 0xc11f458
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
leaq 0x48a2(%rip), %rsi      # 0x1128b
callq 0x34c0
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3380
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0xcada
movl %eax, %r14d
movq %rbx, %rdi
callq 0x34f8
leaq -0x58(%rbp), %r13
movq %r13, %rdi
callq 0x34f8
testb %r14b, %r14b
movq -0x30(%rbp), %rbx
je 0xca3e
jmp 0xca46
movsbl %al, %esi
leaq 0xc112a23(%rip), %rdi   # 0xc11f458
callq 0x3220
leaq -0x58(%rbp), %r13
incq %r15
jmp 0xc9b5
cmpq %r12, %r15
setb %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc112a16(%rip), %rdi   # 0xc11f478
callq 0x3480
testl %eax, %eax
je 0xc9aa
leaq 0xc1129f2(%rip), %rax   # 0xc11f468
movq %rax, 0xc1129db(%rip)   # 0xc11f458
leaq 0xc1129d4(%rip), %rsi   # 0xc11f458
andq $0x0, 0xc1129d4(%rip)   # 0xc11f460
movb $0x0, 0xc1129d5(%rip)   # 0xc11f468
movq 0xc516(%rip), %rdi      # 0x18fb0
leaq 0xc7df(%rip), %rdx      # 0x19280
callq 0x3240
leaq 0xc1129cb(%rip), %rdi   # 0xc11f478
callq 0x3190
jmp 0xc9aa
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x34f8
jmp 0xcac8
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::execfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Interpreter::execfile(std::string filename) {
    std::ifstream fin((filename).c_str());
    if (!fin) std::cout << "file does not exist" << std::endl;
    else {
        std::string buf;
        while (getline(fin, buf)) {
            int len = buf.size();
            while (len && (buf[len - 1] == '\n' || buf[len - 1] == '\r')) {
                len --;
            }
            if (process(buf.substr(0, len))) return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x270(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x3490
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
je 0xe10b
movq 0xaed6(%rip), %rdi      # 0x18fc8
leaq 0x3497(%rip), %rsi      # 0x11590
callq 0x3280
movq %rax, %rdi
callq 0x3120
jmp 0xe1bb
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %r12
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
leaq -0x270(%rbp), %rdi
movq %r15, %rsi
callq 0x3070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xe1b2
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movslq %ecx, %rsi
shlq $0x20, %rcx
movq %rsi, %rdx
subq $0x1, %rdx
jb 0xe179
movzbl -0x1(%rax,%rsi), %esi
cmpl $0xd, %esi
je 0xe171
cmpl $0xa, %esi
jne 0xe179
addq %r14, %rcx
movq %rdx, %rsi
jmp 0xe15c
sarq $0x20, %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x32b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc984
movl %eax, %r13d
movq %r12, %rdi
callq 0x34f8
testb %r13b, %r13b
je 0xe12d
leaq -0x48(%rbp), %rdi
callq 0x34f8
movb $0x1, %bl
jmp 0xe1bd
leaq -0x48(%rbp), %rdi
callq 0x34f8
xorl %ebx, %ebx
leaq -0x270(%rbp), %rdi
callq 0x30a0
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe1fe
jmp 0xe1f2
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0xe1f5
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x34f8
leaq -0x270(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::parseElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
element Interpreter::parseElement(std::string data) {
    if (data[0] == '\'') {
        std::string res;
        res = data.substr(1, data.length() - 2);
        return res;
    }
    if (data.find('.') != -1) {
        char *s;
        return strtof(data.c_str(), &s);
    }
    else {
        char *s;
        return int(strtod(data.c_str(), &s) + 0.5);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
cmpb $0x27, (%rax)
jne 0xe293
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
andq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
leaq -0x80(%rbp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x32b0
leaq -0x40(%rbp), %r14
leaq -0x80(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3310
movq %r15, %rdi
callq 0x34f8
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rcx
cmpq %r12, %rcx
je 0xe2de
movq %rcx, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xe2e8
pushq $0x2e
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3350
cmpq $-0x1, %rax
je 0xe2bc
movq (%r14), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3360
movq %rbx, %rdi
callq 0xfb34
jmp 0xe31b
movq (%r14), %rdi
leaq -0x40(%rbp), %rsi
callq 0x31f0
addsd 0x32b8(%rip), %xmm0     # 0x11588
cvttsd2si %xmm0, %esi
movq %rbx, %rdi
callq 0xfb16
jmp 0xe31b
movupd (%r12), %xmm0
movupd %xmm0, (%rax)
movq -0x38(%rbp), %rax
leaq -0x60(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq %r12, -0x40(%rbp)
andq $0x0, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0xfb80
leaq -0x60(%rbp), %rdi
callq 0x34f8
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x34f8
jmp 0xe33c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::getString[abi:cxx11](Block&, int)
std::string RecordManager::getString(Block &block, int startPos)
{
    //NOTE: space for the string = user input + 1 !!
    char* str = (char*)block.data + startPos;
    std::string theString(str, strlen(str));
    return theString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %ecx, %r14
addq %rdx, %r14
movq %r14, %rdi
callq 0x3100
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf6ba
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq