LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_at(std::pair<unsigned int const, unsigned int> const&, unsigned long)
iterator insert_at(const_reference obj, size_type pos) {
    if (size() >= max_size()) {
      throw std::length_error("insert overflow");
    }
    if ( test_deleted(pos) ) {      // just replace if it's been deleted
      // The set() below will undelete this object.  We just worry about stats
      assert(num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    }
    table.set(pos, obj);
    return iterator(this, table.get_iter(pos), table.nonempty_end());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq 0x50(%rsi), %rax
subq 0x28(%rsi), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jae 0x33d7
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x343c
testb %al, %al
je 0x3369
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x3409
decq %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2898
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2fa8
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %r14, (%rbx)
movq %rax, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x371e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1070
movq %rax, %rbx
leaq 0x3fec(%rip), %rsi      # 0x73d7
movq %rax, %rdi
callq 0x10c0
movq 0x6be6(%rip), %rsi      # 0x9fe0
movq 0x6bcf(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x1160
leaq 0x1a73(%rip), %rdi      # 0x4e83
leaq 0xcf2(%rip), %rsi       # 0x4109
leaq 0x3fc9(%rip), %rcx      # 0x73e7
movl $0x3a4, %edx            # imm = 0x3A4
callq 0x10a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::test_deleted(unsigned long) const
bool test_deleted(size_type bucknum) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && table.test(bucknum) &&
        test_deleted_key(get_key(table.unsafe_get(bucknum)));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
sete %cl
orb 0x1a(%rdi), %cl
je 0x348f
testq %rax, %rax
je 0x3487
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x283e
testb %al, %al
je 0x3487
movq %r15, %rdi
movq %r14, %rsi
callq 0x34ce
cmpq $0x0, 0x28(%rbx)
je 0x34ae
movl 0x20(%rbx), %ecx
cmpl (%rax), %ecx
sete %al
jmp 0x3489
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16b2(%rip), %rdi      # 0x4b48
leaq 0xc6c(%rip), %rsi       # 0x4109
leaq 0x2c08(%rip), %rcx      # 0x60ac
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10a0
leaq 0x19ce(%rip), %rdi      # 0x4e83
leaq 0xc4d(%rip), %rsi       # 0x4109
leaq 0x19d0(%rip), %rcx      # 0x4e93
movl $0x1da, %edx            # imm = 0x1DA
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::new_bicomponent(int const&, int const&)
void biconnectivity::
new_bicomponent( const vertex& v, const vertex& w )
{
	int f, s ;
	graph gr;

	do {
		f = m_edge_stack.top().first;
		s = m_edge_stack.top().second;
		gr.add_edge(m_edge_stack.top());
		m_edge_stack.pop();
	} while ( ! ( f == v && s == w) );

	graphs_out.push_back(gr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8c52
leaq 0x8(%rbx), %r13
movl $0x200, %ebp            # imm = 0x200
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rcx
movq %rsi, %rax
cmpq %rcx, %rsi
jne 0x45d6
movq 0x50(%rbx), %rax
movq -0x8(%rax), %rax
addq %rbp, %rax
movq %rsi, %rdx
cmpq %rcx, %rsi
jne 0x45e9
movq 0x50(%rbx), %rdx
movq -0x8(%rdx), %rdx
addq %rbp, %rdx
cmpq %rcx, %rsi
jne 0x45f9
movq 0x50(%rbx), %rcx
movq -0x8(%rcx), %rsi
addq %rbp, %rsi
movl -0x8(%rax), %r12d
movl -0x4(%rdx), %r14d
addq $-0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x89a8
movq %r13, %rdi
callq 0x4f90
cmpl (%r15), %r12d
jne 0x45bb
movq (%rsp), %rax
cmpl (%rax), %r14d
jne 0x45bb
addq $0x148, %rbx            # imm = 0x148
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4cbc
leaq 0x8(%rsp), %rdi
callq 0x8c7e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4654
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8c7e
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::bicomponents()
void biconnectivity::
bicomponents()
{
	time =  0;

	vertices::const_iterator it = m_vertices.begin();
	for ( ; it != m_vertices.end(); ++it)
	{
		m_parent.insert(parent::value_type( *it, -1 ));
		m_discovery_time.insert(discovery_time::value_type( *it, time ));
		m_back.insert(back::value_type( *it,  m_vertices.size()  + 1 ));
	}
	
	vertices::const_iterator it2 = m_vertices.begin();
	for ( ; it2 != m_vertices.end(); ++it2)
	{
		if( m_discovery_time[*it2] == 0) {
			biDFS(*it2);     // for each connected graph
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, (%rdi)
movq 0x160(%rdi), %rbp
cmpq 0x168(%rdi), %rbp
je 0x4949
leaq 0x58(%rbx), %r14
leaq 0x88(%rbx), %r15
leaq 0xb8(%rbx), %r12
movq %rsp, %r13
movl (%rbp), %eax
movl %eax, (%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %r13, %rsi
callq 0x59ea
movl (%rbp), %eax
movl %eax, (%rsp)
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x59ea
movq 0x168(%rbx), %rax
subq 0x160(%rbx), %rax
shrq $0x2, %rax
movl (%rbp), %ecx
movl %ecx, (%rsp)
incl %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x59ea
addq $0x4, %rbp
cmpq 0x168(%rbx), %rbp
jne 0x48e3
movq 0x160(%rbx), %r14
cmpq 0x168(%rbx), %r14
je 0x4988
leaq 0x88(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ce8
cmpl $0x0, (%rax)
jne 0x497b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x466a
addq $0x4, %r14
cmpq 0x168(%rbx), %r14
jne 0x4960
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::biconnectivity(GraphAlgo::graph const&)
biconnectivity::
biconnectivity( const graph& g )
{
	g_in = g;

	m_vertices = g_in.get_vertices();
	m_neighborhood = g_in.get_neighborhood();
		
	bicomponents();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbp
movq %rdi, %r14
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
xorl %r12d, %r12d
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0x5a94
leaq 0x60(%r14), %rax
movl %r12d, 0x60(%r14)
movq %r12, 0x68(%r14)
movq %rax, 0x70(%r14)
movq %rax, 0x78(%r14)
movq %r12, 0x80(%r14)
leaq 0x90(%r14), %rax
movl %r12d, 0x90(%r14)
movq %r12, 0x98(%r14)
movq %rax, 0xa0(%r14)
movq %rax, 0xa8(%r14)
movq %r12, 0xb0(%r14)
leaq 0xc0(%r14), %rax
movl %r12d, 0xc0(%r14)
movq %r12, 0xc8(%r14)
movq %rax, 0xd0(%r14)
movq %rax, 0xd8(%r14)
movq %r12, 0xe0(%r14)
leaq 0xe8(%r14), %r15
movq %r15, %rdi
callq 0x8c52
leaq 0x160(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x180(%r14), %rax
movl %r12d, 0x180(%r14)
movq %r12, 0x188(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%r14)
movups %xmm0, 0x158(%r14)
movups %xmm0, 0x168(%r14)
movq %rax, 0x190(%r14)
movq %rax, 0x198(%r14)
movq %r12, 0x1a0(%r14)
leaq 0x1a8(%r14), %r13
leaq 0x1b0(%r14), %rbx
movl %r12d, 0x1b0(%r14)
movq %r12, 0x1b8(%r14)
movq %rbx, 0x1c0(%r14)
movq %rbx, 0x1c8(%r14)
movq %r12, 0x1d0(%r14)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x8cb8
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x8528
leaq 0x18(%rsp), %rbp
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x5bee
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4b1b
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x84e8
movq %r13, %rdi
callq 0x4dfc
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x4b86
leaq 0x20(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x1b0(%r14)
movq %rax, 0x1b8(%r14)
movq 0x10(%rcx), %rdx
movq %rdx, 0x1c0(%r14)
movq 0x18(%rcx), %rdx
movq %rdx, 0x1c8(%r14)
movq %rbx, 0x8(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x1d0(%r14)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x18(%rsp), %rdi
callq 0x4e8c
movq %r14, %rdi
callq 0x48aa
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4bb0
jmp 0x4bb0
movq %rax, %rbx
jmp 0x4bfd
movq %rax, %rbx
leaq 0x148(%r14), %r12
leaq 0x178(%r14), %rbp
movq %r13, %rdi
callq 0x4e8c
movq %rbp, %rdi
callq 0x4ea0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4bed
movq 0x170(%r14), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r12, %rdi
callq 0x4db0
movq %r15, %rdi
callq 0x8c7e
leaq 0xb8(%r14), %rdi
leaq 0x88(%r14), %r15
addq $0x58, %r14
callq 0x4ef0
movq %r15, %rdi
callq 0x4ef0
movq %r14, %rdi
callq 0x4ef0
movq 0x10(%rsp), %rdi
callq 0x4f40
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::connected_parts(GraphAlgo::graph&)
void connectivity::
connected_parts( graph& g_in ) 
{
	while( !g_in.get_vertices().empty() )
	{
		initialize();	

		graph g_copy = g_in;
		visit::iterator it = m_visit.begin();
		for ( ; it != m_visit.end(); ++it )
		{
			if ( it->second == false ) {
				g_copy.remove_vertex(it->first);
			}
			if ( it->second == true ) {
				g_in.remove_vertex(it->first);	
			}
		}
		graphs_out.push_back( g_copy );

		connected_parts( g_in );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rdi), %rbp
leaq 0x60(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8528
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
testq %r13, %r13
je 0x5c82
movq 0x18(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x2160
cmpq %r15, %r13
je 0x5d00
movq %r14, %rdi
callq 0x5d26
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8b72
movq 0x90(%r14), %r13
cmpq %rbp, %r13
je 0x5cdc
cmpb $0x0, 0x24(%r13)
jne 0x5cb9
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x807c
cmpb $0x1, 0x24(%r13)
jne 0x5ccc
movl 0x20(%r13), %esi
movq %rbx, %rdi
callq 0x807c
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
cmpq %rbp, %rax
jne 0x5ca6
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4cbc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c30
movq %r12, %rdi
callq 0x8c7e
jmp 0x5c58
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d11
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8c7e
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::initialize()
void connectivity::
initialize()
{	
	vertex first = g_in.get_vertices().front();
	
	dfs tree(g_in, first);
	
	m_visit.clear();
	m_visit = tree.get_visit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8528
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movl (%rdi), %ebp
subq %rdi, %rsi
callq 0x2160
leaq 0xc(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6042
leaq 0x78(%rbx), %r14
movq %r14, %rdi
callq 0x5f0c
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x5f92
movq %r14, %rdi
callq 0x5f0c
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5deb
leaq 0x80(%rbx), %rcx
leaq 0x18(%rsp), %rdx
movl (%rdx), %esi
movl %esi, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq 0x18(%rdx), %rsi
movq %rsi, 0x98(%rbx)
movq %rcx, 0x8(%rax)
movq 0x20(%rdx), %rax
movq %rax, 0xa0(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rax, 0x20(%rdx)
leaq 0x10(%rsp), %rdi
callq 0x5f76
leaq 0x40(%rsp), %rdi
callq 0x625a
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x625a
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::is_connected()
bool connectivity::
is_connected()
{
	initialize();	

	visit::iterator it = m_visit.begin();
	for( ; it != m_visit.end(); ++it )
	{
		if ( it->second == false ) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5d26
movq 0x90(%rbx), %rax
subq $-0x80, %rbx
cmpq %rbx, %rax
sete %cl
je 0x5e4e
cmpb $0x0, 0x24(%rax)
je 0x5e4e
movq %rax, %rdi
callq 0x20f0
jmp 0x5e36
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/dfs.cpp
// Function: GraphAlgo::dfs::dfs_traversal(int const&)
void dfs::
dfs_traversal( const vertex& v )
{
	vertices::const_iterator it = m_neighborhood[v].begin();
	for ( ; it != m_neighborhood[v].end(); ++it ) 
	{
		if ( ! m_visit[*it] ) 
		{
			m_visit[*it] = true ;
			g_out.add_edge(v, *it);
			dfs_traversal(*it);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x108(%rdi), %r15
movq %r15, %rdi
callq 0x4d4c
movq (%rax), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
je 0x6033
leaq 0xc0(%r14), %r13
leaq 0x60(%r14), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x62a4
cmpb $0x0, (%rax)
jne 0x601e
movq %r13, %rdi
movq %r12, %rsi
callq 0x62a4
movb $0x1, (%rax)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8596
movq %r14, %rdi
movq %r12, %rsi
callq 0x5fa8
addq $0x4, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
jne 0x5fe7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c52
leaq 0x60(%rbx), %r12
movq %r12, %rdi
callq 0x8c52
leaq 0xc0(%rbx), %r15
leaq 0xc8(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0xc8(%rbx)
movq %rcx, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
movq %rax, 0xe0(%rbx)
leaq 0xf0(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x108(%rbx), %rax
movq %rax, (%rsp)
leaq 0x110(%rbx), %r13
movl %ecx, 0x110(%rbx)
movq %rcx, 0x118(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movq %r13, 0x120(%rbx)
movq %r13, 0x128(%rbx)
movq %rcx, 0x130(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, 0x10(%rsp)
callq 0x8cb8
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x8528
leaq 0x18(%rsp), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x5bee
movq (%r12), %rdi
testq %rdi, %rdi
je 0x612b
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x84e8
movq (%rsp), %rdi
callq 0x4dfc
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x6196
leaq 0x20(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movq 0x10(%rcx), %rdx
movq %rdx, 0x120(%rbx)
movq 0x18(%rcx), %rdx
movq %rdx, 0x128(%rbx)
movq %r13, 0x8(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x130(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x18(%rsp), %rdi
callq 0x4e8c
movq 0xf0(%rbx), %r12
cmpq 0xf8(%rbx), %r12
je 0x61da
leaq 0x18(%rsp), %r14
movl (%r12), %eax
movl %eax, 0x18(%rsp)
movb $0x0, 0x1c(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x66a2
addq $0x4, %r12
cmpq 0xf8(%rbx), %r12
jne 0x61b5
movq %r15, %rdi
movq %rbp, %rsi
callq 0x62a4
movb $0x1, (%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5fa8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x620f
jmp 0x620f
jmp 0x620f
movq %rax, %r14
jmp 0x6249
jmp 0x620f
movq %rax, %r14
movq (%rsp), %rdi
callq 0x4e8c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6237
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x5f76
movq 0x10(%rsp), %rdi
callq 0x8c7e
movq %rbx, %rdi
callq 0x8c7e
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
movq 0xc0(%rdi), %rax
movl 0x10(%rax), %ebp
movq 0xc8(%rdi), %rax
movl 0x10(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0xb858(%rip), %r14      # 0x11fd8
leaq 0x58f1(%rip), %rsi      # 0xc078
movl $0x13, %edx
movq %r14, %rdi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
callq 0x21f0
movq %rax, %r15
leaq 0x58e4(%rip), %rsi      # 0xc08c
movl $0x4, %edx
movq %rax, %rdi
callq 0x2180
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x21f0
movq %rax, %r15
leaq 0x58c6(%rip), %rsi      # 0xc091
movl $0x4, %edx
movq %rax, %rdi
callq 0x2180
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0xc0(%rbx), %rbp
cmpq %r13, %rbp
je 0x6843
movq 0xb7c6(%rip), %r15      # 0x11fd8
leaq 0x587d(%rip), %r12      # 0xc096
cmpq (%r13), %rbp
je 0x682f
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movl 0x10(%rbp), %esi
movq %r15, %rdi
callq 0x21f0
movq (%rbp), %rbp
cmpq %r13, %rbp
jne 0x6819
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x582a(%rip), %rsi      # 0xc09b
movl $0xc, %edx
movq %r14, %rdi
callq 0x2180
movq 0xd0(%rbx), %rsi
decq %rsi
movq %r14, %rdi
callq 0x20d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x57e7(%rip), %rsi      # 0xc0a8
movl $0xb, %edx
movq %r14, %rdi
callq 0x2180
addq $0x108, %rbx            # imm = 0x108
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x723c
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x21c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc0(%rsi), %r14
movq %r14, %rdi
callq 0x72a0
movq 0xc0(%r15), %r13
movl $0x18, %edi
callq 0x2150
movl (%r12), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0x2050
incq 0xd0(%r15)
movl (%r12), %ebp
leaq 0xe0(%r15), %r13
movq 0xe8(%r15), %rcx
movq %r13, %rax
testq %rcx, %rcx
je 0x69a8
movq %r13, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x6992
movq %r13, %rcx
cmpq %r13, %rax
je 0x69ba
cmpl 0x20(%rax), %ebp
cmovlq %r13, %rax
movq %rax, %rcx
cmpq %r13, %rcx
je 0x69ea
movl 0x24(%rcx), %ebp
movq 0xc0(%r15), %r12
movl $0x18, %edi
callq 0x2150
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2050
incq 0xd0(%r15)
jmp 0x6980
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
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 0x7780
addq $0x170, %r12            # imm = 0x170
cmpq %r12, %rax
je 0x6a59
movl (%r15), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
jmp 0x6a83
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x7780
cmpq %r12, %rax
je 0x6aa3
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x732c
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %eax
movl (%r14), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x7a84
jmp 0x6a97
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x168(%rdi), %rbx
movq %rbx, %rdi
callq 0x7780
addq $0x170, %r15            # imm = 0x170
cmpq %r15, %rax
je 0x6b09
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73ba
jmp 0x6b40
movl 0x4(%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x7780
cmpq %r15, %rax
je 0x6b54
movl 0x4(%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x732c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x7a84
jmp 0x6b4a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x168(%rdi), %rbx
movl (%rsi), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%rdx), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x7780
addq $0x170, %r12            # imm = 0x170
cmpq %r12, %rax
je 0x6bb9
movl (%r15), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r14), %eax
jmp 0x6bdf
movl (%r14), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x7780
cmpq %r12, %rax
je 0x6bfa
movl (%r14), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x732c
movsd (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x546e(%rip), %xmm0     # 0xc070
jmp 0x6bee
// File: /workspace/github_cpp_makefile_star2_O1/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 0x723c
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6b74
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x723c
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x6d1d
leaq 0x138(%r14), %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x723c
movsd (%rax), %xmm0
movl (%rbx), %eax
leaq 0x8(%rsp), %rbp
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x7bea
movq %r13, %rdi
movq %rax, %rsi
callq 0x7ce2
movq %r12, %rdi
movq %r15, %rsi
callq 0x723c
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6b74
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x723c
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x723c
movsd (%rax), %xmm0
movl (%rbx), %eax
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x7d88
movl (%r15), %ebp
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ce8
movl %ebp, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ef8
leaq 0x138(%rbx), %r12
movq %r12, %rdi
callq 0x7d5a
leaq 0xd8(%rbx), %rdi
callq 0x7f26
movq 0x60(%rbx), %rbp
cmpq 0x68(%rbx), %rbp
je 0x6de0
movq %rsp, %r13
movl (%r14), %eax
cmpl %eax, (%rbp)
jne 0x6d9e
movl %eax, (%rsp)
xorl %r15d, %r15d
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x7f54
movl (%r14), %eax
jmp 0x6dc3
movl (%rbp), %eax
movl %eax, (%rsp)
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x7f54
movl (%rbp), %eax
movq %r15, (%rsp)
movl %eax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7d88
addq $0x4, %rbp
cmpq 0x68(%rbx), %rbp
jne 0x6d79
movq 0x78(%rbx), %r12
cmpq 0x80(%rbx), %r12
je 0x6e20
leaq 0x168(%rbx), %r14
movq %rsp, %r15
movq (%r12), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a84
addq $0x8, %r12
cmpq 0x80(%rbx), %r12
jne 0x6df7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d2c
cmpq $0x0, 0x160(%rbx)
je 0x6eb5
leaq 0x138(%rbx), %r14
leaq 0x90(%rbx), %r15
leaq 0xc(%rsp), %r12
movq 0x150(%rbx), %rsi
movl 0x28(%rsi), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
callq 0x8000
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d4c
movq (%rax), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r13
je 0x6eab
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6c04
addq $0x4, %r13
jmp 0x6e86
cmpq $0x0, 0x160(%rbx)
jne 0x6e62
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13
movq %rdi, %rbx
callq 0x8c52
leaq 0x60(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x78(%rbx), %r15
leaq 0x90(%rbx), %r12
leaq 0x98(%rbx), %r14
xorl %eax, %eax
movl %eax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movq %r14, 0xa8(%rbx)
movq %r14, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
leaq 0xc0(%rbx), %rbp
movq %rbp, 0xc8(%rbx)
movq %rbp, 0xc0(%rbx)
movq %rax, 0xd0(%rbx)
leaq 0xe0(%rbx), %rcx
movl %eax, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
movq %rcx, 0xf0(%rbx)
movq %rcx, 0xf8(%rbx)
movq %rax, 0x100(%rbx)
leaq 0x110(%rbx), %rcx
movl %eax, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movq %rcx, 0x120(%rbx)
movq %rcx, 0x128(%rbx)
movq %rax, 0x130(%rbx)
leaq 0x140(%rbx), %rcx
movl %eax, 0x140(%rbx)
movq %rax, 0x148(%rbx)
movq %rcx, 0x150(%rbx)
movq %rcx, 0x158(%rbx)
movq %rax, 0x160(%rbx)
leaq 0x170(%rbx), %rcx
movl %eax, 0x170(%rbx)
movq %rax, 0x178(%rbx)
movq %rcx, 0x180(%rbx)
movq %rcx, 0x188(%rbx)
movq %rax, 0x190(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8cb8
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x8528
leaq 0x18(%rsp), %r13
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x5bee
movq (%r13), %rdi
testq %rdi, %rdi
je 0x702e
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x851a
leaq 0x18(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x803c
movq (%r13), %rdi
testq %rdi, %rdi
je 0x7061
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x84e8
movq %r12, %rdi
callq 0x4dfc
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x70cb
leaq 0x20(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movq 0x10(%rcx), %rdx
movq %rdx, 0xa8(%rbx)
movq 0x18(%rcx), %rdx
movq %rdx, 0xb0(%rbx)
movq %r14, 0x8(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0xb8(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x18(%rsp), %rdi
callq 0x4e8c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70ea
jmp 0x70ea
jmp 0x70ea
movq %rax, (%rsp)
leaq 0xd8(%rbx), %r14
leaq 0x108(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x138(%rbx), %r13
leaq 0x168(%rbx), %rdi
callq 0x7448
movq %r13, %rdi
callq 0x7498
movq 0x10(%rsp), %rdi
callq 0x74e8
movq %r14, %rdi
callq 0x4ef0
movq (%rbp), %rdi
cmpq %rbp, %rdi
je 0x714c
movq (%rdi), %r14
movl $0x18, %esi
callq 0x2160
movq %r14, %rdi
cmpq %rbp, %r14
jne 0x7137
movq %r12, %rdi
callq 0x4e8c
movq (%r15), %rdi
testq %rdi, %rdi
je 0x716b
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7184
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x8c7e
movq (%rsp), %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movl %esi, (%rax)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4d4c
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x80de
leaq 0x4(%rsp), %r15
movl 0x4(%rsp), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
movq 0x8(%rax), %rax
movl -0x4(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8136
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x80aa
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x93de
movq %r14, %rdi
movq %rax, %rsi
callq 0x9456
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq %r15, %rdx
callq 0x94cb
movq 0x20(%rbx), %rdx
cmpq %rdx, %rax
je 0x812b
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x8126
subq %rsi, %rdx
movq %rax, %rdi
callq 0x21d0
addq $-0x4, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rcx
movl %esi, (%rcx)
movl %edx, 0x4(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x9564
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x81aa
leaq 0x8(%rax), %rsi
cmpq %rcx, %rsi
je 0x81a2
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
testq %rdx, %rdx
jle 0x81a2
incq %rdx
addq $0xc, %rax
movq -0x4(%rax), %rsi
movq %rsi, -0xc(%rax)
decq %rdx
addq $0x8, %rax
cmpq $0x1, %rdx
jg 0x818d
addq $-0x8, %rcx
movq %rcx, 0x8(%rbx)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movl (%rsp), %eax
leaq 0x8(%rsp), %rdx
movl %eax, (%rdx)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rdx)
callq 0x9564
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x820c
leaq 0x8(%rax), %rsi
cmpq %rcx, %rsi
je 0x8204
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
testq %rdx, %rdx
jle 0x8204
incq %rdx
addq $0xc, %rax
movq -0x4(%rax), %rsi
movq %rsi, -0xc(%rax)
decq %rdx
addq $0x8, %rax
cmpq $0x1, %rdx
jg 0x81ef
addq $-0x8, %rcx
movq %rcx, 0x8(%rbx)
addq $0x30, %rbx
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x94cb
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r14
je 0x827e
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d4c
movq %rax, %r15
leaq 0x4(%r14), %rsi
movq 0x8(%rax), %rdx
cmpq %rdx, %rsi
je 0x8279
subq %rsi, %rdx
movq %r14, %rdi
callq 0x21d0
addq $-0x4, 0x8(%r15)
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x94cb
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r14
je 0x82ea
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d4c
movq %rax, %rbx
leaq 0x4(%r14), %rsi
movq 0x8(%rax), %rdx
cmpq %rdx, %rsi
je 0x82e5
subq %rsi, %rdx
movq %r14, %rdi
callq 0x21d0
addq $-0x4, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x858c
movq %rdi, %r14
movq 0x28(%r15), %r12
cmpq 0x30(%r15), %r12
je 0x857c
leaq 0x20(%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x8596
addq $0x4, %r12
cmpq 0x30(%r15), %r12
jne 0x8564
movq %r15, %rdi
callq 0x2190
movq %rax, %r15
cmpq %rbx, %rax
jne 0x8556
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8604
movq 0x9a24(%rip), %r12      # 0x11fd8
leaq 0x3b28(%rip), %rsi      # 0xc0e3
movl $0x8, %edx
movq %r12, %rdi
callq 0x2180
leaq 0x3b1d(%rip), %rsi      # 0xc0ec
movl $0x2d, %edx
movq %r12, %rdi
callq 0x2180
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x83fe
testb %al, %al
jne 0x871e
movl (%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r14), %eax
movl %eax, 0x4(%rsi)
movq %r15, %rdi
callq 0x9a1e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8794
movq %r15, %rdi
movq %r14, %rsi
callq 0x8794
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq (%rax), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x94cb
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
jne 0x86b4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x86a9
movl (%r14), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x86b4
movq %rax, %rdi
movq %r14, %rdx
callq 0x9704
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d4c
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x94cb
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
jne 0x871e
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8713
movl (%rbx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x871e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x9704
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8312
testb %al, %al
jne 0x8acb
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x89da
movq (%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x89e5
movq %r14, %rdi
movq %rbx, %rdx
callq 0x98f4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8794
leaq 0x4(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8794
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq (%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x94cb
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
jne 0x8a6e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8a63
movl (%r15), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x8a6e
movq %rax, %rdi
movq %r15, %rdx
callq 0x9704
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
movq (%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x94cb
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
cmpq 0x8(%rax), %r12
jne 0x8acb
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d4c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8ad7
movl (%rbx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9704
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, 0x38(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x8bbd
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x4dfc
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8bd2
movq %rax, 0x8(%rbx)
movq (%r15), %r12
cmpq 0x8(%r15), %r12
je 0x8bec
movq %rbx, %rdi
movq %r12, %rsi
callq 0x89a8
addq $0x8, %r12
jmp 0x8bd5
movq 0x18(%r15), %r12
cmpq 0x20(%r15), %r12
je 0x8c07
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8794
addq $0x4, %r12
jmp 0x8bf0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8c15
movq %rax, %r15
movq %r14, %rdi
callq 0x4e8c
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8c35
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8c49
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8cd1
movq %rax, 0x20(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x4dfc
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8ce7
movq %rax, 0x8(%rbx)
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x8d01
movq %rbx, %rdi
movq %r15, %rsi
callq 0x89a8
addq $0x8, %r15
jmp 0x8cea
movq 0x18(%r14), %r15
cmpq 0x20(%r14), %r15
je 0x8d1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8794
addq $0x4, %r15
jmp 0x8d05
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop