LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dfs.cpp
// Function: GraphAlgo::dfs::dfs(GraphAlgo::graph const&, int const&)
dfs::
dfs( const graph& g, const vertex& v )
{
	g_in = g;

	m_vertices = g.get_vertices();
	m_neighborhood = g.get_neighborhood();

	vertices::const_iterator it = m_vertices.begin();
	for( ; it != m_vertices.end(); ++it ) 
	{
		m_visit.insert( visit::value_type(*it, false) );
	}
	
	m_visit[v] = true;      
	dfs_traversal(v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x769a
leaq 0x60(%rbx), %r12
movq %r12, %rdi
callq 0x769a
andl $0x0, 0xc8(%rbx)
leaq 0xc0(%rbx), %r15
andq $0x0, 0xd0(%rbx)
leaq 0xc8(%rbx), %rax
movq %rax, 0xd8(%rbx)
movq %rax, 0xe0(%rbx)
leaq 0xf0(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x108(%rbx), %r13
andl $0x0, 0x110(%rbx)
leaq 0x110(%rbx), %rax
andq $0x0, 0x118(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movq %rax, 0x120(%rbx)
movq %rax, 0x128(%rbx)
andq $0x0, 0x130(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, 0x10(%rsp)
callq 0x76e4
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x70ac
leaq 0x18(%rsp), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4886
movq %r12, %rdi
callq 0x4852
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x706c
leaq 0x18(%rsp), %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0x383e
movq %r14, %rdi
callq 0x393e
movq 0xf0(%rbx), %r12
cmpq 0xf8(%rbx), %r12
je 0x4df1
movl (%r12), %eax
movl %eax, 0x18(%rsp)
movb $0x0, 0x1c(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5306
addq $0x4, %r12
jmp 0x4dca
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4e98
movb $0x1, (%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4c38
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e26
jmp 0x4e26
jmp 0x4e26
movq %rax, %r14
jmp 0x4e4d
jmp 0x4e26
movq %rax, %r14
movq %r13, %rdi
callq 0x393e
movq 0x8(%rsp), %rdi
callq 0x4852
movq %r15, %rdi
callq 0x4c06
movq 0x10(%rsp), %rdi
callq 0x76c4
movq %rbx, %rdi
callq 0x76c4
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::print_path()
void dijkstra::
print_path()
{
	vertex s = v_path.front();
	vertex d = v_path.back();
	std::cout << "Shortest path from " << s << " to " << d << " is:" << std::endl;

	vertex_path::const_iterator it = v_path.begin();
	for ( ; it != v_path.end(); ++it ) 
	{
		if ( it == v_path.begin() || it == v_path.end() ) 
		{
			std::cout << *it; 
		} else {
			std::cout << " -> " << *it;	
		} 
	}
	std::cout << std::endl;
	
/*	
	vertex_path::const_iterator it2 = v_path.begin();
	for( ; it2 != v_path.end(); ++it2 ) 
	{
		std::cout << " " << v_distance[*it2];
	}
	std::cout << std::endl;
*/
	
	std::cout << "Hope count: " << v_path.size() - 1 << std::endl;
	std::cout << "Path cost: " << v_distance[d] << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc0(%rdi), %r12
movq 0xc0(%rdi), %rax
movl 0x10(%rax), %ebp
movq 0xc8(%rdi), %rax
movl 0x10(%rax), %r15d
movl %r15d, 0x4(%rsp)
movq 0xcbea(%rip), %r14      # 0x11fd8
leaq 0x4c73(%rip), %rsi      # 0xa068
movq %r14, %rdi
callq 0x2160
movq %rax, %rdi
movl %ebp, %esi
callq 0x2210
leaq 0x4c6e(%rip), %rsi      # 0xa07c
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movl %r15d, %esi
callq 0x2210
leaq 0x4c59(%rip), %rsi      # 0xa081
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
leaq 0x4c47(%rip), %r15      # 0xa086
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x546d
movq %r14, %rdi
cmpq (%r12), %r13
je 0x5462
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
movl 0x10(%r13), %esi
callq 0x2210
jmp 0x5442
movq 0xcb64(%rip), %r14      # 0x11fd8
movq %r14, %rdi
callq 0x20c0
leaq 0x4c08(%rip), %rsi      # 0xa08b
movq %r14, %rdi
callq 0x2160
movq 0xd0(%rbx), %rsi
decq %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20c0
leaq 0x4bec(%rip), %rsi      # 0xa098
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
addq $0x108, %rbx            # imm = 0x108
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x5cde
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::get_shortest_path_to[abi:cxx11](int const&)
vertex_path dijkstra::
get_shortest_path_to( const vertex& d )
{
	v_path.clear();
	v_path.push_front(d);

	vertex v = d;
	
	vertex_previous::const_iterator it_prev;
	while ( (it_prev = v_previous.find(v)) != v_previous.end() ) 
	{
		v = it_prev->second;
		v_path.push_front(v);
	}

	return v_path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc0(%rsi), %r14
movq %r14, %rdi
callq 0x5d2c
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d44
movl (%r12), %eax
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
leaq 0xd8(%r15), %r13
addq $0xe0, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0x62b0
cmpq %r15, %rax
je 0x555d
movl 0x24(%rax), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d44
jmp 0x5539
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d50
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::set_edge_weight(int const&, int const&, double)
void dijkstra::
set_edge_weight( const vertex& s, const vertex& d, double w )
{
	if ( e_weight.find(edge(s,d)) != e_weight.end() ) {
		e_weight[edge(s,d)] = w;
	} else if ( e_weight.find( edge(d,s)) != e_weight.end() ) {
		e_weight[edge(d,s)] = w;
	} else {
		e_weight.insert( edge_weight::value_type(edge(s, d), w) );
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x168(%rdi), %rbx
movl (%rsi), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%rdx), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x6328
addq $0x170, %r13            # imm = 0x170
cmpq %r13, %rax
je 0x55ce
movl (%r15), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
jmp 0x55fb
movq %rax, %r12
movl (%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x6328
cmpq %r12, %rax
je 0x561e
movl (%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x5d8a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl (%r15), %eax
movl (%r14), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x668e
jmp 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::set_edge_weight(std::pair<int, int> const&, double)
void dijkstra::
set_edge_weight( const edge& e, double w )
{
	if ( e_weight.find(e) != e_weight.end() ) {
		e_weight[e] = w;
	} else if ( e_weight.find( edge(e.second, e.first)) != e_weight.end() ) {
		e_weight[edge(e.second, e.first)] = w;
	} else {
		e_weight.insert( edge_weight::value_type(e, w) );
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %r12
leaq 0x168(%rdi), %rbx
movq %rbx, %rdi
callq 0x6328
addq $0x170, %r12            # imm = 0x170
cmpq %r12, %rax
je 0x5686
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5df0
jmp 0x56c4
movq %rax, %r15
movq (%r14), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
leaq 0x8(%rsp), %rsi
movq %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x6328
cmpq %r15, %rax
je 0x56d9
movq (%r14), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
leaq 0x8(%rsp), %rsi
movq %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x5d8a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x668e
jmp 0x56cd
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::get_edge_weight(int const&, int const&)
double dijkstra::
get_edge_weight( const vertex& s, const vertex& d )
{
	if ( e_weight.find(edge(s,d)) != e_weight.end() ) {
		return e_weight[edge(s,d)];
	} else if( e_weight.find(edge(d,s)) != e_weight.end() ) {
		return e_weight[edge(d,s)];
	} else {
		return infinity;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x168(%rdi), %rbx
movl (%rsi), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%rdx), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x6328
addq $0x170, %r13            # imm = 0x170
cmpq %r13, %rax
je 0x5746
movl (%r15), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
jmp 0x5773
movq %rax, %r12
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x6328
cmpq %r12, %rax
je 0x5790
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x5d8a
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movsd 0x48c8(%rip), %xmm0     # 0xa060
jmp 0x5782
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::relaxation(int const&, int const&)
void dijkstra::
relaxation( const vertex& s, const vertex& d )
{	
	if ( v_distance[s] + get_edge_weight(s, d) < v_distance[d] ) 
	{
		v_queue.erase( std::make_pair( v_distance[d], d) );
		v_distance[d] = v_distance[s] + get_edge_weight(s, d);
		v_queue.insert( std::make_pair( v_distance[d], d) );

		v_previous[d] = s;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x108(%rdi), %r12
movq %r12, %rdi
callq 0x5cde
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x56f8
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5cde
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x58a8
leaq 0x138(%r14), %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5cde
movsd (%rax), %xmm0
movl (%rbx), %eax
leaq 0x8(%rsp), %rbp
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x67f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5cde
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x56f8
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5cde
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5cde
movsd (%rax), %xmm0
movl (%rbx), %eax
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x6a16
movl (%r15), %ebp
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x375a
movl %ebp, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::initialize(int const&)
void dijkstra::
initialize( const vertex& s )
{
	v_distance.clear();
	v_queue.clear();
	v_previous.clear();
	
	vertices::const_iterator it = m_vertices.begin();
	for ( ; it != m_vertices.end(); ++it ) 
	{
		if( *it != s ) {
			v_distance.insert( vertex_distance::value_type(*it, infinity) );
			v_queue.insert( std::make_pair(infinity, *it) );
		} else {
			v_distance.insert( vertex_distance::value_type(s, 0) );
			v_queue.insert( std::make_pair(0, s) );
		}
	}
	
	edges::const_iterator e_it = m_edges.begin();
	for( ; e_it != m_edges.end(); ++e_it) 
	{
		e_weight.insert( edge_weight::value_type(*e_it, 0) );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x108, %rdi            # imm = 0x108
movq %rdi, 0x10(%rsp)
callq 0x6ba2
leaq 0x138(%rbx), %r12
movq %r12, %rdi
callq 0x69c4
leaq 0xd8(%rbx), %rdi
callq 0x6bd0
movq 0x60(%rbx), %rbp
movq %rsp, %r13
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
cmpq 0x68(%rbx), %rbp
je 0x5968
movl (%rbp), %eax
cmpl (%r14), %eax
jne 0x5937
movl %eax, (%rsp)
andq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x6bfe
movl (%r14), %eax
andq $0x0, (%rsp)
jmp 0x5953
movl %eax, (%rsp)
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x6bfe
movl (%rbp), %eax
movq %r15, (%rsp)
movl %eax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x6a16
addq $0x4, %rbp
jmp 0x5909
movq 0x78(%rbx), %r12
leaq 0x168(%rbx), %r14
movq %rsp, %r15
cmpq 0x80(%rbx), %r12
je 0x599e
movq (%r12), %rax
movq %rax, (%rsp)
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x668e
addq $0x8, %r12
jmp 0x5976
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::shortest_paths_from(int const&)
void dijkstra::
shortest_paths_from( const vertex& s )
{
	initialize(s);
	
	while( !v_queue.empty() ) 
	{
		vertex u = v_queue.begin()->second;
		v_queue.erase(v_queue.begin());		

		vertices::const_iterator it = m_neighborhood[u].begin();
		for ( ; it != m_neighborhood[u].end(); ++it ) 
		{
			relaxation(u, *it);
		}
	}	

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x58b8
leaq 0x138(%rbx), %r14
leaq 0x90(%rbx), %r15
leaq 0xc(%rsp), %r12
cmpq $0x0, 0x160(%rbx)
je 0x5a29
movq 0x150(%rbx), %rsi
movl 0x28(%rsi), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
callq 0x6caa
movq %r15, %rdi
movq %r12, %rsi
callq 0x37a8
movq (%rax), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r13
je 0x59d6
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x579a
addq $0x4, %r13
jmp 0x5a04
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::dijkstra(GraphAlgo::graph const&)
dijkstra::
dijkstra( const graph& g )
{
	g_in = g;

	m_vertices = g_in.get_vertices();
	m_edges = g_in.get_edges();
	m_neighborhood = g_in.get_neighborhood();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x769a
leaq 0x60(%rbx), %r14
leaq 0x98(%rbx), %rax
andl $0x0, 0x98(%rbx)
andq $0x0, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rax, 0xa8(%rbx)
movq %rax, 0xb0(%rbx)
andq $0x0, 0xb8(%rbx)
leaq 0x78(%rbx), %r15
leaq 0x90(%rbx), %r12
leaq 0xc0(%rbx), %r13
movq %r13, 0xc8(%rbx)
movq %r13, 0xc0(%rbx)
andq $0x0, 0xd0(%rbx)
leaq 0xe0(%rbx), %rax
andl $0x0, 0xe0(%rbx)
andq $0x0, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
andq $0x0, 0x100(%rbx)
leaq 0x110(%rbx), %rax
andl $0x0, 0x110(%rbx)
andq $0x0, 0x118(%rbx)
movq %rax, 0x120(%rbx)
movq %rax, 0x128(%rbx)
andq $0x0, 0x130(%rbx)
leaq 0x140(%rbx), %rax
andl $0x0, 0x140(%rbx)
andq $0x0, 0x148(%rbx)
movq %rax, 0x150(%rbx)
movq %rax, 0x158(%rbx)
andq $0x0, 0x160(%rbx)
leaq 0x170(%rbx), %rax
andl $0x0, 0x170(%rbx)
andq $0x0, 0x178(%rbx)
movq %rax, 0x180(%rbx)
movq %rax, 0x188(%rbx)
andq $0x0, 0x190(%rbx)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x76e4
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x70ac
leaq 0x18(%rsp), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4886
movq %rbp, %rdi
callq 0x4852
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x709e
leaq 0x18(%rsp), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6d08
movq %rbp, %rdi
callq 0x6cd4
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x706c
leaq 0x18(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x383e
movq %rbx, %rdi
callq 0x393e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bfa
jmp 0x5bfa
jmp 0x5bfa
movq %rax, (%rsp)
leaq 0x168(%rbx), %rdi
leaq 0x138(%rbx), %rbp
leaq 0x108(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0xd8(%rbx), %rax
movq %rax, 0x10(%rsp)
callq 0x5e56
movq %rbp, %rdi
callq 0x5eae
movq 0x8(%rsp), %rdi
callq 0x5f06
movq 0x10(%rsp), %rdi
callq 0x39aa
movq %r13, %rdi
callq 0x5f5e
movq %r12, %rdi
callq 0x393e
movq %r15, %rdi
callq 0x6cd4
movq %r14, %rdi
callq 0x4852
movq %rbx, %rdi
callq 0x76c4
movq (%rsp), %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::remove_vertex(int)
void graph::
remove_vertex( vertex v )
{
	while( !m_neighborhood[v].empty() ) 
	{
		remove_edge( v, m_neighborhood[v].back() );
	}

	m_neighborhood.erase(v);	

	vertices::iterator v_it = find( m_vertices.begin(), m_vertices.end(), v );
	if ( v_it != m_vertices.end() ) 
	{
		m_vertices.erase(v_it);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x6da8
movl 0x4(%rsp), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
movq 0x8(%rax), %rax
movl -0x4(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6de8
jmp 0x6d72
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7e16
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq %r15, %rdx
callq 0x7f6c
cmpq 0x20(%rbx), %rax
je 0x6ddd
addq $0x18, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7818
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::remove_edge(int, int)
void graph::
remove_edge( vertex s, vertex d )
{
	edges::iterator e_it = find( m_edges.begin(), m_edges.end(), edge(s, d) );
	if ( e_it != m_edges.end() ) 
	{
		m_edges.erase(e_it);
	}
	
	e_it = find( m_edges.begin(), m_edges.end(), edge(d, s) );
	if ( e_it != m_edges.end() ) 
	{
		m_edges.erase(e_it);
	}

	vertices::iterator v_it = find( m_neighborhood[s].begin(), m_neighborhood[s].end(), d );
	if ( v_it != m_neighborhood[s].end() ) 
	{
		m_neighborhood[s].erase(v_it);
	}
	
	v_it = find( m_neighborhood[d].begin(), m_neighborhood[d].end(), s );
	if ( v_it != m_neighborhood[d].end() ) 
	{
		m_neighborhood[d].erase(v_it);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, (%rdx)
movl %r14d, 0x4(%rdx)
callq 0x7ff3
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
je 0x6e31
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7852
movq 0x8(%rbx), %rsi
movq (%rbx), %rdi
leaq 0x10(%rsp), %rdx
movl %r14d, (%rdx)
movl %ebp, 0x4(%rdx)
callq 0x7ff3
cmpq 0x8(%rbx), %rax
je 0x6e55
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7852
addq $0x30, %rbx
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x7f6c
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r14
je 0x6eb4
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x37a8
movq %rax, %rdi
movq %r14, %rsi
callq 0x7818
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x7f6c
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r14
je 0x6f0f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x37a8
movq %rax, %rdi
movq %r14, %rsi
callq 0x7818
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::add_neighborhood(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>> const&)
void graph::
add_neighborhood( const neighborhood& n )
{
	neighborhood::const_iterator it = n.begin();
	for ( ; it != n.end(); ++it ) 
	{
		vertices::const_iterator v_it = it->second.begin();
		for ( ; v_it != it->second.end(); ++v_it ) 
		{
			add_edge( it->first, *v_it );
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x7109
leaq 0x20(%r15), %r12
movq 0x28(%r15), %r13
cmpq 0x30(%r15), %r13
je 0x70fc
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7114
addq $0x4, %r13
jmp 0x70e2
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
jmp 0x70d5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::add_edge(int const&, int const&)
void graph::
add_edge( const vertex& s, const vertex& d ) 
{
    if ( s == d ) {
        std::cout << __FUNCTION__ << ": Error: source and destination are the same." << std::endl;
	}

	if ( ! is_edge_in_graph(s, d) ) 
	{
		m_edges.push_back(edge(s, d));
		add_vertex(s);
		add_vertex(d);
		
		vertices::iterator it = find( m_neighborhood[s].begin(), m_neighborhood[s].end(), d );
		if ( it == m_neighborhood[s].end() ) 
		{
			m_neighborhood[s].push_back(d);
		}
		
		it = find( m_neighborhood[d].begin(), m_neighborhood[d].end(), s );
		if ( it == m_neighborhood[d].end() ) 
		{
			m_neighborhood[d].push_back(s);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
cmpl (%rdx), %eax
jne 0x7155
movq 0xaea6(%rip), %rdi      # 0x11fd8
leaq 0x2f9a(%rip), %rsi      # 0xa0d3
callq 0x2160
leaq 0x2f97(%rip), %rsi      # 0xa0dc
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6fd2
testb %al, %al
jne 0x723e
movl (%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r14), %eax
movl %eax, 0x4(%rsi)
movq %r15, %rdi
callq 0x8584
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7298
movq %r15, %rdi
movq %r14, %rsi
callq 0x7298
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37a8
movq (%rax), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x7f6c
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r12
jne 0x71ec
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37a8
movq %rax, %rdi
movq %r14, %rsi
callq 0x78f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x37a8
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x7f6c
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r12
jne 0x723e
movq %r15, %rdi
movq %r14, %rsi
callq 0x37a8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x78f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::add_vertices(std::vector<int, std::allocator<int>> const&)
void graph::
add_vertices( const vertices& vs )
{
	vertices::const_iterator it = vs.begin();
	for ( ; it != vs.end(); ++it ) 
	{
		vertices::const_iterator v_it = find( m_vertices.begin(), m_vertices.end(), *it );
		if ( v_it != m_vertices.end() ) 
		{
			continue;
		} else {
			m_vertices.push_back(*it);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
leaq 0x18(%rdi), %r12
cmpq 0x8(%rbx), %r15
je 0x728c
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x7f6c
cmpq 0x20(%r14), %rax
jne 0x7286
movq %r12, %rdi
movq %r15, %rsi
callq 0x78f6
addq $0x4, %r15
jmp 0x725f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::add_edges(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
void graph::
add_edges( const edges& ed )
{
	edges::const_iterator it = ed.begin();
	for ( ; it != ed.end(); ++it ) 
	{
		if ( ! is_edge_in_graph(*it) ) 
		{
			m_edges.push_back(*it);
			add_vertex( it->first );
			add_vertex( it->second );
			
			vertices::iterator v_it = find( m_neighborhood[it->first].begin(), m_neighborhood[it->first].end(), it->second );
			if ( v_it == m_neighborhood[it->first].end() ) 
			{
				m_neighborhood[it->first].push_back( it->second );
			}
			
			v_it = find( m_neighborhood[it->second].begin(), m_neighborhood[it->second].end(), it->first );
			if ( v_it == m_neighborhood[it->second].end() ) 
			{
				m_neighborhood[it->second].push_back( it->first );
			}
		}
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
leaq 0x30(%rdi), %r12
cmpq 0x8(%rbx), %r15
je 0x7451
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f38
testb %al, %al
jne 0x7448
movq %r14, %rdi
movq %r15, %rsi
callq 0x796a
movq %r14, %rdi
movq %r15, %rsi
callq 0x7298
leaq 0x4(%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x7298
movq %r12, %rdi
movq %r15, %rsi
callq 0x37a8
movq (%rax), %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x7f6c
movq %rax, %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x37a8
cmpq 0x8(%rax), %rbp
jne 0x73f6
movq %r12, %rdi
movq %r15, %rsi
callq 0x37a8
movq %rax, %rdi
movq %r13, %rsi
callq 0x78f6
movq %r12, %rdi
movq %r13, %rsi
callq 0x37a8
movq (%rax), %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %rbp, %rdi
movq %r15, %rdx
callq 0x7f6c
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x37a8
cmpq 0x8(%rax), %rbp
jne 0x7448
movq %r12, %rdi
movq %r13, %rsi
callq 0x37a8
movq %rax, %rdi
movq %r15, %rsi
callq 0x78f6
addq $0x8, %r15
jmp 0x7362
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::add_edge(std::pair<int, int> const&)
void graph::
add_edge( const edge& e )
{
	if ( ! is_edge_in_graph(e) ) 
	{
		m_edges.push_back(e);
		add_vertex(e.first);
		add_vertex(e.second);
		
		vertices::iterator it = find( m_neighborhood[e.first].begin(), m_neighborhood[e.first].end(), e.second );
		if ( it == m_neighborhood[e.first].end() ) 
		{
			m_neighborhood[e.first].push_back(e.second);
		}
		
		it = find( m_neighborhood[e.second].begin(), m_neighborhood[e.second].end(), e.first );
		if ( it == m_neighborhood[e.second].end() ) 
		{
		   m_neighborhood[e.second].push_back(e.first);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6f38
testb %al, %al
jne 0x7532
movq %r14, %rdi
movq %rbx, %rsi
callq 0x796a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7298
leaq 0x4(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7298
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37a8
movq (%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x7f6c
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r12
jne 0x74f6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37a8
movq %rax, %rdi
movq %r15, %rsi
callq 0x78f6
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
movq (%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x7f6c
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r12
je 0x753e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x37a8
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x78f6
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::graph(GraphAlgo::graph const&)
graph::        
graph( const graph& g )
{
	m_vertices.clear();
	m_neighborhood.clear();
	m_edges.clear();
	
	edges::const_iterator eit = g.m_edges.begin();
	for ( ; eit != g.m_edges.end(); ++eit ) 
	{
		add_edge(*eit);
	}
	
	vertices::const_iterator vit = g.m_vertices.begin();
	for ( ; vit != g.m_vertices.end(); ++vit ) 
	{
		add_vertex(*vit);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movq %r14, %rdi
callq 0x388c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x762f
movq %rax, 0x8(%rbx)
movq (%r15), %r12
cmpq 0x8(%r15), %r12
je 0x7649
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7460
addq $0x8, %r12
jmp 0x7632
movq 0x18(%r15), %r12
cmpq 0x20(%r15), %r12
je 0x7664
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7298
addq $0x4, %r12
jmp 0x764d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7672
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x393e
movq %r12, %rdi
callq 0x4852
movq %rbx, %rdi
callq 0x6cd4
movq %r15, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::operator=(GraphAlgo::graph const&)
graph& graph::
operator =( const graph& g )
{
	m_vertices.clear();
	m_neighborhood.clear();
	m_edges.clear();
	
	edges::const_iterator eit = g.m_edges.begin();
	for ( ; eit != g.m_edges.end(); ++eit) 
	{	
		add_edge(*eit);
	}
	
	vertices::const_iterator vit = g.m_vertices.begin();
	for ( ; vit != g.m_vertices.end(); ++vit ) 
	{
		add_vertex(*vit);
	}
	
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x76fd
movq %rax, 0x20(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x388c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x7713
movq %rax, 0x8(%rbx)
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x772d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7460
addq $0x8, %r15
jmp 0x7716
movq 0x18(%r14), %r15
cmpq 0x20(%r14), %r15
je 0x7748
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7298
addq $0x4, %r15
jmp 0x7731
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::print_neighborhood() const
void graph::
print_neighborhood() const
{
	neighborhood::const_iterator it = m_neighborhood.begin();
	for ( ; it != m_neighborhood.end(); ++it ) 
	{
		std::cout << std::setw(2) << it->first << "  --> " ;
		
		vertices::const_iterator v_it = it->second.begin();
		for ( ; v_it != it->second.end(); ++v_it ) 
		{
			std::cout << std::setw(2) << *v_it;
			if ( v_it != (it->second.end() - 1) ) 
			{
				std::cout << ", " ;
			}
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r15
addq $0x38, %rbx
movq 0xa869(%rip), %r14      # 0x11fd8
leaq 0x2994(%rip), %r12      # 0xa10a
leaq 0x2994(%rip), %r13      # 0xa111
cmpq %rbx, %r15
je 0x7808
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movl 0x20(%r15), %esi
movq %r14, %rdi
callq 0x2210
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq 0x28(%r15), %rbp
cmpq 0x30(%r15), %rbp
je 0x77f0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movl (%rbp), %esi
movq %r14, %rdi
callq 0x2210
movq 0x30(%r15), %rax
addq $-0x4, %rax
cmpq %rax, %rbp
je 0x77ea
movq %r14, %rdi
movq %r13, %rsi
callq 0x2160
addq $0x4, %rbp
jmp 0x77b1
movq %r14, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
jmp 0x777d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/main.cpp
// Function: draw_graph(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void draw_graph( const std::vector<std::string> &graph_data )
{
	// Printing a graph via graph_data
	std::cout << std::endl;
	std::cout << terminal::TEXT_BOLD << terminal::TEXTCOLOR_BLUE;
	
	for ( auto &line : graph_data )
	{
		std::cout << "   " << line << std::endl;
	}
	
	std::cout << terminal::RESET_ALL;
	std::cout << std::endl;
	std::cout << "................................................................................" << std::endl;	
	
	std::this_thread::sleep_for(std::chrono::milliseconds(4000));   // sleep
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x863c(%rip), %rbx      # 0x11fd8
movq %rbx, %rdi
callq 0x20c0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9a3c
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x9a3c
movq (%r15), %r14
movq 0x8(%r15), %r12
leaq 0x10b8(%rip), %r15      # 0xaa80
cmpq %r12, %r14
je 0x99f1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20c0
addq $0x20, %r14
jmp 0x99c8
movq 0x85e0(%rip), %rbx      # 0x11fd8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9a3c
movq %rbx, %rdi
callq 0x20c0
leaq 0x1e8b(%rip), %rsi      # 0xb89c
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movq %rsp, %rdi
movq $0xfa0, (%rdi)          # imm = 0xFA0
callq 0x9a65
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::connectGateway()
void LogicServer::connectGateway()
{
    gatefd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in gatewayAddr;

    gatewayAddr.sin_family = AF_INET;
    gatewayAddr.sin_port = 8898;
    inet_aton("127.0.0.1",&(gatewayAddr.sin_addr));
    
    bind(gatefd, (struct sockaddr*)&gatewayAddr, sizeof(gatewayAddr));
    
    gatewayAddr.sin_family = AF_INET;
    gatewayAddr.sin_port = htons(gateway.second);
    inet_aton(gateway.first.c_str(), &(gatewayAddr.sin_addr));
    ::connect(gatefd, (struct sockaddr*)&gatewayAddr, sizeof(gatewayAddr));

    Client *gate = new Client(gatefd);
    ev.data.ptr = gate;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, gatefd, &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %r14
movl %r14d, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, 0x168(%rbx)
leaq -0x34(%rbp), %r15
movl $0x22c20002, -0x4(%r15) # imm = 0x22C20002
leaq 0x49d2(%rip), %rdi      # 0x7058
movq %r15, %rsi
callq 0x2180
movl 0x168(%rbx), %edi
leaq -0x38(%rbp), %r12
pushq $0x10
popq %r13
movq %r12, %rsi
movl %r13d, %edx
callq 0x2040
movw $0x2, (%r12)
movzwl 0x190(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r12)
movq 0x170(%rbx), %rdi
movq %r15, %rsi
callq 0x2180
movl 0x168(%rbx), %edi
movq %r12, %rsi
movl %r13d, %edx
callq 0x21b0
movl $0x2024, %edi           # imm = 0x2024
callq 0x21f0
movl 0x168(%rbx), %edx
andq $0x0, 0x1004(%rax)
andl $0x0, 0x100c(%rax)
andq $0x0, 0x2014(%rax)
andl $0x0, 0x201c(%rax)
movl %edx, 0x2020(%rax)
leaq 0x1c(%rbx), %rcx
movq %rax, 0x20(%rbx)
movl $0x1, 0x1c(%rbx)
movl 0x10(%rbx), %edi
movl %r14d, %esi
callq 0x22a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::Run()
void LogicServer::Run()
{
    int n = epoll_wait(epfd, events, 20, 500);
    for (int i = 0; i < n; i++) {
        if (events[i].data.fd == listenfd) {
            acceptConnect();
        }
        else {
            Client* cli = (Client*)events[i].data.ptr;
            int ret = cli->Recv();
            PacketInfo pi; string content;
            bool has = cli->hasMsg(&pi, content);
            if (has) {
                Dispatch(cli, &pi, content);
            }
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %edi
leaq 0x28(%rbx), %rsi
pushq $0x14
popq %rdx
movl $0x1f4, %ecx            # imm = 0x1F4
callq 0x2120
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
imulq $0xc, %rax, %r12
leaq -0x80(%rbp), %r15
cmpq %r14, %r12
je 0x2801
movl 0x2c(%rbx,%r14), %eax
cmpl 0x14(%rbx), %eax
jne 0x2793
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
jmp 0x27f8
movq 0x2c(%rbx,%r14), %r13
movq %r13, %rdi
callq 0x5f2c
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %r13, %rdi
leaq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x5fa2
testb %al, %al
je 0x27ef
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2290
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x60(%rbp), %rdx
movq %r15, %r13
movq %r15, %rcx
callq *0x10(%rax)
movq %r13, %rdi
callq 0x2110
leaq -0x48(%rbp), %rdi
callq 0x2110
addq $0xc, %r14
jmp 0x2775
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2110
jmp 0x2821
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::Dispatch(fieryzig::Client*, fieryzig::PacketInfo*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void LogicServer::Dispatch(Client* cli, PacketInfo *ppi, string content)
{
    switch(ppi->srcType) {
        case ServerType::CLIENT:
        {
            // impossible
            break;
        }
        case ServerType::GATEWAY:
        {
            if (content == "Login") {
                fd_map[ppi->uid] = ppi->clifd;
                Player* player = new Player(ppi->uid);
                pl_map[ppi->uid] = player;
                cout << "User " << ppi->uid << "Login" << endl;
            }
            else if (content == "Logout") {
                delete pl_map[ppi->uid];
                pl_map.erase(ppi->uid);
                fd_map.erase(ppi->uid);
                cout << "User " << ppi->uid << "Logout" << endl;
            }
            // Other Msg
            break;
        }
        case ServerType::LOGIC:
        {
            break;
        }
        // DB Cache
    }

}

// Assembly:
cmpl $0x1, (%rdx)
jne 0x2956
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
leaq 0x4806(%rip), %rbx      # 0x7062
movq %rcx, %rdi
movq %rbx, %rsi
callq 0x2e51
testb %al, %al
je 0x28b5
movl 0x10(%r12), %r13d
leaq 0x1c8(%r14), %rdi
leaq 0x8(%r12), %r15
movq %r15, %rsi
callq 0x2e62
movl %r13d, (%rax)
pushq $0x4
popq %rdi
callq 0x21f0
movq %rax, %r13
movl 0x8(%r12), %eax
movl %eax, (%r13)
addq $0x198, %r14            # imm = 0x198
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x2eb4
movq %r13, (%rax)
jmp 0x2917
leaq 0x47b2(%rip), %rbx      # 0x706e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e51
testb %al, %al
je 0x2948
leaq 0x198(%r14), %r13
leaq 0x8(%r12), %r15
movl 0x8(%r12), %eax
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
callq 0x2eb4
movq (%rax), %rdi
callq 0x21d0
movl 0x8(%r12), %eax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
callq 0x36cc
addq $0x1c8, %r14            # imm = 0x1C8
movq %r14, %rdi
movq %r15, %rsi
callq 0x38ac
movq 0xa6ba(%rip), %rdi      # 0xcfd8
leaq 0x4743(%rip), %rsi      # 0x7068
callq 0x21e0
movl (%r15), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x2130
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::acceptConnect()
void LogicServer::acceptConnect()
{
    socklen_t clilen;
    connfd = accept(listenfd, (sockaddr*)&clientaddr, &clilen);
    Client *client = new Client(connfd);

    // DB Cache Server ? may connect in?
    //
    ev.data.ptr = client;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %edi
leaq 0x118(%rbx), %rsi
leaq -0x14(%rbp), %rdx
callq 0x20c0
movl %eax, %r14d
movl %eax, 0x18(%rbx)
movl $0x2024, %edi           # imm = 0x2024
callq 0x21f0
andq $0x0, 0x1004(%rax)
andl $0x0, 0x100c(%rax)
andq $0x0, 0x2014(%rax)
andl $0x0, 0x201c(%rax)
movl %r14d, 0x2020(%rax)
leaq 0x1c(%rbx), %rcx
movq %rax, 0x20(%rbx)
movl $0x1, 0x1c(%rbx)
movl 0x10(%rbx), %edi
pushq $0x1
popq %rsi
movl %r14d, %edx
callq 0x22a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/LogicServer/main.cpp
// Function: main
int main()
{
    LogicServer *logicServer = new LogicServer();
    
    logicServer->SetConfig("logicConfig.json");
    logicServer->InitServer();
    
    logicServer->connectGateway();
    
    while(1)
    {
        logicServer->Run();
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x1f8, %edi            # imm = 0x1F8
callq 0x21f0
movq %rax, %rbx
movl $0x1f8, %edx            # imm = 0x1F8
movq %rax, %rdi
xorl %esi, %esi
callq 0x2140
movq %rbx, %rdi
callq 0x5d70
movq (%rbx), %rax
leaq 0x3e6b(%rip), %rsi      # 0x9ba8
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x5e34
movq %rbx, %rdi
callq 0x2648
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x5d52
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/supragya[P]DirectorySync/DirectorySync.cpp
// Function: set_filewatcher_connection(int, char*)
void set_filewatcher_connection(int portno, char* ipaddr){
    // Network setup with other Droid
    struct sockaddr_in address;
    int sock = 0;
    struct sockaddr_in serv_addr;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        std::cout<<"[FC] Socket creation error"<<std::endl;
        exit(1);
    }

    memset(&serv_addr, '0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(portno);

    // Convert IPv4 and IPv6 addresses from text to binary form
    if(inet_pton(AF_INET, ipaddr, &serv_addr.sin_addr)<=0)
    {
        std::cout<<"[FC] Invalid address/ Address not supported "<<std::endl;
        exit(1);
    }
    std::cout<<"[FC] Other bot ready to accept communication?";
    char ch;
    std::cin>>ch;
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        std::cout<<"[FC] Connection Failed"<<std::endl;
        exit(1);
    }
    else
        std::cout<<"[FC] Successfully setup connection with other droid\n";

    FCsock = sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %r15d
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
testl %eax, %eax
js 0x28c8
movl %eax, %ebx
leaq -0x28(%rbp), %rdx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%rdx)
movl $0x30303030, 0x8(%rdx)  # imm = 0x30303030
movw $0x2, -0x4(%rdx)
rolw $0x8, %r15w
movw %r15w, -0x2(%rdx)
pushq $0x2
popq %rdi
movq %r14, %rsi
callq 0x2300
movq 0x475e(%rip), %rdi      # 0x6fd0
testl %eax, %eax
jle 0x28d8
leaq 0x1a64(%rip), %rsi      # 0x42e1
callq 0x2180
movq 0x4757(%rip), %rdi      # 0x6fe0
leaq -0x19(%rbp), %rsi
callq 0x21f0
leaq -0x2c(%rbp), %rsi
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x2130
movq 0x4729(%rip), %rdi      # 0x6fd0
testl %eax, %eax
js 0x28e1
leaq 0x1a74(%rip), %rsi      # 0x4326
callq 0x2180
movl %ebx, 0x1d9ab(%rip)     # 0x20268
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x4701(%rip), %rdi      # 0x6fd0
leaq 0x19c3(%rip), %rsi      # 0x4299
jmp 0x28e8
leaq 0x19d5(%rip), %rsi      # 0x42b4
jmp 0x28e8
leaq 0x1a27(%rip), %rsi      # 0x430f
callq 0x2180
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/supragya[P]DirectorySync/DirectorySync.cpp
// Function: FormMessage(char*, FileChangeType_t, FileType_t, unsigned long)
message* FormMessage(char *filename, FileChangeType_t fctype, FileType_t ftype, unsigned long filesize){
    message* newmsg = (message *)malloc(sizeof(message));
    strcpy(newmsg->FileName, filename);
    newmsg->FType = ftype;
    newmsg->FCType = fctype;
    newmsg->FileSize = filesize;
    newmsg->valid = 1;
    return newmsg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x400, %edi            # imm = 0x400
callq 0x2200
movq %rax, %r13
leaq 0x4(%rax), %rdi
movq %r12, %rsi
callq 0x2160
movl %r14d, 0x3f0(%r13)
movl %r15d, 0x3ec(%r13)
movq %rbx, 0x3f8(%r13)
movl $0x1, (%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/supragya[P]DirectorySync/DirectorySync.cpp
// Function: TransactionHistory_t::TransactionHistory_t()
TransactionHistory_t(){
        for(int i=0; i<MAXTRANSACTIONS; i++){
            ValidTransactionHistory[i] = false;
            strcpy(TransactionHistory[i].FileName, "");
            TransactionHistory[i].FCType = FCT_NONE;
            TransactionHistory[i].FType = FT_NONE;
            TransactionHistory[i].FileSize = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x19078(%rdi)
andq $0x0, 0x19088(%rdi)
movups %xmm0, 0x19068(%rdi)
leaq 0x460(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x64, %rdx
je 0x3697
movb %cl, (%rdi,%rdx)
movb %cl, -0x3f4(%rax)
andq $0x0, -0xc(%rax)
andq $0x0, (%rax)
incq %rdx
addq $0x400, %rax            # imm = 0x400
jmp 0x3674
popq %rbp
retq
nop