LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0xc0, %rdi
callq 0xfd80
movq -0x50(%rbp), %rdi
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
callq 0xfdb0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xfdf0
movq -0x50(%rbp), %rdi
addq $0xd8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0xfe40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8920
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0xd8, %rdi
callq 0x8750
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8920
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xfe10
testb $0x1, %al
jne 0xecda
jmp 0xed02
leaq -0x28(%rbp), %rdi
callq 0xfe70
movq -0x50(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0xc0, %rdi
leaq -0x1c(%rbp), %rsi
callq 0xfdb0
jmp 0xec79
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0xc0, %rsi
callq 0xfe90
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x6180
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xff80
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xeda3
jmp 0xedf6
movq -0x90(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6180
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xffe0
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xeefb
movq -0x90(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x6180
movq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xff80
movq -0x90(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xee59
jmp 0xeea9
movq -0x90(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x6180
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xffe0
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xeef9
movq -0x90(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x6180
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x10100
movq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x100c0
movq %rax, -0x88(%rbp)
movb %dl, -0x80(%rbp)
jmp 0xeefb
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x168, %rdi            # imm = 0x168
movq -0x10(%rbp), %rsi
callq 0xff80
movq -0x70(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xef6b
jmp 0xef97
movq -0x70(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
addq $0x168, %rdi            # imm = 0x168
movq -0x10(%rbp), %rsi
callq 0x10130
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xf07e
movq -0x70(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x6180
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xff80
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xeff2
jmp 0xf043
movq -0x70(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x6180
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xffe0
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xf07c
movq -0x70(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x10210
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x100c0
movq %rax, -0x68(%rbp)
movb %dl, -0x60(%rbp)
jmp 0xf07e
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x6180
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xff80
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xf102
jmp 0xf13c
movq -0x68(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6180
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xffe0
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xf1dd
movq -0x68(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x6180
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xff80
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x168, %rdi            # imm = 0x168
callq 0xffb0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xff50
testb $0x1, %al
jne 0xf193
jmp 0xf1d0
movq -0x68(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x6180
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xffe0
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xf1dd
movsd 0xfe88(%rip), %xmm0     # 0x1f060
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x108, %rdi            # imm = 0x108
movq -0x10(%rbp), %rsi
callq 0xfca0
movq -0x80(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf090
movq -0x80(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
addq $0x108, %rdi            # imm = 0x108
movq -0x18(%rbp), %rsi
callq 0xfca0
movsd -0x70(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xf39f
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x138, %rax            # imm = 0x138
movq %rax, -0x90(%rbp)
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x98(%rbp)
movq -0x18(%rbp), %rsi
callq 0xfca0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x10270
movq -0x90(%rbp), %rdi
movl %eax, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x10240
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfca0
movq -0x80(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf090
movq -0x98(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0xa8(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
callq 0xfca0
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rsi
callq 0xfca0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x10270
movq -0x90(%rbp), %rdi
movl %eax, -0x50(%rbp)
movsd %xmm0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x102a0
movq -0x80(%rbp), %rdi
movq %rax, -0x68(%rbp)
movb %dl, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x84(%rbp)
addq $0xd8, %rdi
movq -0x18(%rbp), %rsi
callq 0x5e90
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf3b0
movq -0x50(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x105d0
xorb $-0x1, %al
testb $0x1, %al
jne 0xf70c
jmp 0xf7ea
movq -0x50(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x105f0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10620
movq -0x50(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq %rdi, %rax
addq $0x138, %rax            # imm = 0x138
movq %rax, -0x58(%rbp)
addq $0x138, %rdi            # imm = 0x138
callq 0x105f0
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x10640
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x90, %rdi
leaq -0x14(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6080
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
leaq -0x14(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0xf7c1
jmp 0xf7e5
leaq -0x38(%rbp), %rdi
callq 0x6130
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq -0x14(%rbp), %rsi
callq 0xf1f0
leaq -0x38(%rbp), %rdi
callq 0x6240
jmp 0xf78e
jmp 0xf6f1
addq $0x60, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
callq 0x16d80
movq -0x88(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xc8(%rbp)
callq 0x63c0
movq -0x88(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x10680
movq -0x88(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6400
movq -0x88(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x106a0
movq -0x88(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6380
movq -0x88(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0xa0(%rbp)
callq 0x106c0
movq -0x88(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq %rdi, -0x98(%rbp)
callq 0x106e0
movq -0x88(%rbp), %rdi
addq $0x168, %rdi            # imm = 0x168
movq %rdi, -0x90(%rbp)
callq 0x10700
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16e00
jmp 0xf8f9
movq -0xd0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x16180
jmp 0xf90b
movq -0xd0(%rbp), %rdi
addq $0x60, %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x6420
movq -0xd8(%rbp), %rdi
callq 0x6450
movq -0xd0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x16150
jmp 0xf944
movq -0xd0(%rbp), %rdi
addq $0x78, %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x10720
movq -0xe0(%rbp), %rdi
callq 0x10750
movq -0xd0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x160d0
jmp 0xf97d
movq -0xd0(%rbp), %rdi
addq $0x90, %rdi
leaq -0x80(%rbp), %rsi
callq 0x64b0
leaq -0x80(%rbp), %rdi
callq 0x64e0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x107b0
movq -0x98(%rbp), %rdi
callq 0x107d0
movq -0xa0(%rbp), %rdi
callq 0x107f0
movq -0xa8(%rbp), %rdi
callq 0x6580
movq -0xb0(%rbp), %rdi
callq 0x10810
movq -0xb8(%rbp), %rdi
callq 0x64e0
movq -0xc0(%rbp), %rdi
callq 0x10750
movq -0xc8(%rbp), %rdi
callq 0x6450
movq -0x88(%rbp), %rdi
callq 0x16dc0
movq -0x18(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0xc500
xorb $-0x1, %al
testb $0x1, %al
jne 0x159a8
jmp 0x159d7
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x17080
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl (%rax), %edx
callq 0x15a80
jmp 0x15987
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x170c0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x6050
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x170f0
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17140
testb $0x1, %al
jne 0x15a43
jmp 0x15a6d
movq -0x48(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6080
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x17180
movq %rax, -0x40(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::is_vertex_in_graph(int const&) const
bool graph::
is_vertex_in_graph( const vertex& v ) const
{
	vertices::const_iterator it = find( m_vertices.begin(), m_vertices.end(), v );
	if ( it != m_vertices.end() ) 
	{
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
callq 0xcc50
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0xcc80
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x17320
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0xcc80
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x15e0f
jmp 0x15e15
movb $0x1, -0x1(%rbp)
jmp 0x15e19
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::is_edge_in_graph(std::pair<int, int> const&) const
bool graph::
is_edge_in_graph( const edge& e ) const
{
	edges::const_iterator it = m_edges.begin();
	for ( ; it != m_edges.end(); ++it ) 
	{
		if ( (it->first == e.first && it->second == e.second)	|| (it->first == e.second && it->second == e.first) )
		{
			std::cout << __FUNCTION__ << ": Edge " << it->first << " and " << it->second << " already exist!" << std::endl;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x173b0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x17420
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x173e0
testb $0x1, %al
jne 0x15e74
jmp 0x15f62
leaq -0x20(%rbp), %rdi
callq 0x17450
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x15e9c
leaq -0x20(%rbp), %rdi
callq 0x17450
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x15ecc
leaq -0x20(%rbp), %rdi
callq 0x17450
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x15f52
leaq -0x20(%rbp), %rdi
callq 0x17450
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x15f52
movq 0x1a105(%rip), %rdi     # 0x2ffd8
leaq 0x9206(%rip), %rsi      # 0x1f0e0
callq 0x21a0
movq %rax, %rdi
leaq 0x9208(%rip), %rsi      # 0x1f0f1
callq 0x21a0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x17450
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x91e9(%rip), %rsi      # 0x1f0f9
callq 0x21a0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x17450
movq -0x38(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x91c7(%rip), %rsi      # 0x1f0ff
callq 0x21a0
movq %rax, %rdi
movq 0x1a081(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movb $0x1, -0x1(%rbp)
jmp 0x15f66
jmp 0x15f54
leaq -0x20(%rbp), %rdi
callq 0x105b0
jmp 0x15e51
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::is_edge_in_graph(int const&, int const&) const
bool graph::
is_edge_in_graph( const vertex& s, const vertex& d ) const
{
	edges::const_iterator it = m_edges.begin();
	for ( ; it != m_edges.end(); ++it ) 
	{
		if ( (it->first == s && it->second == d) || (it->first == d && it->second == s) )
		{
			std::cout << __FUNCTION__ << ": Edge " << it->first << " and " << it->second << " already exist!" << std::endl;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x173b0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17420
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x173e0
testb $0x1, %al
jne 0x15fc8
jmp 0x160b4
leaq -0x28(%rbp), %rdi
callq 0x17450
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x15fef
leaq -0x28(%rbp), %rdi
callq 0x17450
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x1601e
leaq -0x28(%rbp), %rdi
callq 0x17450
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x160a4
leaq -0x28(%rbp), %rdi
callq 0x17450
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x160a4
movq 0x19fb3(%rip), %rdi     # 0x2ffd8
leaq 0x90b4(%rip), %rsi      # 0x1f0e0
callq 0x21a0
movq %rax, %rdi
leaq 0x90b6(%rip), %rsi      # 0x1f0f1
callq 0x21a0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17450
movq -0x48(%rbp), %rdi
movl (%rax), %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x9097(%rip), %rsi      # 0x1f0f9
callq 0x21a0
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17450
movq -0x40(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x9075(%rip), %rsi      # 0x1f0ff
callq 0x21a0
movq %rax, %rdi
movq 0x19f2f(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movb $0x1, -0x1(%rbp)
jmp 0x160b8
jmp 0x160a6
leaq -0x28(%rbp), %rdi
callq 0x105b0
jmp 0x15fa5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17680
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x176b0
testb $0x1, %al
jne 0x161f8
jmp 0x1627e
leaq -0x18(%rbp), %rdi
callq 0x17710
movq %rax, %rdi
addq $0x8, %rdi
callq 0xcc50
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17710
movq %rax, %rdi
addq $0x8, %rdi
callq 0xcc80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x1623d
jmp 0x1626e
leaq -0x18(%rbp), %rdi
callq 0x17710
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6130
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x16290
leaq -0x28(%rbp), %rdi
callq 0x6240
jmp 0x16211
jmp 0x16270
leaq -0x18(%rbp), %rdi
callq 0x17730
jmp 0x161d5
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x162eb
movq 0x19d17(%rip), %rdi     # 0x2ffd8
leaq 0x8e47(%rip), %rsi      # 0x1f10f
callq 0x21a0
movq %rax, %rdi
leaq 0x8e41(%rip), %rsi      # 0x1f118
callq 0x21a0
movq %rax, %rdi
movq 0x19ce2(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15f80
testb $0x1, %al
jne 0x1647e
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x6180
movq -0x68(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17980
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16590
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16590
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x170f0
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17940
testb $0x1, %al
jne 0x163bb
jmp 0x163d8
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x17760
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x170f0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x17940
testb $0x1, %al
jne 0x1645f
jmp 0x1647c
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x17760
jmp 0x1647e
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcc50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcc80
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x164d8
jmp 0x1657b
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x6050
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6130
movq %rax, %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x170f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6080
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x6100
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0x16548
jmp 0x1654a
jmp 0x1656d
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6130
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x17760
jmp 0x1656d
leaq -0x18(%rbp), %rdi
callq 0x6240
jmp 0x164b5
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x15e30
testb $0x1, %al
jne 0x16b7e
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x178d0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16590
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x16590
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17940
testb $0x1, %al
jne 0x16aa7
jmp 0x16ac8
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x17760
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x170f0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x17940
testb $0x1, %al
jne 0x16b5b
jmp 0x16b7c
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x5f70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x17760
jmp 0x16b7e
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10680
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0x63c0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x6400
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x179e0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x17a00
movq -0x48(%rbp), %rdi
callq 0x17a20
movq -0x10(%rbp), %rdi
callq 0x173b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17420
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x173e0
testb $0x1, %al
jne 0x16cbf
jmp 0x16d0c
leaq -0x18(%rbp), %rdi
callq 0x10560
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x169d0
jmp 0x16cd6
jmp 0x16cd8
leaq -0x18(%rbp), %rdi
callq 0x105b0
jmp 0x16c9f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x64e0
movq -0x58(%rbp), %rdi
callq 0x6450
movq -0x48(%rbp), %rdi
callq 0x10750
jmp 0x16d6b
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xcc50
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xcc80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x16d41
jmp 0x16d65
leaq -0x38(%rbp), %rdi
callq 0x6130
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x16590
jmp 0x16d58
jmp 0x16d5a
leaq -0x38(%rbp), %rdi
callq 0x6240
jmp 0x16d1d
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x179e0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x17a00
movq -0x38(%rbp), %rdi
callq 0x17a20
movq -0x10(%rbp), %rdi
callq 0x173b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17420
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x173e0
testb $0x1, %al
jne 0x16e64
jmp 0x16e84
leaq -0x18(%rbp), %rdi
callq 0x10560
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x169d0
leaq -0x18(%rbp), %rdi
callq 0x105b0
jmp 0x16e44
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xcc50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xcc80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x16eb9
jmp 0x16ed9
leaq -0x28(%rbp), %rdi
callq 0x6130
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x16590
leaq -0x28(%rbp), %rdi
callq 0x6240
jmp 0x16e95
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x30, %rdi
callq 0x17680
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x176e0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x176b0
testb $0x1, %al
jne 0x16f38
jmp 0x17079
movl $0x2, %edi
callq 0x17a40
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq 0x19089(%rip), %rdi     # 0x2ffd8
callq 0x2230
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x17710
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x81d0(%rip), %rsi      # 0x1f146
callq 0x21a0
leaq -0x10(%rbp), %rdi
callq 0x17710
movq %rax, %rdi
addq $0x8, %rdi
callq 0xcc50
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x17710
movq %rax, %rdi
addq $0x8, %rdi
callq 0xcc80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x16fc3
jmp 0x17058
movl $0x2, %edi
callq 0x17a40
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movq 0x18ffe(%rip), %rdi     # 0x2ffd8
callq 0x2230
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6130
movq -0x60(%rbp), %rdi
movl (%rax), %esi
callq 0x22a0
leaq -0x10(%rbp), %rdi
callq 0x17710
movq %rax, %rdi
addq $0x8, %rdi
callq 0xcc80
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x17a60
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17370
testb $0x1, %al
jne 0x17035
jmp 0x17048
movq 0x18f9c(%rip), %rdi     # 0x2ffd8
leaq 0x810a(%rip), %rsi      # 0x1f14d
callq 0x21a0
jmp 0x1704a
leaq -0x28(%rbp), %rdi
callq 0x6240
jmp 0x16f94
movq 0x18f79(%rip), %rdi     # 0x2ffd8
movq 0x18f62(%rip), %rsi     # 0x2ffc8
callq 0x21e0
leaq -0x10(%rbp), %rdi
callq 0x17730
jmp 0x16f11
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x124e5(%rip), %rdi     # 0x2ffd8
movq 0x124ce(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movq 0x124d2(%rip), %rdi     # 0x2ffd8
movl $0x1, %esi
callq 0x1dc00
movq %rax, %rdi
movl $0x22, %esi
callq 0x1dc00
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e050
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1e080
testb $0x1, %al
jne 0x1db52
jmp 0x1db98
leaq -0x18(%rbp), %rdi
callq 0x1e0c0
movq %rax, -0x28(%rbp)
movq 0x12472(%rip), %rdi     # 0x2ffd8
leaq 0x1f4f(%rip), %rsi      # 0x1fabc
callq 0x21a0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x2190
movq %rax, %rdi
movq 0x12440(%rip), %rsi     # 0x2ffc8
callq 0x21e0
leaq -0x18(%rbp), %rdi
callq 0x1e0e0
jmp 0x1db3f
movq 0x12439(%rip), %rdi     # 0x2ffd8
xorl %esi, %esi
callq 0x1dc00
movq 0x1242b(%rip), %rdi     # 0x2ffd8
movq 0x12414(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movq 0x12418(%rip), %rdi     # 0x2ffd8
leaq 0x2d0d(%rip), %rsi      # 0x208d4
callq 0x21a0
movq %rax, %rdi
movq 0x123f2(%rip), %rsi     # 0x2ffc8
callq 0x21e0
movl $0xfa0, -0x34(%rbp)     # imm = 0xFA0
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x1dcf0
leaq -0x30(%rbp), %rdi
callq 0x1dc40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x168(%rax)
movw $0x2, -0x18(%rbp)
movw $0x22c2, -0x16(%rbp)    # imm = 0x22C2
leaq -0x14(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq 0xb814(%rip), %rdi      # 0xe040
callq 0x2190
movq -0x40(%rbp), %rax
movl 0x168(%rax), %edi
leaq -0x18(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movl $0x10, %edx
movl %edx, -0x44(%rbp)
callq 0x2050
movq -0x40(%rbp), %rax
movw $0x2, -0x18(%rbp)
movq %rax, %rcx
addq $0x170, %rcx            # imm = 0x170
movq %rcx, -0x60(%rbp)
movzwl 0x190(%rax), %edi
callq 0x2040
movq -0x60(%rbp), %rdi
movw %ax, -0x16(%rbp)
callq 0x2100
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x50(%rbp), %rsi
movl -0x44(%rbp), %edx
movq -0x40(%rbp), %rax
movl 0x168(%rax), %edi
callq 0x21d0
movl $0x2024, %edi           # imm = 0x2024
callq 0x2210
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl 0x168(%rax), %esi
callq 0x35e0
jmp 0x28c8
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rcx)
movl $0x1, 0x1c(%rcx)
movl 0x10(%rcx), %edi
movl 0x168(%rcx), %edx
addq $0x1c, %rcx
movl $0x1, %esi
callq 0x22f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x21f0
movq -0x28(%rbp), %rdi
callq 0x23b0
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movl 0x10(%rsi), %edi
addq $0x28, %rsi
movl $0x14, %edx
movl $0x1f4, %ecx            # imm = 0x1F4
callq 0x2130
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2a97
movq -0x98(%rbp), %rcx
movq %rcx, %rax
addq $0x28, %rax
movslq -0x10(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl 0x4(%rax), %eax
cmpl 0x14(%rcx), %eax
jne 0x2999
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2a87
movq -0x98(%rbp), %rax
movslq -0x10(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x2c(%rax,%rcx,4), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcf30
movl %eax, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2300
movq -0xa8(%rbp), %rdx
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xcfc0
movb %al, -0x99(%rbp)
jmp 0x29e9
movb -0x99(%rbp), %al
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
je 0x2a71
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2110
jmp 0x2a17
movq -0xb0(%rbp), %rsi
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x34(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq *%rax
jmp 0x2a3b
leaq -0x90(%rbp), %rdi
callq 0x2160
jmp 0x2a71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2a7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2160
jmp 0x2a7c
leaq -0x58(%rbp), %rdi
callq 0x2160
jmp 0x2a87
leaq -0x58(%rbp), %rdi
callq 0x2160
jmp 0x2aa0
jmp 0x2a89
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x295a
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x23b0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movl 0x14(%rsi), %edi
addq $0x118, %rsi            # imm = 0x118
leaq -0xc(%rbp), %rdx
callq 0x20c0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x2024, %edi           # imm = 0x2024
callq 0x2210
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movl 0x18(%rax), %esi
callq 0x35e0
jmp 0x3502
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rcx)
movl $0x1, 0x1c(%rcx)
movl 0x10(%rcx), %edi
movl 0x18(%rcx), %edx
addq $0x1c, %rcx
movl $0x1, %esi
callq 0x22f0
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21f0
movq -0x20(%rbp), %rdi
callq 0x23b0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1f8, %edi            # imm = 0x1F8
movq %rdi, -0x38(%rbp)
callq 0x2210
movq -0x38(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorl %esi, %esi
callq 0x2140
movq -0x28(%rbp), %rdi
callq 0xc6f0
jmp 0xc691
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
leaq 0x4701(%rip), %rsi      # 0x10da8
callq *(%rax)
movq -0x10(%rbp), %rdi
callq 0xcdc0
movq -0x10(%rbp), %rdi
callq 0x27e0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc6bb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21f0
movq -0x18(%rbp), %rdi
callq 0x23b0
nopw %cs:(%rax,%rax)
nop