LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa69b(%rip), %rdi      # 0x11fd0
leaq 0x3a7c(%rip), %rsi      # 0xb3b8
callq 0x2200
xorl %r15d, %r15d
leaq -0x140(%rbp), %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x4, %rax
cmpq %rax, %r15
je 0x7a43
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ff0
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x6b30
movslq %eax, %rsi
movq %r14, %rdi
callq 0x36ce
leaq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x28ba
movq %r13, %rdi
callq 0x6b38
movslq %eax, %rsi
movq %r14, %rdi
callq 0x36ce
movq %r12, %rdi
movq %rax, %rsi
callq 0x28ba
leaq -0xc0(%rbp), %rdi
callq 0x6aca
movq 0xa628(%rip), %rdi      # 0x11ff0
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x39f6(%rip), %rsi      # 0xb3d0
callq 0x2200
movq %rax, %r13
movq %r12, %rdi
callq 0x6aca
movq %r13, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x38ea(%rip), %rsi      # 0xb2e9
callq 0x2200
movq %rax, %r13
leaq -0x40(%rbp), %rdi
callq 0x6b42
movq %r13, %rdi
callq 0x2320
movq %rax, %rdi
leaq 0x39ac(%rip), %rsi      # 0xb3ce
callq 0x2200
movq %r12, %rdi
callq 0x2918
leaq -0xc0(%rbp), %rdi
callq 0x2918
incq %r15
jmp 0x794b
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7a69
movq %rax, %rbx
leaq -0x140(%rbp), %rdi
callq 0x2918
leaq -0xc0(%rbp), %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
callq 0x41a8
cmpq %r14, %rax
je 0x7b23
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36ce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x53ec
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x7b16
leaq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x5012
jmp 0x7afe
movq %r15, %rdi
callq 0x2a4a
incq %r14
jmp 0x7acd
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2a4a
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0xa8(%rbp), %r15
leaq 0x375f(%rip), %r13      # 0xb466
movq %rbx, %rdi
callq 0x41a8
cmpq %rax, %r14
je 0x7e0d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x28ba
movq %r15, %rdi
callq 0x6aca
movq 0xa2b3(%rip), %rdi      # 0x11ff0
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x36d3(%rip), %rsi      # 0xb422
callq 0x2200
movq %rax, %rdi
movl %r14d, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x36c3(%rip), %rsi      # 0xb42c
callq 0x2200
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x412c
movq %r12, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x36a9(%rip), %rsi      # 0xb439
callq 0x2200
movq %rax, %r12
movq %r15, %rdi
callq 0x6aca
movq %r12, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x36a3(%rip), %rsi      # 0xb458
callq 0x2200
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4152
movq %r12, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
movq %r13, %rsi
callq 0x2200
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4178
movq %r12, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2918
incq %r14
jmp 0x7d07
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa199(%rip), %rdi      # 0x11ff0
leaq 0x35de(%rip), %rsi      # 0xb43c
callq 0x2200
movq %rax, %rdi
callq 0x2120
leaq -0xa8(%rbp), %r12
leaq 0x35eb(%rip), %r15      # 0xb464
movq 0x30(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7f60
cmpq 0x38(%rbx), %rsi
jne 0x7e9d
movq 0x48(%rbx), %rax
movq -0x8(%rax), %rsi
movl $0x200, %eax            # imm = 0x200
addq %rax, %rsi
addq $-0x80, %rsi
movq %r12, %rdi
callq 0x28ba
movq 0xa140(%rip), %rdi      # 0x11ff0
leaq 0x3593(%rip), %rsi      # 0xb44a
callq 0x2200
movq %rax, %r13
movq %r12, %rdi
callq 0x6aca
movq %r13, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x3550(%rip), %rsi      # 0xb42c
callq 0x2200
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x412c
movq %r13, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x3553(%rip), %rsi      # 0xb456
callq 0x2200
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x4152
movq %r13, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x4178
movq %r13, %rdi
movl %eax, %esi
callq 0x2360
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x8404
movq %r12, %rdi
callq 0x2918
jmp 0x7e79
movq 0xa089(%rip), %rdi      # 0x11ff0
leaq 0x3502(%rip), %rsi      # 0xb470
callq 0x2200
movq %rax, %rdi
callq 0x2120
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/BFS.cpp
// Function: BFS(Graph&, Node&)
void BFS(Graph & g, Node & s) {
	queue<Node> q;
	
	g.resetAllDist();
	
	g.setDist(s, 0); //s is the root 
	q.push(s);
	
	while ( !q.empty() ) {
		Node u = q.front();
		q.pop();
		
		set<Node> uAdjNodes = g.getAdjNodes(u);
		
		//for every adjacent node v: (u)--->(v)
		for(set<Node>::iterator v = uAdjNodes.begin(); v != uAdjNodes.end(); v++) {
			if(g.dist(*v) == M_INFINITY) {		//if v has not been visited in BFS
				g.setDist(*v, g.dist(u) + 1);	//v.dist == u.dist + 1
				q.push(*v);						//push the adjacent node to back of the queue
			}
		} //end adjNodes loop
	} //end while
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x85d8
movq %rbx, %rdi
callq 0x45f0
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fba
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
callq 0x8942
leaq -0x50(%rbp), %r15
leaq -0x128(%rbp), %r14
leaq -0x58(%rbp), %r12
movq -0x98(%rbp), %rsi
cmpq %rsi, -0x78(%rbp)
je 0x8581
movq %r14, %rdi
callq 0x28ba
leaq -0xa8(%rbp), %rdi
callq 0x8bd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x428a
movq %r12, %rdi
movq %rax, %rsi
callq 0x5516
movq -0x40(%rbp), %r13
cmpq %r15, %r13
je 0x8568
leaq 0x20(%r13), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4106
ucomisd 0x2b3e(%rip), %xmm0     # 0xb068
jne 0x855b
jp 0x855b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4106
addsd 0x2b17(%rip), %xmm0     # 0xb058
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3fba
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x8942
movq %r13, %rdi
callq 0x2260
movq %rax, %r13
jmp 0x850e
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x2aa8
movq %r14, %rdi
callq 0x2918
jmp 0x84cf
leaq -0xa8(%rbp), %rdi
callq 0x85f8
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x85a1
movq %rax, %rbx
jmp 0x85c3
movq %rax, %rbx
jmp 0x85b7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2aa8
leaq -0x128(%rbp), %rdi
callq 0x2918
leaq -0xa8(%rbp), %rdi
callq 0x85f8
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
movq %rsi, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x8ca7
movups 0x10(%r13), %xmm0
movaps %xmm0, -0x40(%rbp)
movq %r15, %rdi
callq 0x6b38
movl %eax, %r12d
movq %r14, %rdi
callq 0x6ac0
cmpl %eax, %r12d
jne 0x8c72
leaq -0x40(%rbp), %rdi
callq 0x6b42
jmp 0x8cca
movq 0x9342(%rip), %rdi      # 0x11ff0
leaq 0x2843(%rip), %rsi      # 0xb4f8
callq 0x2200
movq %rax, %rdi
callq 0x2120
movsd 0x2826(%rip), %xmm0     # 0xb4f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x41a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa4b8
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x41a8
cmpq %r15, %rax
je 0x9b86
movq %r14, %rdi
movq %r15, %rsi
callq 0x36ce
movq %r14, %rdi
movq %rax, %rsi
callq 0x42ce
movq %r12, %rdi
movq %rax, %rsi
callq 0x53ec
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x9b79
leaq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x4f34
jmp 0x9b62
movq %r12, %rdi
callq 0x2a4a
incq %r15
jmp 0x9b31
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b9c
jmp 0x9b9c
movq %rax, %r14
jmp 0x9bad
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2a4a
movq %rbx, %rdi
callq 0x29fc
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rdi, %rbx
callq 0x4178
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4178
movl %eax, %r15d
xorl %r12d, %r12d
leaq -0xa8(%rbp), %r13
movq %rbx, %rdi
callq 0x41a8
cmpq %rax, %r12
je 0x9d45
movq %rbx, %rdi
movq %r12, %rsi
callq 0x36ce
movq %r13, %rdi
movq %rax, %rsi
callq 0x28ba
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4178
cmpl %r15d, %eax
jne 0x9d38
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x3fea
movq %r13, %rdi
callq 0x2918
incq %r12
jmp 0x9cf7
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x98(%rbp), %r15
movq %rbx, %rdi
callq 0x41a8
cmpq %rax, %r14
je 0x9de0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x28ba
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x4014
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3f16
movq %r15, %rdi
callq 0x2918
incq %r14
jmp 0x9d95
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x130(%rbp), %r13
movq %r13, %rdi
callq 0x28ba
movq %r14, %rdi
movq %r13, %rsi
callq 0x9e05
movl %eax, -0x2c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x2918
leaq -0xb0(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x28ba
movq %r14, %rdi
movq %r13, %rsi
callq 0x9e05
movl %eax, %r12d
leaq -0xb0(%rbp), %rdi
callq 0x2918
cmpl %r12d, -0x2c(%rbp)
je 0x9f9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41ea
movl %eax, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x41ea
cmpl %eax, %r13d
jge 0x9f52
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x4014
jmp 0x9f9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41ea
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x41ea
movl %eax, %r13d
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0x4014
cmpl %r13d, %r12d
jg 0x9f9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41ea
leal 0x1(%rax), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f16
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9fae
movq %rax, %rbx
movq %r13, %rdi
callq 0x2918
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/jkeys-ecg-nmsu[P]graph-with-search-algorithms/Kruskal.cpp
// Function: Kruskal_MST_djsets(Graph&)
Graph Kruskal_MST_djsets ( Graph & g) {	
	Graph r(g.num_nodes() + 1);
	r.copyNodes(g);
	r.copyEdges(g);
		
	make_set(g);
	
	vector<Edge> E = get_all_edges(g);
	
	// make_edge_heap(E);
	
	sort(E.begin(), E.end(), edge_heap_comp);
	
	// while(!E.empty()) {
	for(int i = 0; i != E.size(); i++) {
		// Edge e = cheapest_edge(E); //get cheapest edge and pop
		Edge e = E.at(i);
		Node u = g.getNode(e.u_id());
		Node v = g.getNode(e.v_id());
		
		if(find(g, u) != find(g,v)) {
			// cerr << "in djsets, sets are disjoint, edge: ";
			// e.print(r);			
			
			r.pushEdge(e);
			MST_union(g, u, v);
		}
	}
	
	return r; //MST is contained in m_edges_MST
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x41a8
leal 0x1(%rax), %esi
movq %rbx, %rdi
callq 0x2cbc
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4724
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x476c
movq %r14, %rdi
callq 0x9d78
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x9af5
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x8f0(%rip), %rdx      # 0x99a8
callq 0xa796
xorl %r15d, %r15d
leaq -0x260(%rbp), %rbx
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x4, %rax
cmpq %rax, %r15
je 0xa3b3
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x4ff0
movups (%rax), %xmm0
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6b30
movslq %eax, %rsi
movq %r14, %rdi
callq 0x36ce
leaq -0x160(%rbp), %rdi
movq %rax, %rsi
callq 0x28ba
leaq -0x60(%rbp), %rdi
callq 0x6b38
movslq %eax, %rsi
movq %r14, %rdi
callq 0x36ce
leaq -0xe0(%rbp), %rdi
movq %rax, %rsi
callq 0x28ba
leaq -0x1e0(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x28ba
movq %r14, %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x9e05
movl %eax, %r13d
movq %rbx, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x28ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e05
movl %eax, %r12d
movq %rbx, %rdi
callq 0x2918
leaq -0x1e0(%rbp), %rdi
callq 0x2918
cmpl %r12d, %r13d
je 0xa393
movq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4086
movq %r14, %rdi
leaq -0x160(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x9eac
leaq -0xe0(%rbp), %rdi
callq 0x2918
leaq -0x160(%rbp), %rdi
callq 0x2918
incq %r15
jmp 0xa2a7
leaq -0x48(%rbp), %rdi
callq 0x29fc
movq -0x30(%rbp), %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa410
jmp 0xa3d6
movq %rax, %rbx
jmp 0xa42d
jmp 0xa410
movq %rax, %rbx
leaq -0x260(%rbp), %rdi
callq 0x2918
jmp 0xa3f6
movq %rax, %rbx
jmp 0xa402
movq %rax, %rbx
leaq -0x1e0(%rbp), %rdi
callq 0x2918
leaq -0xe0(%rbp), %rdi
callq 0x2918
jmp 0xa418
movq %rax, %rbx
jmp 0xa424
movq %rax, %rbx
leaq -0x160(%rbp), %rdi
callq 0x2918
leaq -0x48(%rbp), %rdi
callq 0x29fc
movq -0x30(%rbp), %rdi
callq 0x2938
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/xx01cyx[P]LSM-Tree/correctness.cc
// Function: main
int main(int argc, char *argv[])
{
	bool verbose = (argc == 2 && std::string(argv[1]) == "-v");

	std::cout << "Usage: " << argv[0] << " [-v]" << std::endl;
	std::cout << "  -v: print extra info for failed tests [currently ";
	std::cout << (verbose ? "ON" : "OFF")<< "]" << std::endl;
	std::cout << std::endl;
	std::cout.flush();

	CorrectnessTest test("./data", verbose);

	test.start_test();

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r15
cmpl $0x2, %edi
jne 0x36c1
movq 0x8(%r15), %rsi
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x37ce
leaq 0xa957(%rip), %rsi      # 0xe004
movq %r14, %rdi
callq 0x3809
movl %eax, %ebx
movq %r14, %rdi
callq 0x34a8
jmp 0x36c3
xorl %ebx, %ebx
movq 0x11906(%rip), %r14     # 0x14fd0
leaq 0xa936(%rip), %rsi      # 0xe007
movq %r14, %rdi
callq 0x3230
movq (%r15), %rsi
movq %rax, %rdi
callq 0x3230
leaq 0xa924(%rip), %rsi      # 0xe00f
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
leaq 0xa913(%rip), %rsi      # 0xe015
movq %r14, %rdi
callq 0x3230
leaq 0xa938(%rip), %rax      # 0xe049
leaq 0xa934(%rip), %rsi      # 0xe04c
testb %bl, %bl
cmovneq %rax, %rsi
movq %r14, %rdi
callq 0x3230
leaq 0xa9bf(%rip), %rsi      # 0xe0ec
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3180
leaq 0xa8fc(%rip), %rsi      # 0xe050
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x37ce
movzbl %bl, %edx
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3816
leaq 0x10(%rsp), %rdi
callq 0x34a8
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3842
leaq 0x30(%rsp), %rdi
callq 0x38ba
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x38ba
jmp 0x37c5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x34a8
jmp 0x37c5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11780(%rip), %r14     # 0x14fd0
leaq 0xa818(%rip), %rsi      # 0xe06f
movq %r14, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
leaq 0xa81a(%rip), %rsi      # 0xe088
movq %r14, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq 0x90(%rbx), %rsi
movq %rbx, %rdi
callq 0x3924
leaq 0xa802(%rip), %rsi      # 0xe096
movq %r14, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq 0x98(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3924
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10b04(%rip), %r14     # 0x14fd0
leaq 0x9c04(%rip), %rsi      # 0xe0d7
movq %r14, %rdi
callq 0x3230
movq 0x18(%rbx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x9b1b(%rip), %rsi      # 0xe00c
movq %rax, %rdi
callq 0x3230
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3170
leaq 0x9da6(%rip), %rsi      # 0xe2b2
movq %rax, %rdi
callq 0x3230
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x9ae2(%rip), %rsi      # 0xe00d
movq %rax, %rdi
callq 0x3230
incq 0x18(%rbx)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x454e
incq 0x20(%rbx)
leaq 0x9b94(%rip), %rsi      # 0xe0e0
jmp 0x4555
leaq 0x9b92(%rip), %rsi      # 0xe0e7
movq 0x10a74(%rip), %rbx     # 0x14fd0
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3180
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
pushq $0x10
popq %rdi
callq 0x3030
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
callq 0x4dd0
movq (%r14), %rcx
xorl %esi, %esi
movl $0x2800, %edi           # imm = 0x2800
cmpq $0x4, %rsi
je 0x4d4c
movl (%rbx,%rsi,4), %eax
xorl %edx, %edx
divl %edi
movb $0x1, (%rcx,%rdx)
incq %rsi
jmp 0x4d36
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
pushq $0x10
popq %rdi
callq 0x3030
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
callq 0x4dd0
movq (%r14), %rdi
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
movl $0x2800, %r8d           # imm = 0x2800
xorl %edx, %edx
divl %r8d
movl %edx, %esi
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
movb (%rdi,%rdx), %cl
andb (%rdi,%rsi), %cl
movl 0x8(%rbx), %eax
xorl %edx, %edx
divl %r8d
andb (%rdi,%rdx), %cl
movl 0xc(%rbx), %eax
xorl %edx, %edx
divl %r8d
andb (%rdi,%rdx), %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rdi
movq %rdx, %rsi
callq 0x4d56
testb %al, %al
je 0x50de
leaq 0x30(%r14), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x586a
movq 0x10(%r14), %r8
decq %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x5116
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5a44
testq %r15, %r15
js 0x50de
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x51fa
jmp 0x50f2
leaq 0x8f29(%rip), %rsi      # 0xe00e
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x37ce
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a44
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rcx, %rbp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %r15
movq %r8, %rax
movq (%rdx), %rsi
subq %rbp, %rax
jg 0x514b
movq %rbp, %rdx
shlq $0x4, %rdx
cmpq %r14, (%rsi,%rdx)
jne 0x51c5
pushq $0x2
popq %rdi
cqto
idivq %rdi
movq %rax, %rbx
addq %rbp, %rbx
movq %rbx, %rax
shlq $0x4, %rax
cmpq %r14, (%rsi,%rax)
jbe 0x518f
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x586a
decq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x5116
jmp 0x51b8
jae 0x51c8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x586a
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x5116
movq %rax, %rbx
movq %r12, %rdi
callq 0x5a44
jmp 0x51c8
pushq $-0x1
popq %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x51ec
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a44
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x533e
leaq 0x28(%rsp), %rdi
pushq $0xc
popq %rdx
movq %r12, %rsi
callq 0x33d0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x52ca
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 0x5283
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x32e0
leaq 0x28(%rsp), %rdi
callq 0x3430
movq %rax, %rcx
jmp 0x5287
movl 0x18(%rax,%rcx), %ecx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x55a2
leaq 0x28(%rsp), %rdi
callq 0x3040
leaq 0x28(%rsp), %rdi
callq 0x3070
leaq 0x8(%rsp), %rdi
callq 0x34a8
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xfd1f(%rip), %rdi      # 0x14ff0
leaq 0x8ec4(%rip), %rsi      # 0xe19c
callq 0x3230
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x31e0
leaq 0x8ebe(%rip), %rsi      # 0xe1af
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
pushq $-0x1
popq %rdi
callq 0x3280
jmp 0x531f
jmp 0x531f
movq %rax, %r14
movq %rbx, %rdi
callq 0x34a8
jmp 0x5322
movq %rax, %r14
jmp 0x532c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3070
leaq 0x8(%rsp), %rdi
callq 0x34a8
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/xx01cyx[P]LSM-Tree/SSTable.cc
// Function: SSTable::getFilename[abi:cxx11]() const
string SSTable::getFilename() const {
    return "./data/level-" + to_string(level)
           + "/table-" + to_string(header.timeStamp)
           + "-" + to_string(header.minKey)
           + "-" + to_string(header.maxKey)
           + ".sst";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x140(%rsp), %r15
movq %r15, %rdi
callq 0x5964
leaq 0x8e48(%rip), %rsi      # 0xe1b2
leaq 0x60(%rsp), %rdi
movq %r15, %rdx
callq 0x5940
leaq 0x8e42(%rip), %rdx      # 0xe1c0
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x58ba
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %rdi
callq 0x5964
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x58d9
leaq 0x8e07(%rip), %rdx      # 0xe1c6
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x58ba
movq 0x18(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x5964
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x58d9
leaq 0x8dc3(%rip), %rdx      # 0xe1c6
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x58ba
movq 0x20(%r14), %rsi
movq %rsp, %rdi
callq 0x5964
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
movq %rsp, %rdx
callq 0x58d9
leaq 0x8d85(%rip), %rdx      # 0xe1c8
leaq 0x120(%rsp), %rsi
movq %rbx, %rdi
callq 0x58ba
leaq 0x120(%rsp), %rdi
callq 0x34a8
movq %rsp, %rdi
callq 0x34a8
leaq 0x100(%rsp), %rdi
callq 0x34a8
leaq 0xe0(%rsp), %rdi
callq 0x34a8
leaq 0x20(%rsp), %rdi
callq 0x34a8
leaq 0xc0(%rsp), %rdi
callq 0x34a8
leaq 0xa0(%rsp), %rdi
callq 0x34a8
leaq 0x40(%rsp), %rdi
callq 0x34a8
leaq 0x80(%rsp), %rdi
callq 0x34a8
leaq 0x60(%rsp), %rdi
callq 0x34a8
leaq 0x140(%rsp), %rdi
callq 0x34a8
movq %rbx, %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x34a8
jmp 0x54f9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x34a8
jmp 0x5506
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x34a8
jmp 0x5518
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x34a8
jmp 0x552a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x34a8
leaq 0xc0(%rsp), %rdi
callq 0x34a8
leaq 0xa0(%rsp), %rdi
callq 0x34a8
leaq 0x40(%rsp), %rdi
callq 0x34a8
leaq 0x80(%rsp), %rdi
callq 0x34a8
leaq 0x60(%rsp), %rdi
callq 0x34a8
leaq 0x140(%rsp), %rdi
callq 0x34a8
movq %rbx, %rdi
callq 0x3440
movq %rax, %rbx
jmp 0x5534
movq %rax, %rbx
jmp 0x5541
movq %rax, %rbx
jmp 0x554e
movq %rax, %rbx
jmp 0x5558
movq %rax, %rbx
jmp 0x5565
movq %rax, %rbx
jmp 0x556f
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %r12d
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
subl %edx, %r14d
movq %r14, %rsi
callq 0x3300
testb %bpl, %bpl
jne 0x55e6
movl %r12d, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x32e0
movq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x32a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x34a8
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r15
cmpq %r15, %r14
je 0x584d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4584
addq $0x10, %r14
jmp 0x5837
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4be4
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x5f6c
movq 0x28(%r15), %r12
testq %r12, %r12
je 0x5f4f
movq 0x28(%r12), %rax
movq %rax, 0x28(%r15)
leaq 0x8(%r12), %rdi
callq 0x34a8
movq %r12, %rdi
movq %r14, %rsi
callq 0x3260
movq (%rbx), %r15
jmp 0x5f23
movq 0x30(%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%r15), %rdi
callq 0x34a8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3260
jmp 0x5f1b
pushq $0x38
popq %rdi
callq 0x3250
andq $0x0, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rax), %rsi
testq %rsi, %rsi
je 0x61b0
movq %rsi, %rax
movq 0x28(%rsi), %rsi
testq %rsi, %rsi
je 0x61aa
cmpq %rdx, (%rsi)
jb 0x6197
je 0x61c6
addq $0x30, %rax
jmp 0x618f
leaq 0x7e57(%rip), %rsi      # 0xe00e
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x37ce
jmp 0x61d2
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r12
xorl %ebp, %ebp
leaq 0x80a4(%rip), %r15      # 0xe29a
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x624d
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x6247
cmpq %r14, (%rdi)
jb 0x6201
jne 0x6247
addq $0x8, %rdi
movq %r15, %rsi
callq 0x3809
testb %al, %al
jne 0x627f
movq 0x28(%rbx), %r13
movq 0x28(%r13), %rax
movq %rax, 0x28(%rbx)
leaq 0x8(%r13), %rdi
callq 0x34a8
movq %r13, %rdi
pushq $0x38
popq %rsi
callq 0x3260
movb $0x1, %bpl
addq $0x30, %rbx
jmp 0x61f9
pushq $0x38
popq %r14
movq (%r12), %r15
testq %r15, %r15
je 0x6281
cmpq $0x0, 0x28(%r15)
jne 0x6281
movq 0x30(%r15), %rax
movq %rax, (%r12)
leaq 0x8(%r15), %rdi
callq 0x34a8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3260
jmp 0x6251
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
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xdaff(%rip), %rax      # 0x14cb8
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 0x40(%rsp), %rdi
callq 0x32f0
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x72ff
movl %eax, %ebp
movq %r12, %rdi
callq 0x34a8
testb %bpl, %bpl
jne 0x7214
movq (%r15), %rdi
callq 0x732e
movq %rsp, %rdi
callq 0xa42f
leaq 0x8(%rbx), %rdi
movq %rsp, %rsi
callq 0xacdc
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6932
movl $0x2820, 0x18(%rbx)     # imm = 0x2820
andq $0x0, 0x18(%r15)
leaq 0x30(%rsp), %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)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa6fc
movq %r15, %rdi
callq 0xa816
movq %rsp, %rdi
callq 0xa44a
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq %r14, %rdi
callq 0xad0a
movq %rsp, %rsi
movq %rax, %rdi
callq 0xb188
leaq 0x8(%rsp), %rdi
callq 0x6932
movq $0x1, 0x58(%rbx)
movq %rbx, %rdi
callq 0x74c2
movq %rbx, %rdi
callq 0x78e0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6932
jmp 0x72e3
jmp 0x72e0
jmp 0x72e0
movq %rax, %r15
movq %r14, %rdi
callq 0xa816
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x6932
movq %r15, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/xx01cyx[P]LSM-Tree/./utils.h
// Function: utils::mkdir(char const*)
static inline int mkdir(const char *path){
        std::string currentPath = "";
        std::string dirName;
        std::stringstream ss(path);

        while (std::getline(ss, dirName, '/')){
            currentPath += dirName;
            if (!dirExists(currentPath) && _mkdir(currentPath.c_str()) != 0){
                return -1;
            }
            currentPath += "/";
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq 0x6cc5(%rip), %rsi      # 0xe00e
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x37ce
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x37ce
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x33a0
leaq 0x30(%rsp), %rdi
callq 0x34a8
leaq 0x90(%rsp), %rbx
leaq 0x50(%rsp), %r14
pushq $0x2f
popq %rbp
leaq 0x10(%rsp), %r15
leaq 0x70(%rsp), %r12
leaq 0x6ef4(%rip), %r13      # 0xe2b2
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3460
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x744f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3490
movq %r12, %rdi
movq %r15, %rsi
callq 0x32f0
movq %r12, %rdi
callq 0x72ff
testb %al, %al
je 0x7405
movq %r12, %rdi
callq 0x34a8
jmp 0x743f
movq 0x10(%rsp), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x3100
movq %r14, %r15
movl %ebp, %r14d
movq %r13, %rbp
movq %rbx, %r13
movl %eax, %ebx
movq %r12, %rdi
callq 0x34a8
testl %ebx, %ebx
movq %r13, %rbx
movq %rbp, %r13
movl %r14d, %ebp
movq %r15, %r14
leaq 0x10(%rsp), %r15
jne 0x744f
movq %r15, %rdi
movq %r13, %rsi
callq 0x3470
jmp 0x73be
leaq 0x90(%rsp), %rdi
callq 0x31a0
leaq 0x50(%rsp), %rdi
callq 0x34a8
leaq 0x10(%rsp), %rdi
callq 0x34a8
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x34a8
jmp 0x74a6
movq %rax, %rbx
jmp 0x74a6
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x31a0
leaq 0x50(%rsp), %rdi
callq 0x34a8
leaq 0x10(%rsp), %rdi
callq 0x34a8
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x820a
testl %eax, %eax
je 0x78fb
movq %rbx, %rdi
callq 0x8274
movq 0x38(%rbx), %r15
pushq $0x1
popq %r14
cmpq %r15, %r14
jae 0x7929
movq %rbx, %rdi
movq %r14, %rsi
callq 0x820a
testl %eax, %eax
je 0x7929
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x8492
incq %r14
jmp 0x7903
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7a1c
movq %rbx, %rdi
callq 0x797a
movq 0x8(%rbx), %rdi
callq 0x5f0c
movl $0x2820, 0x18(%rbx)     # imm = 0x2820
movq %rbx, %rdi
callq 0x78e0
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5fa4
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_O2/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 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6184
leaq 0x681a(%rip), %rsi      # 0xe29a
movq %r12, %rdi
callq 0x3809
testb %al, %al
je 0x7aa5
leaq 0x657b(%rip), %rsi      # 0xe00e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x37ce
jmp 0x7b75
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x7ad2
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
leaq 0x38(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x7b0d
movq %rsi, (%rbx)
movq 0x38(%rsp), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x7b13
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7bb4
leaq 0x67b1(%rip), %rsi      # 0xe29a
leaq 0x8(%rsp), %rdi
callq 0x3809
testb %al, %al
je 0x7b29
leaq 0x6510(%rip), %rsi      # 0xe00e
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x37ce
jmp 0x7b6b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
jmp 0x7b75
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x7b4c
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x7b52
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x34a8
leaq 0x28(%rsp), %rdi
callq 0x34a8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34a8
jmp 0x7ba2
jmp 0x7b9f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x34a8
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x8(%rax)
cmpq $0x0, 0x8(%r15)
je 0x7e42
leaq 0x6466(%rip), %rsi      # 0xe29a
leaq 0x28(%rsp), %rdi
callq 0xa465
movl %eax, %ebp
jmp 0x7e44
xorl %ebp, %ebp
movq 0x8(%r14), %r14
leaq 0x644b(%rip), %rsi      # 0xe29a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x37ce
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5fa4
leaq 0x8(%rsp), %rdi
callq 0x34a8
leaq 0x28(%rsp), %rdi
callq 0x34a8
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34a8
jmp 0x7ea1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x34a8
movq %rbx, %rdi
callq 0x3440
nop