LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Kruskal.cpp
// Function: make_set(Graph&)
void make_set(Graph & g) {
	for(int i = 0; i != g.num_nodes(); i++) {
		Node n = g.getNode(i);
		g.setParent(n, i);
		g.setRank(n, 0);
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x4e6e
testq %rax, %rax
je 0xcd7c
leaq -0x98(%rbp), %r14
xorl %r15d, %r15d
leaq -0xa8(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3faa
movq %rax, %r13
movq %r14, -0xa8(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2c2e
movups 0x20(%r13), %xmm0
movups 0x30(%r13), %xmm1
movups 0x40(%r13), %xmm2
movups 0x50(%r13), %xmm3
movups %xmm3, 0x40(%r14)
movups %xmm2, 0x30(%r14)
movups %xmm1, 0x20(%r14)
movups %xmm0, 0x10(%r14)
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x60(%r13), %rsi
movq 0x68(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2c2e
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x4cb0
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4bb2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xcd57
callq 0x21f0
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0xcd68
callq 0x21f0
incq %r15
movq %rbx, %rdi
callq 0x4e6e
cmpq %rax, %r15
jne 0xccbf
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0xcdb3
callq 0x21f0
jmp 0xcdb3
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2bc0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Kruskal.cpp
// Function: MST_union(Graph&, Node&, Node&)
void MST_union(Graph & g, Node & a, Node & b) {
	int a_root = find(g, a), b_root = find(g, b);
	
	if(a_root == b_root) return;
	
	if(g.rank(a) < g.rank(b)) {
		g.setParent(a, b_root);
	} else if (g.rank(a) > g.rank(b)) {
		g.setParent(b, a_root);
	} else {
		g.setParent(b, a_root);
		g.setRank(a, g.rank(a) + 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x120(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x130(%rbp), %r12
movq %r12, %rdi
callq 0x2c2e
movups 0x20(%rbx), %xmm0
movups 0x30(%rbx), %xmm1
movups 0x40(%rbx), %xmm2
movups 0x50(%rbx), %xmm3
movups %xmm3, 0x50(%r12)
movups %xmm2, 0x40(%r12)
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x20(%r12)
leaq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdx
addq %rsi, %rdx
callq 0x2c2e
leaq -0x130(%rbp), %rsi
movq %r14, %rdi
callq 0xcdbb
movl %eax, -0x2c(%rbp)
movq -0xd0(%rbp), %rdi
cmpq %r12, %rdi
je 0xcfa8
callq 0x21f0
movq -0x130(%rbp), %rdi
cmpq %r13, %rdi
je 0xcfb9
callq 0x21f0
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0xb0(%rbp), %r13
movq %r13, %rdi
callq 0x2c2e
movups 0x20(%r15), %xmm0
movups 0x30(%r15), %xmm1
movups 0x40(%r15), %xmm2
movups 0x50(%r15), %xmm3
movups %xmm3, 0x50(%r13)
movups %xmm2, 0x40(%r13)
movups %xmm1, 0x30(%r13)
movups %xmm0, 0x20(%r13)
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x60(%r15), %rsi
movq 0x68(%r15), %rdx
addq %rsi, %rdx
callq 0x2c2e
leaq -0xb0(%rbp), %rsi
movq %r14, %rdi
callq 0xcdbb
movl %eax, %r13d
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xd042
callq 0x21f0
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0xd05a
callq 0x21f0
cmpl %r13d, -0x2c(%rbp)
je 0xd0d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4eb0
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x4eb0
cmpl %eax, %r12d
jge 0xd08e
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x4cb0
jmp 0xd0d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4eb0
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x4eb0
movl %eax, %r13d
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0x4cb0
cmpl %r13d, %r12d
jg 0xd0d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4eb0
leal 0x1(%rax), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4bb2
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0xd116
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
jne 0xd12c
jmp 0xd131
movq %rax, %rbx
leaq -0x130(%rbp), %rdi
callq 0x2bc0
jmp 0xd131
movq %rax, %rbx
movq -0x130(%rbp), %rdi
cmpq %r13, %rdi
je 0xd131
callq 0x21f0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/correctness.cc
// Function: CorrectnessTest::start_test(void*)
void start_test(void *args = NULL) override
	{
		std::cout << "KVStore Correctness Test" << std::endl;

		std::cout << "[Simple Test]" << std::endl;
		regular_test(SIMPLE_TEST_MAX);

		std::cout << "[Large Test]" << std::endl;
		regular_test(LARGE_TEST_MAX);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x124e8(%rip), %r14     # 0x15fd0
leaq 0xc5bc(%rip), %rsi      # 0x100ab
movl $0x18, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
leaq 0xc59a(%rip), %rsi      # 0x100c4
movl $0xd, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
movq 0x90(%rbx), %rsi
movq %rbx, %rdi
callq 0x3c02
leaq 0xc55e(%rip), %rsi      # 0x100d2
movl $0xc, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
movq 0x98(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c02
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/./test.h
// Function: Test::phase()
void phase(void)
	{
		// Report
		std::cout << "  Phase " << (nr_phases+1) << ": ";
		std::cout << nr_passed_tests << "/" << nr_tests << " ";

		// Count
		++nr_phases;
		if (nr_tests == nr_passed_tests) {
			++nr_passed_phases;
			std::cout << "[PASS]" << std::endl;
		} else
			std::cout << "[FAIL]" << std::endl;

		std::cout.flush();

		// Reset
		nr_tests = 0;
		nr_passed_tests = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x11132(%rip), %rbx     # 0x15fd0
leaq 0xb26e(%rip), %rsi      # 0x10113
movl $0x8, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x18(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x3190
leaq 0xb180(%rip), %rsi      # 0x10048
movl $0x2, %edx
movq %rax, %rdi
callq 0x32b0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3190
movq %rax, %r15
leaq 0xb3c6(%rip), %rsi      # 0x102b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x3190
leaq 0xb13a(%rip), %rsi      # 0x10049
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
incq 0x18(%r14)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jne 0x4f37
incq 0x20(%r14)
leaq 0xb1e7(%rip), %rsi      # 0x1011c
jmp 0x4f3e
leaq 0xb1e5(%rip), %rsi      # 0x10123
movl $0x6, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x31a0
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/BloomFilter.cc
// Function: BloomFilter::insert(unsigned long)
void BloomFilter::insert(LsmKey k) {
    uint32_t* hashValues = new uint32_t[4];
    hashValues = (uint32_t*)memset(hashValues, 0, 4 * sizeof(uint32_t));
    MurmurHash3_x64_128(&k, sizeof(k), 1, hashValues);
    for (int i = 0; i < 4; ++i) {
        int index = *(hashValues + i) % BLOOM_FILTER_SIZE;
        byteArray[index] = 1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10, %edi
callq 0x3030
movq (%rbx), %rcx
xorl %edx, %edx
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
movl (%rax,%rdx,4), %edi
movq %rdi, %r8
imulq %rsi, %r8
shrq $0x2d, %r8
shll $0xb, %r8d
leal (%r8,%r8,4), %r8d
subl %r8d, %edi
movb $0x1, (%rcx,%rdi)
incq %rdx
cmpq $0x4, %rdx
jne 0x5756
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/BloomFilter.cc
// Function: BloomFilter::hasKey(unsigned long) const
bool BloomFilter::hasKey(LsmKey k) const {
    uint32_t* hashValues = new uint32_t[4];
    hashValues = (uint32_t*)memset(hashValues, 0, 4 * sizeof(uint32_t));
    MurmurHash3_x64_128(&k, sizeof(k), 1, hashValues);
    return byteArray[*hashValues % BLOOM_FILTER_SIZE]
           & byteArray[*(hashValues + 1) % BLOOM_FILTER_SIZE]
           & byteArray[*(hashValues + 2) % BLOOM_FILTER_SIZE]
           & byteArray[*(hashValues + 3) % BLOOM_FILTER_SIZE];
}

// Assembly:
movabsq $-0x783c846eeebdac2b, %rax # imm = 0x87C37B91114253D5
imulq %rsi, %rax
movabsq $-0x775ed61580000000, %rcx # imm = 0x88A129EA80000000
imulq %rsi, %rcx
shrq $0x21, %rax
orq %rcx, %rax
movabsq $0x4cf5ad432745937f, %rcx # imm = 0x4CF5AD432745937F
imulq %rax, %rcx
xorq $0x9, %rcx
leaq 0x9(%rcx), %rax
addq $0x12, %rcx
movq %rax, %rdx
shrq $0x21, %rdx
xorq %rax, %rdx
movabsq $-0xae502812aa7333, %rsi # imm = 0xFF51AFD7ED558CCD
imulq %rsi, %rdx
movq %rdx, %r8
shrq $0x21, %r8
xorq %rdx, %r8
movabsq $-0x3b314601e57a13ad, %rdx # imm = 0xC4CEB9FE1A85EC53
imulq %rdx, %r8
movq %r8, %rax
shrq $0x21, %rax
xorq %r8, %rax
movq %rcx, %r8
shrq $0x21, %r8
xorq %rcx, %r8
imulq %rsi, %r8
movq %r8, %rsi
shrq $0x21, %rsi
xorq %r8, %rsi
imulq %rdx, %rsi
movq %rsi, %rcx
shrq $0x21, %rcx
xorq %rsi, %rcx
addq %rcx, %rax
addq %rax, %rcx
movq (%rdi), %rdx
movl %eax, %edi
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
imulq %rsi, %rdi
shrq $0x2d, %rdi
shll $0xb, %edi
leal (%rdi,%rdi,4), %edi
movl %eax, %r8d
subl %edi, %r8d
shrq $0x20, %rax
movq %rax, %rdi
imulq %rsi, %rdi
shrq $0x2d, %rdi
shll $0xb, %edi
leal (%rdi,%rdi,4), %edi
subl %edi, %eax
movb (%rdx,%rax), %al
andb (%rdx,%r8), %al
movl %ecx, %edi
imulq %rsi, %rdi
shrq $0x2d, %rdi
shll $0xb, %edi
leal (%rdi,%rdi,4), %edi
movl %ecx, %r8d
subl %edi, %r8d
andb (%rdx,%r8), %al
shrq $0x20, %rcx
movq %rcx, %rdi
imulq %rsi, %rdi
shrq $0x2d, %rdi
shll $0xb, %edi
leal (%rdi,%rdi,4), %esi
subl %esi, %ecx
andb (%rdx,%rcx), %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::get[abi:cxx11](unsigned long) const
LsmValue SSTable::get(LsmKey k) const {
    if (!bloomFilter.hasKey(k))
        return "";
    int64_t index = find(k, dataIndexes, 0, header.keyNumber - 1);
    if (index < 0)
        return "";
    return getValueFromDisk(index);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rdi
movq %rdx, %rsi
callq 0x577e
testb %al, %al
je 0x5958
leaq 0x30(%r14), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x6900
movq 0x10(%r14), %r8
decq %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x59a2
movq %rax, %r15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5943
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
testq %r15, %r15
js 0x5958
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5ab6
jmp 0x5971
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xa6e4(%rip), %rdx      # 0x1004a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5648
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5999
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::find(unsigned long, std::vector<DataIndex, std::allocator<DataIndex>>, long, long) const
int64_t SSTable::find(LsmKey k, vector<DataIndex> arr, int64_t start, int64_t end) const {

    if (start >= end && arr[start].key != k)
        return -1;

    uint64_t mid = start + (end - start) / 2;
    if (k < arr[mid].key)
        return find(k, arr, start, mid-1);
    if (k > arr[mid].key)
        return find(k, arr, mid+1, end);

    return mid;  // found

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %r8, %rcx
movq (%rdx), %rax
subq %r13, %rcx
jg 0x59df
movq %r13, %rsi
shlq $0x4, %rsi
movq $-0x1, %rbx
cmpq %r14, (%rax,%rsi)
jne 0x5a79
movq %rcx, %rbx
shrq $0x3f, %rbx
addq %rcx, %rbx
sarq %rbx
addq %r13, %rbx
movq %rbx, %rcx
shlq $0x4, %rcx
cmpq %r14, (%rax,%rcx)
jbe 0x5a32
leaq 0x30(%rsp), %rbp
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x6900
decq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x59a2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x5a68
jae 0x5a79
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x6900
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x59a2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5a79
movq (%rbp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x5a9d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5aae
movq (%rbp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::getValueFromDisk[abi:cxx11](unsigned long) const
LsmValue SSTable::getValueFromDisk(size_t index) const {

    string filename = getFilename();

    // Open the SST file.
    ifstream table(filename, ios::in | ios::binary);
    if (!table) {
        cerr << "Cannot open file `" << filename << "`." << endl;
        exit(-1);
    }

    // Find the start and end of the value.
    uint32_t start = dataIndexes[index].offset;
    uint32_t end;
    if (index != dataIndexes.size() - 1)
        end = dataIndexes[index + 1].offset;
    else {      // If `key` is the last key, set `end` as the length of the file.
        table.seekg(0, ios::end);
        end = table.tellg();
    }

    // Read value from the file.
    LsmValue value = readValueFromFile(table, start, end, false);

    // Close the file.
    table.close();

    return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5c48
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movl $0xc, %edx
callq 0x33e0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x5b9b
movq 0x30(%r15), %rax
movq 0x38(%r15), %rdx
movq %r14, %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %ebp
subq %rax, %rdx
sarq $0x4, %rdx
decq %rdx
cmpq %r14, %rdx
jne 0x5b43
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3320
leaq 0x28(%rsp), %rdi
callq 0x3450
movq %rax, %rcx
jmp 0x5b47
movl 0x18(%rax,%rcx), %ecx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x657a
leaq 0x28(%rsp), %rdi
callq 0x3050
leaq 0x28(%rsp), %rdi
callq 0x3070
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x1044e(%rip), %rdi     # 0x15ff0
leaq 0xa5ee(%rip), %rsi      # 0x10197
movl $0x12, %edx
callq 0x32b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x1042c(%rip), %rdi     # 0x15ff0
callq 0x32b0
movq %rax, %rbx
leaq 0xa5d7(%rip), %rsi      # 0x101aa
movl $0x2, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3140
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x32d0
jmp 0x5c17
jmp 0x5c17
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x5c1a
movq (%rbx), %rsi
incq %rsi
callq 0x3280
jmp 0x5c1a
movq %rax, %r14
jmp 0x5c24
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3070
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::readValueFromFile[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&, unsigned int, unsigned int, bool)
LsmValue SSTable::readValueFromFile(ifstream& table, uint32_t startOffset, uint32_t endOffset, bool multiValue) {
    LsmValue value;
    uint32_t length = endOffset - startOffset;
    value.resize(length);
    if (!multiValue)
        table.seekg(startOffset, ios::beg);
    table.read((char*)&value[0], length);
    return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
subl %edx, %r14d
movq %r14, %rsi
xorl %edx, %edx
callq 0x30b0
testb %r12b, %r12b
jne 0x65c4
movl %ebp, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3320
movq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x32f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x65fb
movq (%r13), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::getKeys() const
vector<LsmKey> SSTable::getKeys() const {
    vector<LsmKey> keys;
    for (const auto& dataIndex : dataIndexes) {
        keys.push_back(dataIndex.key);
    }
    return keys;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r15
cmpq %r15, %r14
je 0x68d8
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x68c7
movq (%r14), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x68d2
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5216
addq $0x10, %r14
jmp 0x68a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x68f8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/MemTable.cc
// Function: MemTable::reset()
void MemTable::reset() {
    while (head) {
        while (head->next) {
            Node* delNode = head->next;
            head->next = delNode->next;
            delete delNode;
        }
        Node* delHead = head;
        head = head->down;
        delete delHead;
    }
    head = new Node();
    keyNumber = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x6e34
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x6e00
addq $0x28, %r14
movq %r14, %rax
movq 0x28(%r15), %rcx
movq %rcx, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x6de3
movq (%rax), %rsi
incq %rsi
callq 0x3280
movl $0x38, %esi
movq %r15, %rdi
callq 0x3280
movq (%rbx), %r14
leaq 0x28(%r14), %rax
movq 0x28(%r14), %r15
testq %r15, %r15
jne 0x6dc4
movq 0x30(%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x6e1f
movq (%rax), %rsi
incq %rsi
callq 0x3280
movl $0x38, %esi
movq %r14, %rdi
callq 0x3280
movq (%rbx), %r14
jmp 0x6dab
movl $0x38, %edi
callq 0x3270
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/MemTable.cc
// Function: MemTable::get[abi:cxx11](unsigned long)
LsmValue MemTable::get(LsmKey k) {

    Node* p = head;

    while (p) {
        while (p->next && p->next->key < k)
            p = p->next;
        if (p->next && k == p->next->key)
            return p->next->value;
        p = p->down;
    }

    return "";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x710b
movq %rax, %rcx
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x7105
cmpq %rdx, (%rax)
jb 0x70f2
je 0x7129
movq 0x30(%rcx), %rax
jmp 0x70ed
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8f31(%rip), %rdx      # 0x1004a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5648
movq %rbx, %rax
popq %rbx
retq
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x55b2
jmp 0x7124
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/MemTable.cc
// Function: MemTable::del(unsigned long)
bool MemTable::del(LsmKey k) {

    Node* p = head;
    bool find = false;

    while (p) {
        while (p->next && p->next->key < k)
            p = p->next;
        if (p->next && k == p->next->key) {
            if (p->next->value == DELETE_SIGN)
                return false;
            find = true;
            Node *delNode = p->next;
            p->next = delNode->next;
            delete delNode;
        }
        p = p->down;
    }

    while (head && !head->next) {   // delete empty layer
        Node* delHead = head;
        head = head->down;
        delete delHead;
    }

    return find;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x720e
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x912d(%rip), %r15      # 0x10299
movq %rdi, %r13
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x71c6
cmpq %r14, (%rdi)
jb 0x716c
jne 0x71c6
addq $0x8, %rdi
movq %r15, %rsi
callq 0x30a0
testl %eax, %eax
je 0x720e
movq 0x28(%r13), %r12
movq 0x28(%r12), %rax
movq %rax, 0x28(%r13)
movq 0x8(%r12), %rdi
leaq 0x18(%r12), %rax
cmpq %rax, %rdi
je 0x71b6
movq (%rax), %rsi
incq %rsi
callq 0x3280
movl $0x38, %esi
movq %r12, %rdi
callq 0x3280
movb $0x1, %bpl
movq 0x30(%r13), %rdi
testq %rdi, %rdi
jne 0x716c
jmp 0x7204
cmpq $0x0, 0x28(%r14)
jne 0x7210
movq 0x30(%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x71f7
movq (%rax), %rsi
incq %rsi
callq 0x3280
movl $0x38, %esi
movq %r14, %rdi
callq 0x3280
movq (%rbx), %r14
testq %r14, %r14
jne 0x71d1
jmp 0x7210
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %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/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::KVStore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KVStore::KVStore(const std::string &dir): KVStoreAPI(dir)
{
    if (!utils::dirExists(dir))
        utils::mkdir(dir.c_str());

    memTable = make_shared<MemTable>();
    memTableSize = HEADER_SIZE + BLOOM_FILTER_SIZE;
    ssTables = unordered_map<size_t, shared_ptr<vector<SSTPtr>>>();
    ssTables[0] = make_shared<vector<SSTPtr>>();
    timeStamp = 1;

    readAllSSTsFromDisk();
    detectAndHandleOverflow();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd91e(%rip), %rax      # 0x15ca8
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x50(%rdi), %rax
movq %rax, 0x20(%rdi)
movq $0x1, 0x28(%rdi)
movups %xmm0, 0x30(%rdi)
movl $0x3f800000, 0x40(%rdi) # imm = 0x3F800000
movups %xmm0, 0x48(%rdi)
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x55b2
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %r12
movq %r12, %rsi
callq 0x3220
testl %eax, %eax
sete %al
movl 0x18(%r12), %ebp
shrl $0xe, %ebp
andl $0x1, %ebp
andb %al, %bpl
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x8410
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
testb %bpl, %bpl
jne 0x841d
movq (%r15), %rdi
callq 0x8573
leaq 0x38(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0xd58c
movaps 0x30(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x30(%rsp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x8467
callq 0x7c76
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8467
callq 0x7c76
movl $0x2820, 0x18(%rbx)     # imm = 0x2820
leaq 0x60(%rsp), %rax
movq $0x0, -0x10(%rax)
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x3526
leaq 0x30(%rsp), %rdi
callq 0xd1e6
movl $0x28, %edi
callq 0x3270
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0xd87e(%rip), %rax      # 0x15d50
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0xd658
movq %r15, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rdi
movq %r15, 0x8(%rax)
testq %rdi, %rdi
je 0x850f
callq 0x7c76
movq $0x1, 0x58(%rbx)
movq %rbx, %rdi
callq 0x880a
movq %rbx, %rdi
callq 0x9100
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x7c76
jmp 0x8555
jmp 0x8552
movq %rax, %rdi
callq 0x520a
jmp 0x8552
movq %rax, %r12
movq %r14, %rdi
callq 0xd1e6
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x856b
callq 0x7c76
movq %r12, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::detectAndHandleOverflow()
void KVStore::detectAndHandleOverflow() {
    if (levelOverflow(0))
        compact0();

    size_t levelNumber = ssTables.size();
    for (size_t level = 1; level < levelNumber; ++level) {
        uint32_t overflowNumber = levelOverflow(level);
        if (!overflowNumber)
            break;
        compact(level, overflowNumber);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xe280
movq (%rax), %rax
movq 0x8(%rax), %r12
subq (%rax), %r12
movq (%r15), %rax
incq %rax
movq %rax, %xmm1
punpckldq 0x729c(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x72a4(%rip), %xmm1     # 0x103f0
shrq $0x4, %r12
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x3210
cvttsd2si %xmm0, %rax
cmpl %eax, %r12d
jle 0x9173
movq %rbx, %rdi
callq 0x9ec4
movq 0x38(%rbx), %rbp
cmpq $0x2, %rbp
jb 0x91f0
movl $0x1, %r15d
movq %rsp, %r12
movq %r15, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xe280
movq (%rax), %rax
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x4, %r13
movq (%rsp), %rax
incq %rax
movq %rax, %xmm1
punpckldq 0x7229(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x7231(%rip), %xmm1     # 0x103f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x3210
cvttsd2si %xmm0, %rax
subl %eax, %r13d
jle 0x91f0
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xa146
incq %r15
cmpq %r15, %rbp
jne 0x9186
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::put(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void KVStore::put(uint64_t key, const std::string &s)
{
    if (memTableOverflow(s)) {
        memToDisk();

        // Update states
        memTable->reset();
        memTableSize = HEADER_SIZE + BLOOM_FILTER_SIZE;

        detectAndHandleOverflow();
    }

    memTable->put(key, s);
    memTableSize += (DATA_INDEX_SIZE + s.size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x18(%rdi), %eax
addl $0xc, %eax
addq 0x8(%rdx), %rax
cmpq $0x200001, %rax         # imm = 0x200001
jb 0x92fe
movq %rbx, %rdi
callq 0x924e
movq 0x8(%rbx), %rdi
callq 0x6da0
movl $0x2820, 0x18(%rbx)     # imm = 0x2820
movq %rbx, %rdi
callq 0x9100
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6e68
movl 0x8(%r14), %eax
movl 0x18(%rbx), %ecx
addl %ecx, %eax
addl $0xc, %eax
movl %eax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::get[abi:cxx11](unsigned long)
std::string KVStore::get(uint64_t key)
{
    LsmValue memValue = memTable->get(key);
    if (memValue == DELETE_SIGN)
        return "";
    if (memValue.length() != 0)
        return memValue;

    LsmValue sstValue = getValueFromDisk(key);
    if (sstValue == DELETE_SIGN)
        return "";
    return sstValue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x70e6
leaq 0x6f37(%rip), %rsi      # 0x10299
movq %r12, %rdi
callq 0x30a0
testl %eax, %eax
je 0x939b
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x93b9
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x9401
movq %rsi, (%rbx)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x9407
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6ca1(%rip), %rdx      # 0x1004a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5648
jmp 0x945e
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x94d0
leaq 0x6ec9(%rip), %rsi      # 0x10299
leaq 0x28(%rsp), %rdi
callq 0x30a0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x9420
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x944f
movq %rdx, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x9455
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
jmp 0x945e
leaq 0x6c23(%rip), %rdx      # 0x1004a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5648
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x945e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x945e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9479
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x94ad
jmp 0x94aa
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x94c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::del(unsigned long)
bool KVStore::del(uint64_t key)
{
    LsmValue value = get(key);
    bool find = (value.length() != 0) && (value != DELETE_SIGN);
    memTable->put(key, DELETE_SIGN);
    return find;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x8(%rax)
cmpq $0x0, 0x8(%rbx)
je 0x9890
leaq 0x6a1a(%rip), %rsi      # 0x10299
leaq 0x28(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
setne %bl
jmp 0x9892
xorl %ebx, %ebx
movq 0x8(%r15), %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x69f2(%rip), %rsi      # 0x10299
leaq 0x69f4(%rip), %rdx      # 0x102a2
leaq 0x8(%rsp), %rdi
callq 0x5648
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e68
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x98df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x98fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x9927
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x9927
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9942
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reset()
void KVStore::reset()
{
    clearDisk();
    memTable->reset();
    memTableSize = HEADER_SIZE + BLOOM_FILTER_SIZE;
    ssTables.clear();
    ssTables[0] = make_shared<vector<SSTPtr>>();
    timeStamp = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x99fc
movq 0x8(%rbx), %rdi
callq 0x6da0
movl $0x2820, 0x18(%rbx)     # imm = 0x2820
leaq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0xd20c
movl $0x28, %edi
callq 0x3270
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0xc3b7(%rip), %rax      # 0x15d50
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0xd658
movq %r14, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rdi
movq %r14, 0x8(%rax)
testq %rdi, %rdi
je 0x99d6
callq 0x7c76
movq $0x1, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7c76
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::clearDisk()
void KVStore::clearDisk() {
    size_t levelNumber = ssTables.size();
    for (size_t level = 0; level < levelNumber; ++level) {
        vector<SSTPtr> levelSSTs = *ssTables[level];
        for (const auto& sst : levelSSTs)
            utils::rmfile(sst->getFilename().c_str());
        string dir = "./data/level-" + to_string(level);
        utils::rmdir(dir.c_str());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq 0x38(%rdi), %rax
movq $0x0, 0x8(%rsp)
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x9be3
addq $0x20, 0x10(%rsp)
leaq 0x28(%rsp), %r15
leaq 0x48(%rsp), %r13
leaq 0x60(%rsp), %r14
leaq 0x38(%rsp), %r12
leaq 0x18(%rsp), %rbp
movq %r13, %rbx
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe280
movq (%rax), %rsi
movq %r14, %rdi
callq 0xcf10
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %r13
cmpq %r13, %r14
je 0x9aa7
movq (%r14), %rsi
movq %rbp, %rdi
callq 0x5c48
movq 0x18(%rsp), %rdi
callq 0x3130
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9aa1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x10, %r14
jmp 0x9a70
movq 0x8(%rsp), %r14
movl $0x1, %esi
cmpq $0xa, %r14
movq %rbx, %r13
jb 0x9b09
movl $0x4, %esi
movq %r14, %rcx
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
cmpq $0x63, %rcx
jbe 0x9b02
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x9b07
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x9b09
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x9acc
addl $-0x3, %esi
jmp 0x9b09
addl $-0x2, %esi
jmp 0x9b09
decl %esi
movl %esi, %esi
movq %r13, 0x38(%rsp)
movq %r12, %rdi
xorl %edx, %edx
callq 0x32c0
movq 0x38(%rsp), %rdi
movl 0x40(%rsp), %esi
movq %r14, %rdx
callq 0x6978
movl $0xd, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x666e(%rip), %rcx      # 0x101ad
callq 0x32a0
movq %r15, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
leaq 0x60(%rsp), %r14
je 0x9b6c
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0x9b73
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x9ba2
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x18(%rsp), %rdi
callq 0x3100
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9bc3
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0xce64
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq 0x58(%rsp), %rax
jb 0x9a49
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9c10
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x9c13
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x9c13
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xce64
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::levelOverflow(unsigned long)
uint32_t KVStore::levelOverflow(size_t level) {
    int currentNumber = ssTables[level]->size();
    int maxNumber = (uint32_t)pow(2, level + 1);
    int overflowNumber = currentNumber - maxNumber;
    return overflowNumber > 0 ? overflowNumber : 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rsi, (%rbx)
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xe280
movq (%rax), %rax
movq 0x8(%rax), %r14
subq (%rax), %r14
movq (%rbx), %rax
incq %rax
movq %rax, %xmm1
punpckldq 0x6553(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x655b(%rip), %xmm1     # 0x103f0
shrq $0x4, %r14
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x3210
cvttsd2si %xmm0, %rax
subl %eax, %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::compact(unsigned long, unsigned int)
void KVStore::compact(size_t upperLevel, uint32_t overflowNumber) {

    // New the lower level if it does not exist.
    size_t lowerLevel = upperLevel + 1;
    if (!ssTables.count(lowerLevel)) {
        ssTables[lowerLevel] = make_shared<vector<SSTPtr>>();
    }

    // Find the SSTs possessing the smallest time stamps or minimum keys.
    vector<SSTPtr> compactSSTs = getCompactSSTs(upperLevel, overflowNumber);

    // Compact the SSTs one by one.
    for (const auto& compactSST : compactSSTs)
        compactOneSST(compactSST, lowerLevel);

    // Reconstruct the upper level.
    reconstructUpperLevel(upperLevel, compactSSTs);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x20(%rdi), %r12
movq %r12, %rdi
callq 0xe516
testq %rax, %rax
jne 0xa1d1
movl $0x28, %edi
callq 0x3270
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0xbbb9(%rip), %rax      # 0x15d50
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %rsp, %rsi
movq %r12, %rdi
callq 0xe280
movq %r15, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rdi
movq %r15, 0x8(%rax)
testq %rdi, %rdi
je 0xa1d1
callq 0x7c76
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xae22
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0xa209
movq (%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xaefe
addq $0x10, %r15
jmp 0xa1ef
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb14e
leaq 0x8(%rsp), %rdi
callq 0xce64
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7c76
jmp 0xa24c
jmp 0xa23f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xce64
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::sstBinarySearch(std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&, unsigned long, unsigned int, unsigned int)
uint32_t KVStore::sstBinarySearch(const vector<SSTPtr> &SSTs, LsmKey key,
                                  uint32_t left, uint32_t right) {
    if (left >= right) {
        if (right && SSTs[right]->getMinKey() > key)
            right--;
        return right;
    }

    uint32_t mid = left + (right - left) / 2;
    LsmKey midMinKey = SSTs[mid]->getMinKey();

    if (key < midMinKey)
        return sstBinarySearch(SSTs, key, left, mid ? mid - 1 : mid);
    if (key > midMinKey)
        return sstBinarySearch(SSTs, key, mid + 1, right);
    return mid;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl %ecx, %edx
jae 0xa2b6
movl %edx, %r12d
xorl %r13d, %r13d
movl %ebp, %r15d
subl %r12d, %r15d
shrl %r15d
addl %r12d, %r15d
movq (%r14), %rax
movq %r15, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
callq 0x6866
cmpq %rbx, %rax
jbe 0xa2a7
subl $0x1, %r15d
cmovbl %r13d, %r15d
movl %r15d, %ebp
cmpl %r15d, %r12d
jb 0xa271
jmp 0xa2b9
jae 0xa2e1
incl %r15d
movl %r15d, %r12d
cmpl %ebp, %r15d
jb 0xa271
jmp 0xa2c1
movl %ebp, %r15d
movl %r15d, %ebp
testl %r15d, %r15d
je 0xa2de
movl %ebp, %eax
movq (%r14), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rdi
callq 0x6866
cmpq %rax, %rbx
sbbl $0x0, %ebp
movl %ebp, %r15d
jmp 0xa2e1
xorl %r15d, %r15d
movl %r15d, %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/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getCompact0Range(unsigned long&, unsigned long&)
void KVStore::getCompact0Range(LsmKey& minKey, LsmKey& maxKey) {
    vector<SSTPtr> L0SSTs = *ssTables[0];
    minKey = min(min(L0SSTs[0]->getMinKey(), L0SSTs[1]->getMinKey()),
                 L0SSTs[2]->getMinKey());
    maxKey = max(max(L0SSTs[0]->getMaxKey(), L0SSTs[1]->getMaxKey()),
                 L0SSTs[2]->getMaxKey());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0x20, %rdi
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
callq 0xd658
movq (%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xcf10
movq (%r15), %rax
movq (%rax), %rdi
callq 0x6866
movq %rax, %r15
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x6866
movq %rax, %r12
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x6866
cmpq %r15, %r12
cmovbq %r12, %r15
cmpq %r15, %rax
cmovbq %rax, %r15
movq %r15, (%r14)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x686c
movq %rax, %r14
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x686c
movq %rax, %r15
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x686c
cmpq %r15, %r14
cmovaq %r14, %r15
cmpq %rax, %r15
cmovbeq %rax, %r15
movq %r15, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xce64
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa3c8
jmp 0xa3c8
jmp 0xa3c8
jmp 0xa3c8
jmp 0xa3c8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xce64
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getOverlapSSTs(unsigned long, unsigned long, unsigned long, long&, long&)
vector<SSTPtr> KVStore::getOverlapSSTs(LsmKey minKey, LsmKey maxKey, size_t level,
                                       int64_t& minOverlapIndex, int64_t& maxOverlapIndex) {

    vector<SSTPtr> overlapSSTs;

    if (ssTables[level]->empty())
        return overlapSSTs;

    vector<SSTPtr> levelSSTs = *ssTables[level];
    uint32_t length = levelSSTs.size();

    uint32_t leftIndex = sstBinarySearch(levelSSTs, minKey, 0, length - 1);

    if (levelSSTs[leftIndex]->getMaxKey() < minKey)
        if ((leftIndex == length - 1)
            || (leftIndex < length - 1 && levelSSTs[leftIndex+1]->getMinKey() > maxKey))
            return overlapSSTs;

    minOverlapIndex = leftIndex;
    maxOverlapIndex = 1 + sstBinarySearch(levelSSTs, maxKey, 0, length - 1);

    for (uint32_t i = minOverlapIndex; i < maxOverlapIndex; ++i)
        overlapSSTs.push_back(levelSSTs[i]);

    return overlapSSTs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %r8, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
addq $0x20, %r13
movq %r13, %rdi
callq 0xe280
movq (%rax), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0xa4fc
movq %r15, (%rsp)
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0xe280
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xcf10
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r13
subq (%rdi), %r13
shrq $0x4, %r13
decl %r13d
movq %r12, %rsi
xorl %edx, %edx
movl %r13d, %ecx
callq 0xa254
movl %eax, %ebp
movl %eax, %r15d
movq 0x8(%rsp), %rax
movq %r15, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
callq 0x686c
cmpq %r12, %rax
jae 0xa4ad
cmpl %r13d, %ebp
je 0xa4f2
jae 0xa4ad
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx), %rdi
callq 0x6866
cmpq (%rsp), %rax
ja 0xa4f2
movq %r15, (%r14)
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
movl %r13d, %ecx
callq 0xa254
movq 0x60(%rsp), %r15
incl %eax
movq %rax, (%r15)
movl (%r14), %esi
cmpq %rax, %rsi
jae 0xa4f2
leal 0x1(%rsi), %ebp
shlq $0x4, %rsi
addq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xcdc6
movl %ebp, %esi
incl %ebp
cmpq %rsi, (%r15)
jg 0xa4d8
leaq 0x8(%rsp), %rdi
callq 0xce64
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa510
movq %rax, %r14
jmp 0xa524
jmp 0xa517
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xce64
movq %rbx, %rdi
callq 0xce64
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getCompactionData[abi:cxx11](std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&)
KVPair KVStore::getCompactionData(const vector<SSTPtr>& SSTs) {

    // Sort the SSTs according to their time tokens so that the value of the same key
    // in a newer SST will always overwrite the previous one.

    auto sortByTimeStamp = [](const SSTPtr& sstA, const SSTPtr& sstB) {
        return sstA->getTimeStamp() < sstB->getTimeStamp();
    };

    vector<SSTPtr> tempSSTs(SSTs);
    sort(tempSSTs.begin(), tempSSTs.end(), sortByTimeStamp);

    KVPair sstData;
    for (const auto& sst : tempSSTs)
        sst->getValuesFromDisk(sstData);

    return sstData;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xcf10
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0xa5b7
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xc754
cmpq $0x101, %r12            # imm = 0x101
jl 0xa5ac
leaq 0x100(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xcc43
cmpq %r14, %r12
je 0xa5b7
movq %r12, %rdi
callq 0xccce
addq $0x10, %r12
jmp 0xa599
movq %r15, %rdi
movq %r14, %rsi
callq 0xcc43
leaq 0x30(%rbx), %rax
movq %rax, (%rbx)
movq $0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movups %xmm0, 0x28(%rbx)
movq (%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0xa5f7
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6604
addq $0x10, %r14
jmp 0xa5e1
movq %rsp, %rdi
callq 0xce64
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa610
movq %rax, %r14
jmp 0xa620
movq %rax, %r14
movq %rbx, %rdi
callq 0xd4ca
movq %rsp, %rdi
callq 0xce64
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reconstructLowerLevelDisk(long, long, unsigned long)
void KVStore::reconstructLowerLevelDisk(int64_t minOverlapIndex, int64_t maxOverlapIndex, size_t lowerLevel) {

    if (minOverlapIndex == -1 && maxOverlapIndex == -1)
        return;

    vector<SSTPtr> previousSSTs = *ssTables[lowerLevel];
    for (uint32_t i = minOverlapIndex; i < maxOverlapIndex; ++i)
        removeSSTFromDisk(previousSSTs[i]);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rax
andq %rsi, %rax
cmpq $-0x1, %rax
je 0xa697
movq %rdx, %rbx
movq %rsi, %r14
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0xe280
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0xcf10
movl %r14d, %edi
cmpq %rbx, %rdi
jge 0xa68d
incl %r14d
shlq $0x4, %rdi
addq 0x10(%rsp), %rdi
callq 0xc698
movl %r14d, %edi
incl %r14d
cmpq %rbx, %rdi
jb 0xa674
leaq 0x10(%rsp), %rdi
callq 0xce64
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xce64
movq %rbx, %rdi
callq 0x3460