LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ShootMe[P]Klondike-Solver/./HashMap.h
// Function: HashMap<int>::Add(HashKey const&, int const&)
KeyValue<T> * HashMap<T>::Add(HashKey const& key, T const& value) {
	int hash = key.ComputeHash();
	int i = hash;
	i ^= (hash >> 16);
	i &= capacity;
	KeyValue<T> * node = &table[i];

	int length = 1;
	while (node != NULL && node->Key[0] != 0) {
		if (node->Hash == hash && key == node->Key) { return node; }
		node = node->Next;
		length++;
	}

	++size;
	node = &table[i];
	if (node->Key[0] != 0) {
		node->Next = new KeyValue<T>(node->Hash, node->Key, node->Value, node->Next);
	}
	node->Hash = hash;
	node->Key = key;
	node->Value = value;

	if (length > maxLength) { maxLength = length; }
	if (length == 1) { slotsUsed++; }
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
xorl %eax, %eax
xorl %ebp, %ebp
movsbl (%r15,%rax), %ecx
incq %rax
imull $0x1007f, %ebp, %ebp    # imm = 0x1007F
addl %ecx, %ebp
cmpq $0x15, %rax
jne 0x9065
movl %ebp, %eax
sarl $0x10, %eax
xorl %ebp, %eax
andl 0xc(%rdi), %eax
cltq
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r13
movl $0x1, %r12d
testq %rcx, %rcx
je 0x90e2
movq %r13, %rax
cmpb $0x0, 0x8(%rax)
je 0x90e2
cmpl %ebp, 0x24(%rax)
jne 0x90d7
xorl %ecx, %ecx
movb (%r15,%rcx), %sil
cmpb 0x8(%rax,%rcx), %sil
jne 0x90c6
incq %rcx
cmpq $0x14, %rcx
jne 0x90ad
movl $0x14, %ecx
movl %ecx, %ecx
movb (%r15,%rcx), %sil
cmpb 0x8(%rax,%rcx), %sil
je 0x915a
movq (%rax), %rax
incl %r12d
testq %rax, %rax
jne 0x90a0
incl 0x8(%rdi)
leaq 0x8(%r13), %r14
cmpb $0x0, 0x8(%r13)
je 0x912b
movq %rdi, (%rsp)
movl $0x28, %edi
callq 0x21c0
movq (%rsp), %rdi
movl 0x24(%r13), %ecx
movq (%r13), %rsi
movq %rsi, (%rax)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq 0xd(%r14), %rsi
movq %rsi, 0x15(%rax)
movl %ecx, 0x24(%rax)
movl 0x20(%r13), %ecx
movl %ecx, 0x20(%rax)
movq %rax, (%r13)
movl %ebp, 0x24(%r13)
movq 0xd(%r15), %rax
movq %rax, 0xd(%r14)
movups (%r15), %xmm0
movups %xmm0, (%r14)
movl (%rbx), %eax
movl %eax, 0x20(%r13)
cmpl 0x14(%rdi), %r12d
jle 0x914f
movl %r12d, 0x14(%rdi)
cmpl $0x1, %r12d
jne 0x9158
incl 0x18(%rdi)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ShootMe[P]Klondike-Solver/Random.cpp
// Function: Random::SetSeed(int)
void Random::SetSeed(int seed) {
	this->seed = seed;
	mix = 51651237;
	twist = 895213268;
	value = seed;

	for (int i = 0; i < 50; ++i) {
		CalculateNext();
	}

	seed ^= (seed >> 15);
	value = 0x9417B3AF ^ seed;

	for (int i = 0; i < 950; ++i) {
		CalculateNext();
	}
}

// Assembly:
movl %esi, 0xc(%rdi)
movl $0x31422a5, %ecx        # imm = 0x31422A5
movl $0x355bded4, %eax       # imm = 0x355BDED4
movl $0x32, %edx
movl %esi, %r9d
movl %ecx, %r10d
movl %eax, %r8d
subl %ecx, %r8d
movl %eax, %ecx
xorl %r9d, %ecx
xorl %r10d, %ecx
xorl %ecx, %r8d
movl %r8d, %r10d
xorl %eax, %r10d
subl %ecx, %eax
movl %eax, %r11d
xorl %r9d, %r11d
movl %r10d, %eax
xorl %r11d, %eax
movl %eax, %r9d
shll $0x7, %r9d
movl %ecx, %r10d
sarl $0x10, %r10d
shll $0x8, %r8d
xorl %r10d, %r8d
xorl %r11d, %r8d
xorl %r9d, %r8d
movl %r8d, %r9d
decl %edx
jne 0x9b39
movl %esi, %r8d
sarl $0xf, %r8d
xorl %esi, %r8d
xorl $0x9417b3af, %r8d       # imm = 0x9417B3AF
movl $0x3b6, %edx            # imm = 0x3B6
movl %ecx, %esi
movl %eax, %r9d
subl %ecx, %r9d
movl %eax, %ecx
xorl %r8d, %ecx
xorl %esi, %ecx
xorl %ecx, %r9d
movl %r9d, %esi
xorl %eax, %esi
subl %ecx, %eax
movl %eax, %r10d
xorl %r8d, %r10d
movl %esi, %eax
xorl %r10d, %eax
movl %eax, %esi
shll $0x7, %esi
movl %ecx, %r8d
sarl $0x10, %r8d
shll $0x8, %r9d
xorl %r8d, %r9d
xorl %r10d, %r9d
movl %r9d, %r8d
xorl %esi, %r8d
decl %edx
jne 0x9b99
movl %r8d, (%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0x4(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ShootMe[P]Klondike-Solver/Random.cpp
// Function: Random::Next2()
int Random::Next2() {
	if (seed == 0) { seed = 0x12345987; }
	int k = seed / 127773;
	seed = 16807 * (seed - k * 127773) - 2836 * k;
	if ((int)seed < 0) { seed += 2147483647; }
	return seed & 0x7fffffff;
}

// Assembly:
movl 0xc(%rdi), %eax
testl %eax, %eax
movl $0x12345987, %ecx       # imm = 0x12345987
cmovnel %eax, %ecx
imulq $0x69c16bd, %rcx, %rax  # imm = 0x69C16BD
shrq $0x20, %rax
movl %ecx, %edx
subl %eax, %edx
shrl %edx
addl %eax, %edx
shrl $0x10, %edx
imull $0xfffe0ce3, %edx, %eax # imm = 0xFFFE0CE3
addl %ecx, %eax
imull $0x41a7, %eax, %eax     # imm = 0x41A7
imull $0xfffff4ec, %edx, %ecx # imm = 0xFFFFF4EC
addl %eax, %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leal (%rcx,%rdx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %eax, 0xc(%rdi)
andl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zimpha[P]MiniSQL/API.cc
// Function: API::dropTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response API::dropTable(const std::string &tableName) {
    if (!cm.hasTable(tableName + ".table")) {
        return Response("Table does not exist");
    }
    cm.dropTable(tableName+".table");

    std::string dbName = tableName + ".db";
    // Record Manager clear database
    // 传入数据库文件名(dbName)
    rm.RecordManagerTableDetete(dbName);
    return Response();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x88b4
leaq 0xf698(%rip), %rsi      # 0x14051
movq %r12, %rdi
callq 0x34f0
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0xde1c
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x49de
callq 0x3270
testb %r12b, %r12b
je 0x4a9c
leaq -0x48(%rbp), %r12
movq %r13, (%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x88b4
leaq 0xf649(%rip), %rsi      # 0x14051
movq %r12, %rdi
callq 0x34f0
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0xe1cc
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4a2a
callq 0x3270
movq %r13, (%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x88b4
leaq 0xf677(%rip), %rsi      # 0x140be
movq %r12, %rdi
callq 0x34f0
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x88b4
addq $0x30, %r14
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq 0x11d88
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x4a89
callq 0x3270
movq %rbx, %rdi
callq 0x135ba
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0x4ad8
jmp 0x4add
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xf5ad(%rip), %rsi      # 0x14058
leaq 0xf5ba(%rip), %rdx      # 0x1406c
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x8952
movq %rbx, %rdi
movq %r14, %rsi
callq 0x135e0
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x4add
callq 0x3270
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x4b20
callq 0x3270
jmp 0x4b20
jmp 0x4b1d
jmp 0x4b1d
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x4b29
jmp 0x4b2e
jmp 0x4b1d
jmp 0x4b1d
jmp 0x4b1d
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b2e
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0xc5af(%rip), %rsi      # 0x14214
leaq -0x2a0(%rbp), %rdi
movl $0x8, %edx
callq 0x34c0
movq %rbx, %rdi
callq 0x7e96
movq -0x2a0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x280(%rbp,%rax)
jne 0x7d87
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x88(%rbp), %r13
leaq -0x70(%rbp), %r15
leaq -0x98(%rbp), %r14
leaq -0x2a0(%rbp), %rdi
movq %r15, %rsi
callq 0x3360
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x3360
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7d57
movq %r13, -0x98(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x88b4
movl -0x2c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7e08
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3340
movl -0x78(%rbp), %eax
movl %eax, 0x20(%r12)
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0x7cc7
callq 0x3270
jmp 0x7cc7
leaq -0x2a0(%rbp), %rdi
callq 0x3080
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7d75
callq 0x3270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x7d87
callq 0x3270
leaq -0x2a0(%rbp), %rdi
callq 0x3090
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7dc4
movq %rax, %r14
jmp 0x7df7
movq %rax, %r14
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0x7dc7
callq 0x3270
jmp 0x7dc7
jmp 0x7dc4
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7dd9
callq 0x3270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x7deb
callq 0x3270
leaq -0x2a0(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x82e0
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbefe(%rip), %rsi      # 0x14214
leaq -0x230(%rbp), %rdi
movl $0x10, %edx
callq 0x32e0
movq 0x18(%rbx), %r14
movq %rbx, -0x30(%rbp)
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x83da
leaq -0x230(%rbp), %r15
leaq 0xc2d3(%rip), %r12      # 0x1461d
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x3310
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r13, %rdi
callq 0x3310
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
movl 0x60(%r14), %esi
movq %r13, %rdi
callq 0x3470
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x834a
leaq -0x230(%rbp), %rdi
callq 0x33a0
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7e96
movq 0x12bc7(%rip), %rax     # 0x1afc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0x3220
leaq -0x138(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x82e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8444
movq %rax, %rdi
callq 0x7e87
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x1000(%rsi), %rdi
leaq 0xa9e1(%rip), %rsi      # 0x14297
callq 0x3330
testq %rax, %rax
je 0x98d1
movq %rax, %rdi
callq 0x3290
leaq 0xa9ea(%rip), %rsi      # 0x142b9
jmp 0x98d8
leaq 0xa9de(%rip), %rsi      # 0x142b6
movq 0x1000(%rbx), %rdi
callq 0x3330
testq %rax, %rax
je 0x99b4
movq %rax, %r14
movq 0x1020(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x32f0
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rcx
callq 0x3500
movq %r14, %rdi
callq 0x3290
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x1000(%rbx), %rsi
movq 0x1008(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x88b4
movq 0x1020(%rbx), %rax
movq %rax, 0x20(%r14)
leaq 0x1195b(%rip), %rdi     # 0x1b2b0
movq %r14, %rsi
callq 0x9d5e
leaq 0x11954(%rip), %rcx     # 0x1b2b8
cmpq %rcx, %rax
je 0x999b
movq 0x48(%rax), %rbx
leaq 0x1193c(%rip), %rdi     # 0x1b2b0
leaq -0x40(%rbp), %rsi
callq 0x9d5e
leaq 0x1192c(%rip), %rdi     # 0x1b2b0
movq %rax, %rsi
callq 0xa0d4
leaq 0x1194d(%rip), %rdi     # 0x1b2e0
movq %rbx, %rsi
callq 0x9e20
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x99a9
callq 0x3270
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x11635(%rip), %r14     # 0x1aff0
leaq 0xa8d8(%rip), %rsi      # 0x1429a
movl $0x11, %edx
movq %r14, %rdi
callq 0x3310
movq 0x1000(%rbx), %rsi
movq 0x1008(%rbx), %rdx
movq %r14, %rdi
callq 0x3310
leaq 0xa8c0(%rip), %rsi      # 0x142ac
movl $0x9, %edx
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
jmp 0x9a05
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x9a16
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11898(%rip), %rsi     # 0x1b2e0
leaq 0x11891(%rip), %rbx     # 0x1b2e0
cmpq %rbx, %rsi
je 0x9a68
movq (%rsi), %r14
addq $0x10, %rsi
callq 0x9898
movq %r14, %rsi
cmpq %rbx, %r14
jne 0x9a54
movq %rbx, %rdi
callq 0x9d12
movq %rbx, 0x11871(%rip)     # 0x1b2e8
movq %rbx, 0x11862(%rip)     # 0x1b2e0
movq $0x0, 0x11867(%rip) # 0x1b2f0
leaq 0x11820(%rip), %rdi     # 0x1b2b0
popq %rbx
popq %r14
popq %rbp
jmp 0xa114
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x88b4
movl $0x0, 0x20(%r14)
leaq -0x68(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x9af2
movq %rdi, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x9afc
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq %rcx, %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %r15, -0x50(%rbp)
xorl %eax, %eax
movq %rax, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq %rax, -0x58(%rbp)
movq 0x117a3(%rip), %r13     # 0x1b2c0
leaq 0x11794(%rip), %r14     # 0x1b2b8
testq %r13, %r13
je 0x9b62
leaq 0x11780(%rip), %r15     # 0x1b2b0
leaq -0x78(%rbp), %r12
leaq 0x20(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x9dd2
testb %al, %al
cmoveq %r13, %r14
movzbl %al, %eax
movq 0x10(%r13,%rax,8), %r13
testq %r13, %r13
jne 0x9b34
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %r15
leaq -0x68(%rbp), %rcx
cmpq %rcx, %rdi
je 0x9b6c
callq 0x3270
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x9b7a
callq 0x3270
leaq 0x11737(%rip), %r12     # 0x1b2b8
cmpq %r12, %r14
je 0x9bc5
movq 0x28(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x9bc5
testq %rdx, %rdx
je 0x9ba5
movq (%rbx), %rsi
movq 0x20(%r14), %rdi
callq 0x32b0
testl %eax, %eax
jne 0x9bc5
movq %r14, %rdi
callq 0x31d0
movq %rax, %r15
movq 0x48(%r14), %rsi
addq $0x10, %rsi
callq 0x9898
movq %r15, %r14
cmpq %r12, %r15
jne 0x9b86
movq (%rbx), %rdi
callq 0x34a0
movq 0x113f4(%rip), %rdi     # 0x1afc8
movl %eax, %esi
callq 0x3470
movq %rax, %r14
leaq 0xaa38(%rip), %rsi      # 0x1461d
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3310
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x9c4f
callq 0x3270
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x9c61
callq 0x3270
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x32f0
testl %eax, %eax
jne 0xa203
movslq %r15d, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3500
cmpq %r15, %rax
jne 0xa216
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3130
leaq 0xa0e5(%rip), %rcx      # 0x142f9
jmp 0xa227
movl $0x8, %edi
callq 0x3130
leaq 0xa0ab(%rip), %rcx      # 0x142d2
movq %rcx, (%rax)
movq 0x10d7f(%rip), %rsi     # 0x1afb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 0x135ba
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 0x7a0e
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0xa886
leaq -0x48(%rbp), %r14
movq (%r12), %rax
movq %rax, -0x60(%rbp)
movq %r14, -0x58(%rbp)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x88b4
movl 0x28(%r12), %eax
movl %eax, -0x38(%rbp)
movq 0x30(%r12), %r15
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x60(%rbp), %rsi
callq 0xc9d8
movq %r15, (%rax)
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xa87d
callq 0x3270
addq $0x38, %r12
cmpq %r13, %r12
jne 0xa82d
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xa8ae
movq %rax, %r15
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xa8ae
callq 0x3270
movq %rbx, %rdi
callq 0xcd12
movq %r15, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10a5a(%rip), %rdi     # 0x1b330
leaq 0x99ba(%rip), %rsi      # 0x14297
callq 0x3330
movq %rax, %r15
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x32f0
movq %r15, %rdi
callq 0x3030
movq %rax, %r14
movq %r15, %rdi
callq 0x3290
leaq 0x238(%rbx), %r13
leaq 0x250(%rbx), %r15
movq %r15, %rdi
callq 0x13296
addq $-0x30, %r12
addq $0x30, %r15
cmpq $-0xd80, %r12           # imm = 0xF280
jne 0xa918
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r12, %r12
je 0xa96a
subq %r12, %r13
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0xa960
callq 0x3270
addq $-0x30, %r13
addq $0x30, %r12
jne 0xa952
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9a3a
movq 0x1099c(%rip), %rdi     # 0x1b330
leaq 0x998f(%rip), %rsi      # 0x1432a
callq 0x3330
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movl $0x8, %ecx
callq 0xa1bf
movq %r14, %rdi
callq 0x3290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x1097f(%rip), %rax     # 0x1b350
movq %rax, 0xc116a78(%rip)   # 0xc121450
movl $0x0, 0x10972(%rip)     # 0x1b354
movw $0x101, 0x10965(%rip)   # imm = 0x101
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10923(%rip), %rdi     # 0x1b328
callq 0x9a3a
movq 0x1091f(%rip), %rdi     # 0x1b330
leaq 0x9912(%rip), %rsi      # 0x1432a
callq 0x3330
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl $0xfd0, %ecx            # imm = 0xFD0
callq 0xa1bf
movq %r15, %rdi
callq 0x3290
xorl %r15d, %r15d
movl $0xfd0, %edx            # imm = 0xFD0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3160
leaq 0x238(%rbx), %r12
movq %rbx, %r14
addq $0x250, %r14            # imm = 0x250
movq %r14, %rdi
callq 0x13296
addq $-0x30, %r15
addq $0x30, %r14
cmpq $-0xd80, %r15           # imm = 0xF280
jne 0xaa5f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r15, %r15
je 0xaaa8
subq %r15, %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0xaa9e
callq 0x3270
addq $-0x30, %r12
addq $0x30, %r15
jne 0xaa8f
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xa8, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, -0x40(%rbp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x135ba
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0xa28b
movq %r13, -0x30(%rbp)
movq %r12, -0x38(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa14c
movl %eax, %r12d
leaq -0x60(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xbc8b
callq 0x3270
testb %r12b, %r12b
je 0xbca4
leaq 0xf671(%rip), %rsi      # 0x1b308
movq %rbx, %rdi
callq 0xa443
jmp 0xbd7a
movq %r14, %rdi
callq 0xbab4
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0xa28b
leaq 0x38(%r14), %rdi
leaq -0x70(%rbp), %r15
movq %r15, %rsi
callq 0x3340
movq (%r15), %rdi
cmpq %r13, %rdi
je 0xbcd5
callq 0x3270
movq (%r14), %rsi
leaq -0x88(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0xa49b
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa7ec
leaq 0x8(%r14), %rdi
callq 0xcdfe
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0xbd52
leaq 0x10(%r14), %rcx
leaq -0x68(%rbp), %rdx
movl (%rdx), %esi
movl %esi, 0x10(%r14)
movq %rax, 0x18(%r14)
movq 0x10(%rdx), %rsi
movq %rsi, 0x20(%r14)
movq 0x18(%rdx), %rsi
movq %rsi, 0x28(%r14)
movq %rcx, 0x8(%rax)
movq 0x20(%rdx), %rax
movq %rax, 0x30(%r14)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rax, 0x20(%rdx)
leaq -0x70(%rbp), %rdi
callq 0xcd12
leaq -0x88(%rbp), %rdi
callq 0xc97e
movq %r14, %rdi
callq 0xbab4
movq %rbx, %rdi
callq 0x135ba
movb $0x1, (%rbx)
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x7a6a
movq -0x20(%r14), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xbd9e
callq 0x3270
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xc97e
jmp 0xbde4
jmp 0xbde1
jmp 0xbde1
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbde4
callq 0x3270
jmp 0xbde4
jmp 0xbde1
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x7a0e
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x58(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xa28b
movq %r15, %rdi
callq 0xa14c
testb %al, %al
je 0xbe5b
movq (%r14), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9a9a
movq 0x40(%r14), %rdx
addq $0x38, %r14
leaq 0x8474(%rip), %rcx      # 0x142b5
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3400
movq %rbx, %rdi
callq 0x135ba
movb $0x1, (%rbx)
jmp 0xbe94
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x84c4(%rip), %rsi      # 0x1432e
leaq 0x84e1(%rip), %rdx      # 0x14352
leaq -0x38(%rbp), %rdi
callq 0x8952
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xa443
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xbe94
callq 0x3270
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbea6
callq 0x3270
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xbecc
callq 0x3270
jmp 0xbecc
jmp 0xbec9
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbede
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x68(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0xa28b
movq %r13, %rdi
callq 0xa14c
testb %al, %al
je 0xbfaa
leaq 0x38(%r12), %r13
movq -0x60(%rbp), %rdx
cmpq 0x40(%r12), %rdx
jne 0xbf48
testq %rdx, %rdx
je 0xbf64
movq (%r13), %rsi
movq -0x68(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xbf64
movq %r12, %rdi
callq 0xbab4
leaq -0x68(%rbp), %rsi
movq %r13, %rdi
callq 0x3150
movq %r12, %rdi
callq 0xc058
leaq 0x8(%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xdc48
addq $0x10, %r12
cmpq %r12, %rax
je 0xbfe5
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x83ee(%rip), %rsi      # 0x1437a
leaq 0x840d(%rip), %rdx      # 0x143a0
leaq -0x48(%rbp), %rdi
callq 0x8952
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xa443
jmp 0xbfd5
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x839a(%rip), %rsi      # 0x14353
leaq 0x83b9(%rip), %rdx      # 0x14379
leaq -0x48(%rbp), %rdi
callq 0x8952
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xa443
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xbffe
callq 0x3270
jmp 0xbffe
movq %r13, %rdi
movq %r15, %rsi
callq 0xc9d8
movq %r14, (%rax)
movq %rbx, %rdi
callq 0x135ba
movb $0x1, (%rbx)
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc010
callq 0x3270
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc026
jmp 0xc03b
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xc03e
callq 0x3270
jmp 0xc03e
jmp 0xc03b
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc050
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x40, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xa28b
movq %r12, %rdi
callq 0xa14c
testb %al, %al
je 0xc3e6
leaq 0x38(%r15), %r12
movq -0x58(%rbp), %rdx
cmpq 0x40(%r15), %rdx
jne 0xc38f
testq %rdx, %rdx
je 0xc3ab
movq (%r12), %rsi
movq -0x60(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xc3ab
movq %r15, %rdi
callq 0xbab4
leaq -0x60(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r15, %rdi
callq 0xc058
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xdc48
addq $0x10, %r15
cmpq %r15, %rax
je 0xc413
movq %r12, %rdi
movq %r14, %rsi
callq 0xdcac
movq %r12, %rdi
movq %rax, %rsi
callq 0xdd78
movq %rbx, %rdi
callq 0x135ba
movb $0x1, (%rbx)
jmp 0xc44c
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7fac(%rip), %rsi      # 0x143a1
leaq 0x7fca(%rip), %rdx      # 0x143c6
leaq -0x40(%rbp), %rdi
callq 0x8952
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xa443
jmp 0xc43e
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7fa5(%rip), %rsi      # 0x143c7
leaq 0x7fc5(%rip), %rdx      # 0x143ee
leaq -0x40(%rbp), %rdi
callq 0x8952
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xa443
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0xc44c
callq 0x3270
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc45e
callq 0x3270
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc472
jmp 0xc487
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0xc48a
callq 0x3270
jmp 0xc48a
jmp 0xc487
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc49c
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xa28b
movq %r14, %rdi
callq 0xa14c
movq $-0x1, %r14
testb %al, %al
je 0xc53e
leaq 0x38(%r15), %r12
movq -0x38(%rbp), %rdx
cmpq 0x40(%r15), %rdx
jne 0xc4fc
testq %rdx, %rdx
je 0xc518
movq (%r12), %rsi
movq -0x40(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xc518
movq %r15, %rdi
callq 0xbab4
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r15, %rdi
callq 0xc058
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xdc48
addq $0x10, %r15
cmpq %r15, %rax
je 0xc53e
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc9d8
movq (%rax), %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc550
callq 0x3270
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc575
callq 0x3270
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xa28b
movq %r12, %rdi
callq 0xa14c
testb %al, %al
je 0xc669
leaq 0x38(%r14), %r12
movq -0x40(%rbp), %rdx
cmpq 0x40(%r14), %rdx
jne 0xc5db
testq %rdx, %rdx
je 0xc5f7
movq (%r12), %rsi
movq -0x48(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xc5f7
movq %r14, %rdi
callq 0xbab4
leaq -0x48(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r14, %rdi
callq 0xc058
leaq 0x8(%rbx), %rax
movl $0x0, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x18(%r14), %r13
testq %r13, %r13
je 0xc685
addq $0x10, %r14
movq %r14, %r12
leaq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x133ee
testb %al, %al
cmovneq %r13, %r12
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r13,%rax,8), %r13
testq %r13, %r13
jne 0xc624
cmpq %r14, %r12
je 0xc685
leaq 0x50(%r12), %rsi
movq %rbx, %rdi
callq 0x8ede
movq %r12, %rdi
callq 0x31d0
movq %rax, %r12
cmpq %r14, %rax
jne 0xc64a
jmp 0xc685
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc697
callq 0x3270
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc6bb
jmp 0xc6b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x859c
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6cd
callq 0x3270
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa28b
movq %r12, %rdi
callq 0xa14c
testb %al, %al
je 0xc7a7
leaq 0x38(%r15), %r12
movq -0x38(%rbp), %rdx
cmpq 0x40(%r15), %rdx
jne 0xc731
testq %rdx, %rdx
je 0xc74d
movq (%r12), %rsi
movq -0x40(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xc74d
movq %r15, %rdi
callq 0xbab4
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x3150
movq %r15, %rdi
callq 0xc058
leaq 0x8(%rbx), %rax
movl $0x0, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x20(%r15), %r12
addq $0x10, %r15
cmpq %r15, %r12
je 0xc7c3
leaq 0x20(%r12), %rdi
movq %r14, %rsi
callq 0x133ee
testb %al, %al
je 0xc7c3
leaq 0x50(%r12), %rsi
movq %rbx, %rdi
callq 0x8ede
movq %r12, %rdi
callq 0x31d0
movq %rax, %r12
cmpq %r15, %rax
jne 0xc777
jmp 0xc7c3
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc7d5
callq 0x3270
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc7f7
jmp 0xc7ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x859c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc809
callq 0x3270
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x30(%rbp)
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0xa28b
movq %r13, %rdi
callq 0xa14c
testb %al, %al
je 0xc90f
leaq 0x38(%r15), %r13
movq -0x48(%rbp), %rdx
cmpq 0x40(%r15), %rdx
jne 0xc873
testq %rdx, %rdx
je 0xc88f
movq (%r13), %rsi
movq -0x50(%rbp), %rdi
callq 0x32b0
testl %eax, %eax
je 0xc88f
movq %r15, %rdi
callq 0xbab4
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
callq 0x3150
movq %r15, %rdi
callq 0xc058
leaq 0x8(%rbx), %rax
movl $0x0, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x18(%r15), %r14
testq %r14, %r14
je 0xc92b
addq $0x10, %r15
movq %r15, %r13
leaq 0x20(%r14), %rdi
movq %r12, %rsi
callq 0x133ee
testb %al, %al
cmoveq %r14, %r13
movzbl %al, %eax
movq 0x10(%r14,%rax,8), %r14
testq %r14, %r14
jne 0xc8bc
cmpq %r15, %r13
je 0xc92b
leaq 0x20(%r13), %rdi
movq -0x30(%rbp), %rsi
callq 0x13580
testb %al, %al
je 0xc92b
leaq 0x50(%r13), %rsi
movq %rbx, %rdi
callq 0x8ede
movq %r13, %rdi
callq 0x31d0
movq %rax, %r13
cmpq %r15, %rax
jne 0xc8e0
jmp 0xc92b
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc93d
callq 0x3270
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc963
jmp 0xc958
jmp 0xc958
movq %rax, %r14
movq %rbx, %rdi
callq 0x859c
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc975
callq 0x3270
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq (%rsi), %rsi
leaq -0x240(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x34c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
je 0xde5b
xorl %ebx, %ebx
jmp 0xdec7
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x240(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3360
leaq -0x240(%rbp), %rdi
callq 0x3080
movq 0x8(%rbx), %rdx
cmpq -0x30(%rbp), %rdx
jne 0xdeb0
movq -0x38(%rbp), %r14
testq %rdx, %rdx
je 0xdeb8
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x32b0
testl %eax, %eax
sete %bl
jmp 0xdeba
movq -0x38(%rbp), %r14
xorl %ebx, %ebx
jmp 0xdeba
movb $0x1, %bl
cmpq %r15, %r14
je 0xdec7
movq %r14, %rdi
callq 0x3270
leaq -0x240(%rbp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xdef4
callq 0x3270
leaq -0x240(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 0xde1c
testb %al, %al
jne 0xdf4b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12d00
movq %rbx, %rdi
callq 0x12df6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x649e(%rip), %rdi      # 0x143f0
leaq 0x64ac(%rip), %rsi      # 0x14405
leaq 0x64b7(%rip), %rcx      # 0x14417
movl $0x17, %edx
callq 0x31a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a3c
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq (%rdi), %rsi
movb $0x1, %al
cmpq %rsi, 0x8(%rdi)
je 0xefcd
movq %rdi, %r15
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x565f(%rip), %rbx      # 0x14538
movslq -0x8(%rsi,%r12), %rax
movq (%r14), %rdi
movq 0x8(%r14), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rax, %rcx
jbe 0xefdc
movl -0x4(%rsi,%r12), %ecx
cmpq $0x5, %rcx
ja 0xeffb
movslq (%rbx,%rcx,4), %rcx
addq %rbx, %rcx
jmpq *%rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x133ee
jmp 0xef97
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x13528
jmp 0xef97
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x13478
jmp 0xef97
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x13554
jmp 0xef97
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x13580
jmp 0xef97
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq %r12, %rsi
callq 0x135ac
testb %al, %al
je 0xefcb
incq %r13
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
addq $0x38, %r12
cmpq %rax, %r13
jb 0xeed9
movb $0x1, %al
jmp 0xefcd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x556d(%rip), %rdi      # 0x14550
leaq 0x5587(%rip), %rsi      # 0x14571
leaq 0x558a(%rip), %rcx      # 0x1457b
movl $0x12, %edx
callq 0x31a0
leaq 0x517d(%rip), %rdi      # 0x1417f
leaq 0x5568(%rip), %rsi      # 0x14571
leaq 0x556b(%rip), %rcx      # 0x1457b
movl $0x27, %edx
callq 0x31a0