LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Debug.cpp
// Function: printMST(Graph&, std::vector<Edge, std::allocator<Edge>>)
void printMST(Graph & g, vector<Edge> E) {
	cout << "Minimum spanning tree:\n";
	for(int i = 0; i != E.size(); i++) {
		Edge e = E.at(i);
		Node u = g.getNode(e.u_id());
		Node v = g.getNode(e.v_id());
		cerr << u.name() << "<-->" << v.name() << ", weight: " << e.weight() << "\n";
	} 	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x15e1f(%rip), %rdi     # 0x26fd0
leaq 0x91f8(%rip), %rsi      # 0x1a3b0
callq 0x2240
movl $0x0, -0x14(%rbp)
movq -0x148(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x150(%rbp)
callq 0x7f40
movq %rax, %rcx
movq -0x150(%rbp), %rax
cmpq %rcx, %rax
je 0x113d5
movq -0x148(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x7f60
movups (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0xeec0
movq -0x170(%rbp), %rdi
movslq %eax, %rsi
callq 0x5040
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x2b50
movq -0x168(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
callq 0xeed0
movl %eax, -0x154(%rbp)
jmp 0x1125d
movq -0x160(%rbp), %rdi
movl -0x154(%rbp), %eax
movslq %eax, %rsi
callq 0x5040
movq %rax, -0x178(%rbp)
jmp 0x1127b
movq -0x178(%rbp), %rsi
leaq -0x130(%rbp), %rdi
callq 0x2b50
jmp 0x11290
leaq -0xb0(%rbp), %rdi
callq 0xeda0
movq %rax, -0x180(%rbp)
jmp 0x112a5
movq -0x180(%rbp), %rsi
movq 0x15d3d(%rip), %rdi     # 0x26ff0
callq 0x2220
movq %rax, -0x188(%rbp)
jmp 0x112c1
movq -0x188(%rbp), %rdi
leaq 0x90f9(%rip), %rsi      # 0x1a3c8
callq 0x2240
movq %rax, -0x190(%rbp)
jmp 0x112dd
leaq -0x130(%rbp), %rdi
callq 0xeda0
movq %rax, -0x198(%rbp)
jmp 0x112f2
movq -0x198(%rbp), %rsi
movq -0x190(%rbp), %rdi
callq 0x2220
movq %rax, -0x1a0(%rbp)
jmp 0x1130e
movq -0x1a0(%rbp), %rdi
leaq 0x8fcd(%rip), %rsi      # 0x1a2e9
callq 0x2240
movq %rax, -0x1a8(%rbp)
jmp 0x1132a
leaq -0x30(%rbp), %rdi
callq 0xeef0
movsd %xmm0, -0x1b0(%rbp)
jmp 0x1133d
movsd -0x1b0(%rbp), %xmm0
movq -0x1a8(%rbp), %rdi
callq 0x2430
movq %rax, -0x1b8(%rbp)
jmp 0x1135a
movq -0x1b8(%rbp), %rdi
leaq 0x905e(%rip), %rsi      # 0x1a3c6
callq 0x2240
jmp 0x1136f
leaq -0x130(%rbp), %rdi
callq 0x2bd0
leaq -0xb0(%rbp), %rdi
callq 0x2bd0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x111c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x113c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x2bd0
leaq -0xb0(%rbp), %rdi
callq 0x2bd0
jmp 0x113de
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x23e0
nopw (%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Debug.cpp
// Function: printEdges(Graph&)
void printEdges(Graph & g) {	
	for(int i = 0; i != g.num_nodes(); i++) {
		list<Edge> edge_list = g.getEdges(g.getNode(i));
		for(list<Edge>::iterator e = edge_list.begin(); e != edge_list.end(); e++) {
			e->print(g);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0x11516
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5040
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x6360
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8870
leaq -0x28(%rbp), %rdi
callq 0x8930
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8990
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8960
testb $0x1, %al
jne 0x114be
jmp 0x114ff
leaq -0x30(%rbp), %rdi
callq 0x89c0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7fa0
jmp 0x114d5
jmp 0x114d7
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x89e0
movq %rax, -0x50(%rbp)
jmp 0x1149e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30b0
jmp 0x1151c
leaq -0x28(%rbp), %rdi
callq 0x30b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11443
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Debug.cpp
// Function: printTimes(Graph&)
void printTimes(Graph & g) {
	for (int i = 0; i != g.num_nodes(); i++) {
		Node e = g.getNode(i);
		cerr << e.name() << ".id() == " << i << ", .pre() == " << g.pre(e) << ", " << e.name() 
			 << ".post() == " << g.post(e) << ".cc() == " << g.cc(e) << endl;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
je 0x11a1e
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5040
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2b50
movq -0xb8(%rbp), %rdi
callq 0xeda0
movq %rax, -0xb0(%rbp)
jmp 0x11845
movq -0xb0(%rbp), %rsi
movq 0x1579d(%rip), %rdi     # 0x26ff0
callq 0x2220
movq %rax, -0xc0(%rbp)
jmp 0x11861
movq -0xc0(%rbp), %rdi
leaq 0x8bab(%rip), %rsi      # 0x1a41a
callq 0x2240
movq %rax, -0xc8(%rbp)
jmp 0x1187d
movq -0xc8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x23d0
movq %rax, -0xd0(%rbp)
jmp 0x11895
movq -0xd0(%rbp), %rdi
leaq 0x8b81(%rip), %rsi      # 0x1a424
callq 0x2240
movq %rax, -0xd8(%rbp)
jmp 0x118b1
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6020
movl %eax, -0xdc(%rbp)
jmp 0x118c9
movl -0xdc(%rbp), %esi
movq -0xd8(%rbp), %rdi
callq 0x23d0
movq %rax, -0xe8(%rbp)
jmp 0x118e4
movq -0xe8(%rbp), %rdi
leaq 0x8b3f(%rip), %rsi      # 0x1a431
callq 0x2240
movq %rax, -0xf0(%rbp)
jmp 0x11900
leaq -0x90(%rbp), %rdi
callq 0xeda0
movq %rax, -0xf8(%rbp)
jmp 0x11915
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdi
callq 0x2220
movq %rax, -0x100(%rbp)
jmp 0x11931
movq -0x100(%rbp), %rdi
leaq 0x8b11(%rip), %rsi      # 0x1a450
callq 0x2240
movq %rax, -0x108(%rbp)
jmp 0x1194d
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6060
movl %eax, -0x10c(%rbp)
jmp 0x11965
movl -0x10c(%rbp), %esi
movq -0x108(%rbp), %rdi
callq 0x23d0
movq %rax, -0x118(%rbp)
jmp 0x11980
movq -0x118(%rbp), %rdi
leaq 0x8ad0(%rip), %rsi      # 0x1a45e
callq 0x2240
movq %rax, -0x120(%rbp)
jmp 0x1199c
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x60a0
movl %eax, -0x124(%rbp)
jmp 0x119b4
movl -0x124(%rbp), %esi
movq -0x120(%rbp), %rdi
callq 0x23d0
movq %rax, -0x130(%rbp)
jmp 0x119cf
movq -0x130(%rbp), %rdi
movq 0x155e3(%rip), %rsi     # 0x26fc0
callq 0x2280
jmp 0x119e4
leaq -0x90(%rbp), %rdi
callq 0x2bd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x117e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2bd0
jmp 0x11a27
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Debug.cpp
// Function: printStack(Graph&, std::stack<Node, std::deque<Node, std::allocator<Node>>>)
void printStack(Graph & g, stack<Node> s) {
	cerr << "Top of stack:" << endl;
	while( !s.empty() ) {
		Node v = s.top();
		cerr << "s.top() == " << v.name() << ", .pre() == " << g.pre(v) 
			 << ", .post() == " << g.post(v) << ", .cc() == " << g.cc(v) << endl;
		
		s.pop();
	}
	
	cerr << ": Bottom of stack" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1558f(%rip), %rdi     # 0x26ff0
leaq 0x89cc(%rip), %rsi      # 0x1a434
callq 0x2240
movq %rax, %rdi
movq 0x15549(%rip), %rsi     # 0x26fc0
callq 0x2280
movq -0xa8(%rbp), %rdi
callq 0x12110
xorb $-0x1, %al
testb $0x1, %al
jne 0x11a93
jmp 0x11c3c
movq -0xa8(%rbp), %rdi
callq 0x12130
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x2b50
movq 0x1553b(%rip), %rdi     # 0x26ff0
leaq 0x8986(%rip), %rsi      # 0x1a442
callq 0x2240
movq %rax, -0xb0(%rbp)
jmp 0x11aca
leaq -0x90(%rbp), %rdi
callq 0xeda0
movq %rax, -0xb8(%rbp)
jmp 0x11adf
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x2220
movq %rax, -0xc0(%rbp)
jmp 0x11afb
movq -0xc0(%rbp), %rdi
leaq 0x891b(%rip), %rsi      # 0x1a424
callq 0x2240
movq %rax, -0xc8(%rbp)
jmp 0x11b17
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6020
movl %eax, -0xcc(%rbp)
jmp 0x11b2f
movl -0xcc(%rbp), %esi
movq -0xc8(%rbp), %rdi
callq 0x23d0
movq %rax, -0xd8(%rbp)
jmp 0x11b4a
movq -0xd8(%rbp), %rdi
leaq 0x88f6(%rip), %rsi      # 0x1a44e
callq 0x2240
movq %rax, -0xe0(%rbp)
jmp 0x11b66
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6060
movl %eax, -0xe4(%rbp)
jmp 0x11b7e
movl -0xe4(%rbp), %esi
movq -0xe0(%rbp), %rdi
callq 0x23d0
movq %rax, -0xf0(%rbp)
jmp 0x11b99
movq -0xf0(%rbp), %rdi
leaq 0x88b5(%rip), %rsi      # 0x1a45c
callq 0x2240
movq %rax, -0xf8(%rbp)
jmp 0x11bb5
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x60a0
movl %eax, -0xfc(%rbp)
jmp 0x11bcd
movl -0xfc(%rbp), %esi
movq -0xf8(%rbp), %rdi
callq 0x23d0
movq %rax, -0x108(%rbp)
jmp 0x11be8
movq -0x108(%rbp), %rdi
movq 0x153ca(%rip), %rsi     # 0x26fc0
callq 0x2280
jmp 0x11bfd
movq -0xa8(%rbp), %rdi
callq 0x12150
jmp 0x11c0b
leaq -0x90(%rbp), %rdi
callq 0x2bd0
jmp 0x11a7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2bd0
jmp 0x11c67
movq 0x153ad(%rip), %rdi     # 0x26ff0
leaq 0x881e(%rip), %rsi      # 0x1a468
callq 0x2240
movq %rax, %rdi
movq 0x15367(%rip), %rsi     # 0x26fc0
callq 0x2280
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Dijkstra.cpp
// Function: findEdgeWeight(Node, std::__cxx11::list<Edge, std::allocator<Edge>>)
double findEdgeWeight(Node v, list<Edge> uEdges) { //find the destination node v containing edge from u
	for(list<Edge>::iterator itr = uEdges.begin(); itr != uEdges.end(); itr++) {
		Edge e = *itr;
		if(e.v_id() == v.id()) 
			return e.weight();
	}
	
	cerr << "findEdgeWeight: should never reach here!" << endl;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x8930
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
callq 0x8990
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8960
testb $0x1, %al
jne 0x14bfc
jmp 0x14c55
leaq -0x20(%rbp), %rdi
callq 0x161e0
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xeed0
movq -0x50(%rbp), %rdi
movl %eax, -0x5c(%rbp)
callq 0xed80
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jne 0x14c42
leaq -0x38(%rbp), %rdi
callq 0xeef0
movsd %xmm0, -0x8(%rbp)
jmp 0x14c84
jmp 0x14c44
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x89e0
movq %rax, -0x40(%rbp)
jmp 0x14bdc
movq 0x12394(%rip), %rdi     # 0x26ff0
leaq 0x588d(%rip), %rsi      # 0x1a4f0
callq 0x2240
movq %rax, %rdi
movq 0x1234e(%rip), %rsi     # 0x26fc0
callq 0x2280
movsd 0x5869(%rip), %xmm0     # 0x1a4e8
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Kruskal.cpp
// Function: get_all_edges(Graph&)
vector<Edge> get_all_edges(Graph & g) {
	vector<Edge> E;
	E.reserve(g.num_nodes());
	
	for(int i = 0; i != g.num_nodes(); i++) {
		list<Edge> edge_list = g.getEdges(g.getNode(i));
		for(list<Edge>::iterator e = edge_list.begin(); e != edge_list.end(); e++) {
			E.push_back(*e);
		}
	}
	
	return E;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x76f0
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, -0x60(%rbp)
jmp 0x16d66
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x17f10
jmp 0x16d75
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, -0x78(%rbp)
jmp 0x16d93
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
je 0x16e82
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movslq -0x28(%rbp), %rsi
callq 0x5040
movq %rax, -0x88(%rbp)
jmp 0x16dc1
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x6360
movq %rax, -0x98(%rbp)
jmp 0x16ddd
movq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8870
jmp 0x16def
leaq -0x40(%rbp), %rdi
callq 0x8930
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8990
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8960
testb $0x1, %al
jne 0x16e1c
jmp 0x16e6b
leaq -0x48(%rbp), %rdi
callq 0x161e0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x7be0
jmp 0x16e33
jmp 0x16e35
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x89e0
movq %rax, -0x58(%rbp)
jmp 0x16dfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x16ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30b0
jmp 0x16ea2
leaq -0x40(%rbp), %rdi
callq 0x30b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x16d7c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x16e95
movq -0x70(%rbp), %rdi
callq 0x2c50
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2c50
movq -0x20(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: jkeys-ecg-nmsu[P]graph-with-search-algorithms/Kruskal.cpp
// Function: union_set_cc(Graph&, Node, Node)
void union_set_cc(Graph & g, Node u_in, Node v_in) {
	int new_cc = g.cc(u_in);
	int orig_cc = g.cc(v_in);
	for(int i = 0; i != g.num_nodes(); i++) {
		Node n = g.getNode(i);
		if(g.cc(n) == orig_cc) {
			g.setCC(n, new_cc);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60a0
movq -0xc0(%rbp), %rsi
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60a0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
je 0x171a2
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x5040
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x2b50
movq -0xd8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x60a0
movl %eax, -0xcc(%rbp)
jmp 0x17146
movl -0xcc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x17188
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0xa8(%rbp), %rsi
callq 0x5da0
jmp 0x17166
jmp 0x17188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2bd0
jmp 0x171ab
leaq -0xa8(%rbp), %rdi
callq 0x2bd0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x170e4
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x23e0
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
je 0x172a3
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5040
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2b50
movq -0xb0(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
callq 0x5df0
jmp 0x17255
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
xorl %edx, %edx
callq 0x5c20
jmp 0x17269
leaq -0x90(%rbp), %rdi
callq 0x2bd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x171f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2bd0
jmp 0x172ac
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x23e0
nopl (%rax,%rax)
// File: 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
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x2b50
movq -0x148(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x172c0
movl %eax, -0x134(%rbp)
jmp 0x17424
leaq -0xa0(%rbp), %rdi
callq 0x2bd0
movl -0x134(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x130(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x2b50
movq -0x160(%rbp), %rdi
movq -0x158(%rbp), %rsi
callq 0x172c0
movl %eax, -0x14c(%rbp)
jmp 0x17476
leaq -0x130(%rbp), %rdi
callq 0x2bd0
movl -0x14c(%rbp), %eax
movl %eax, -0xb0(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xb0(%rbp), %eax
jne 0x174e4
jmp 0x175b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2bd0
jmp 0x175bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x2bd0
jmp 0x175bc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6180
movl %eax, -0x164(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6180
movl %eax, %ecx
movl -0x164(%rbp), %eax
cmpl %ecx, %eax
jge 0x17528
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xb0(%rbp), %edx
callq 0x5df0
jmp 0x175b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6180
movl %eax, -0x168(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6180
movl %eax, %ecx
movl -0x168(%rbp), %eax
cmpl %ecx, %eax
jle 0x17566
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5df0
jmp 0x175b1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5df0
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6180
movq -0x178(%rbp), %rdi
movq -0x170(%rbp), %rsi
movl %eax, %edx
addl $0x1, %edx
callq 0x5c20
jmp 0x175b3
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x23e0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2d331(%rip), %rdi     # 0x31fd0
leaq 0x1e3c9(%rip), %rsi     # 0x2306f
callq 0x42c0
movq %rax, %rdi
movq 0x2d2fb(%rip), %rsi     # 0x31fb0
callq 0x4300
movq 0x2d30f(%rip), %rdi     # 0x31fd0
leaq 0x1e3c0(%rip), %rsi     # 0x23088
callq 0x42c0
movq %rax, %rdi
movq 0x2d2d9(%rip), %rsi     # 0x31fb0
callq 0x4300
movq -0x18(%rbp), %rdi
movq 0x90(%rdi), %rsi
callq 0x4e00
movq 0x2d2dd(%rip), %rdi     # 0x31fd0
leaq 0x1e39c(%rip), %rsi     # 0x23096
callq 0x42c0
movq %rax, %rdi
movq 0x2d2a7(%rip), %rsi     # 0x31fb0
callq 0x4300
movq -0x18(%rbp), %rdi
movq 0x98(%rdi), %rsi
callq 0x4e00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: xx01cyx[P]LSM-Tree/./test.h
// Function: Test::Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Test(const std::string &dir, bool v=true): store(dir), verbose(v)
	{
		nr_tests = 0;
		nr_passed_tests = 0;
		nr_phases = 0;
		nr_passed_phases = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x2ce22(%rip), %rax     # 0x31b98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xfcf0
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x88(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x2bcd5(%rip), %rdi     # 0x31fd0
leaq 0x1cdd5(%rip), %rsi     # 0x230d7
callq 0x42c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x1, %rsi
callq 0x4080
movq %rax, %rdi
leaq 0x1cce7(%rip), %rsi     # 0x2300c
callq 0x42c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x2bc97(%rip), %rdi     # 0x31fd0
callq 0x4080
movq %rax, %rdi
leaq 0x1cf6a(%rip), %rsi     # 0x232b2
callq 0x42c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4080
movq %rax, %rdi
leaq 0x1cca6(%rip), %rsi     # 0x2300d
callq 0x42c0
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x18(%rcx)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x63ba
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x2bc33(%rip), %rdi     # 0x31fd0
leaq 0x1cd3c(%rip), %rsi     # 0x230e0
callq 0x42c0
movq %rax, %rdi
movq 0x2bbfd(%rip), %rsi     # 0x31fb0
callq 0x4300
jmp 0x63dc
movq 0x2bc0f(%rip), %rdi     # 0x31fd0
leaq 0x1cd1f(%rip), %rsi     # 0x230e7
callq 0x42c0
movq %rax, %rdi
movq 0x2bbd9(%rip), %rsi     # 0x31fb0
callq 0x4300
movq 0x2bbed(%rip), %rdi     # 0x31fd0
callq 0x41c0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x4030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x4190
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x8350
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x8237
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x2800, %ecx           # imm = 0x2800
xorl %edx, %edx
divl %ecx
movq -0x30(%rbp), %rax
movl %edx, -0x20(%rbp)
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x4030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x4190
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x8350
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl $0x2800, %esi           # imm = 0x2800
xorl %edx, %edx
divl %esi
movq -0x30(%rbp), %rax
movl %edx, %edx
movb (%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x2800, %esi           # imm = 0x2800
xorl %edx, %edx
divl %esi
movq -0x30(%rbp), %rax
movl %edx, %esi
movq -0x38(%rbp), %rdx
movl %esi, %esi
movb (%rdx,%rsi), %dl
andb $0x1, %dl
movzbl %dl, %edx
andl %edx, %ecx
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2800, %esi           # imm = 0x2800
xorl %edx, %edx
divl %esi
movq -0x30(%rbp), %rax
movl %edx, %esi
movq -0x28(%rbp), %rdx
movl %esi, %esi
movb (%rdx,%rsi), %dl
andb $0x1, %dl
movzbl %dl, %edx
andl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x2800, %esi           # imm = 0x2800
xorl %edx, %edx
divl %esi
movl -0x1c(%rbp), %eax
movl %edx, %edx
movb (%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x8240
testb $0x1, %al
jne 0x8a96
leaq -0x19(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4570
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x1a5a7(%rip), %rsi     # 0x2300e
callq 0x4b40
jmp 0x8a6e
leaq -0x19(%rbp), %rdi
callq 0x4320
jmp 0x8b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x4320
jmp 0x8b79
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x30, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x9a40
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq 0x10(%rdi), %r8
decq %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x8b90
movq %rax, -0x80(%rbp)
jmp 0x8ae1
leaq -0x50(%rbp), %rdi
callq 0x9b30
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x8b5b
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4570
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0x1a4f3(%rip), %rsi     # 0x2300e
callq 0x4b40
jmp 0x8b22
leaq -0x51(%rbp), %rdi
callq 0x4320
jmp 0x8b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9b30
jmp 0x8b79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x4320
jmp 0x8b79
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rdx
callq 0x8d90
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x8bee
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9b90
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x8bee
movq $-0x1, -0x8(%rbp)
jmp 0x8d76
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x98(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x38(%rbp), %rsi
callq 0x9b90
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq (%rcx), %rax
jae 0x8cca
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9a40
movq -0x80(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
decq %r8
callq 0x8b90
movq %rax, -0xa0(%rbp)
jmp 0x8c97
movq -0xa0(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9b30
jmp 0x8d76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9b30
jmp 0x8d83
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x38(%rbp), %rsi
callq 0x9b90
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq (%rcx), %rax
jbe 0x8d6e
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x9a40
movq -0x80(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0x38(%rbp), %rcx
incq %rcx
movq -0x30(%rbp), %r8
callq 0x8b90
movq %rax, -0xc0(%rbp)
jmp 0x8d41
movq -0xc0(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9b30
jmp 0x8d76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9b30
jmp 0x8d83
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x4410
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x4400
jmp 0x941d
testb $0x1, -0x19(%rbp)
jne 0x944e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x43f0
jmp 0x9435
jmp 0x944e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4608
jmp 0x949a
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x45f0
movq %rax, -0x48(%rbp)
jmp 0x9469
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x43a0
jmp 0x947d
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x9490
movq -0x38(%rbp), %rdi
callq 0x4608
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6410
movq -0x50(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9fb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9fe0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9cc0
testb $0x1, %al
jne 0x99d5
jmp 0x9a15
leaq -0x28(%rbp), %rdi
callq 0x9c60
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x6430
jmp 0x99f1
jmp 0x99f3
leaq -0x28(%rbp), %rdi
callq 0xa010
jmp 0x99c2
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x69d0
jmp 0x9a32
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x9a28
movq -0x60(%rbp), %rdi
callq 0x69d0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4560
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbea6
jmp 0xbe14
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xbe67
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xbe65
movq -0x38(%rbp), %rdi
callq 0xcf60
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0x42f0
jmp 0xbe14
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbea1
movq -0x40(%rbp), %rdi
callq 0xcf60
movq -0x40(%rbp), %rdi
movl $0x38, %esi
callq 0x42f0
jmp 0xbe04
movl $0x38, %edi
callq 0x42e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xcf20
jmp 0xbec1
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0x42f0
movq -0x20(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc2c7
jmp 0xc247
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, -0x49(%rbp)
je 0xc26c
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xc275
jmp 0xc283
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc247
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xc2b6
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq (%rcx), %rax
jne 0xc2b6
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x8, %rsi
callq 0x4120
jmp 0xc30c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc23a
leaq -0x21(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4570
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x16d2b(%rip), %rsi     # 0x2300e
callq 0x4b40
jmp 0xc2ea
leaq -0x21(%rbp), %rdi
callq 0x4320
jmp 0xc30c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4320
jmp 0xc316
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4560
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc427
jmp 0xc350
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, -0x41(%rbp)
je 0xc375
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc37e
jmp 0xc38c
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc350
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xc416
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq (%rcx), %rax
jne 0xc416
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x8, %rdi
leaq 0x16edf(%rip), %rsi     # 0x2329a
callq 0x4bf0
testb $0x1, %al
jne 0xc3c6
jmp 0xc3cf
movb $0x0, -0x1(%rbp)
jmp 0xc499
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xc414
movq -0x50(%rbp), %rdi
callq 0xcf60
movq -0x50(%rbp), %rdi
movl $0x38, %esi
callq 0x42f0
jmp 0xc416
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc343
jmp 0xc429
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x51(%rbp)
je 0xc44c
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xc455
jmp 0xc491
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xc48f
movq -0x60(%rbp), %rdi
callq 0xcf60
movq -0x60(%rbp), %rdi
movl $0x38, %esi
callq 0x42f0
jmp 0xc429
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/MemTable.cc
// Function: MemTable::getLowestHead() const
MemTable::Node* MemTable::getLowestHead() const {
    Node* p = head;
    while (p->down)
        p = p->down;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xce8c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xce73
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x15c00
movq -0xb8(%rbp), %rdi
leaq 0x21f5b(%rip), %rax     # 0x31c80
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x15c20
movq -0xb8(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x15c40
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4120
jmp 0xfd5e
leaq -0x30(%rbp), %rdi
callq 0xff30
movb %al, -0xc1(%rbp)
jmp 0xfd6f
movb -0xc1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xc2(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4608
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0xfd92
jmp 0xfdd2
movq -0x10(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0xff90
jmp 0xfda5
jmp 0xfdd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xff06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4608
jmp 0xff06
leaq -0x50(%rbp), %rdi
callq 0x15c60
jmp 0xfddd
movq -0xb8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x15cd0
movq -0xd8(%rbp), %rdi
callq 0x15d00
movq -0xb8(%rbp), %rax
movl $0x2820, 0x18(%rax)     # imm = 0x2820
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x15c40
movq -0xb8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
addq $0x20, %rdi
callq 0x15d20
movq -0xd0(%rbp), %rdi
callq 0x15d50
leaq -0xa0(%rbp), %rdi
callq 0x15d70
jmp 0xfe70
movq -0xb8(%rbp), %rdi
addq $0x20, %rdi
movq $0x0, -0xa8(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x15de0
movq %rax, -0xe0(%rbp)
jmp 0xfe9b
movq -0xe0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
callq 0x15e10
movq -0xe8(%rbp), %rdi
callq 0x15e40
movq -0xb8(%rbp), %rdi
movq $0x1, 0x58(%rdi)
callq 0x10240
jmp 0xfed7
movq -0xb8(%rbp), %rdi
callq 0x108b0
jmp 0xfee5
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x15e40
movq -0xb0(%rbp), %rdi
callq 0x15d50
movq -0xc0(%rbp), %rdi
callq 0x15d00
movq -0x38(%rbp), %rdi
callq 0x4560
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x11ab0
cmpl $0x0, %eax
je 0x108db
movq -0x28(%rbp), %rdi
callq 0x11b30
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x16520
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10934
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11ab0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x10916
jmp 0x10934
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x11e90
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x108f4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x10b10
testb $0x1, %al
jne 0x10a9b
jmp 0x10ac9
movq -0x20(%rbp), %rdi
callq 0x109c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x15e60
movq %rax, %rdi
callq 0xbdf0
movq -0x20(%rbp), %rdi
movl $0x2820, 0x18(%rdi)     # imm = 0x2820
callq 0x108b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x15e60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbf00
movq -0x18(%rbp), %rdi
callq 0x41e0
movq %rax, %rdx
movq -0x20(%rbp), %rax
addq $0xc, %rdx
movl 0x18(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
callq 0x15e60
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc210
movq -0x80(%rbp), %rdi
leaq 0x126df(%rip), %rsi     # 0x2329a
callq 0x4bf0
movb %al, -0x72(%rbp)
jmp 0x10bc5
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x10bce
jmp 0x10c3a
leaq -0x45(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4570
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq 0x1241b(%rip), %rsi     # 0x2300e
callq 0x4b40
jmp 0x10bfa
leaq -0x45(%rbp), %rdi
callq 0x4320
movl $0x1, -0x4c(%rbp)
jmp 0x10d2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x4320
jmp 0x10d48
leaq -0x38(%rbp), %rdi
callq 0x4480
cmpq $0x0, %rax
je 0x10c65
movq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41a0
movl $0x1, -0x4c(%rbp)
jmp 0x10d2f
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x10d60
jmp 0x10c7b
leaq 0x12618(%rip), %rsi     # 0x2329a
leaq -0x70(%rbp), %rdi
callq 0x4bf0
movb %al, -0xa1(%rbp)
jmp 0x10c93
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x10c9f
jmp 0x10d02
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x4570
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rdx
leaq 0x1234a(%rip), %rsi     # 0x2300e
callq 0x4b40
jmp 0x10ccb
leaq -0x71(%rbp), %rdi
callq 0x4320
movl $0x1, -0x4c(%rbp)
jmp 0x10d19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x4320
jmp 0x10d24
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x41a0
movl $0x1, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4608
jmp 0x10d2f
leaq -0x70(%rbp), %rdi
callq 0x4608
jmp 0x10d48
leaq -0x38(%rbp), %rdi
callq 0x4608
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x4608
movq -0x40(%rbp), %rdi
callq 0x4560
nopw (%rax,%rax)