LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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_noresize(std::pair<unsigned int const, unsigned int> const&)
std::pair<iterator, bool> insert_noresize(const_reference obj) {
    // First, double-check we're not inserting delkey
    assert((!settings.use_deleted() || !equals(get_key(obj), key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(get_key(obj));
    if ( pos.first != ILLEGAL_BUCKET) {      // object was already there
      return std::pair<iterator,bool>(iterator(this, table.get_iter(pos.first),
                                               table.nonempty_end()),
                                      false);     // false: we didn't insert
    } else {                                 // pos.second says where to put it
      return std::pair<iterator,bool>(insert_at(obj, pos.second), true);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rsi)
jne 0x31f5
movl (%r15), %eax
cmpl 0x20(%r14), %eax
je 0x328e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e86
cmpq $-0x1, %rax
je 0x326b
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x2f4e
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
leaq 0x28(%rsp), %r15
movups %xmm1, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq %r14, (%r15)
movq %rax, 0x28(%r15)
movq %rcx, 0x30(%r15)
movq %rcx, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq %r15, %rdi
callq 0x36ba
movl $0x9, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
xorl %eax, %eax
jmp 0x327e
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32ae
movb $0x1, %al
movb %al, 0x48(%rbx)
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x37c2(%rip), %rdi      # 0x6a57
leaq 0xe6d(%rip), %rsi       # 0x4109
leaq 0x3817(%rip), %rcx      # 0x6aba
movl $0x3af, %edx            # imm = 0x3AF
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3373
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x33d8
testb %al, %al
je 0x3305
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x33a5
decq %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x284a
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2f4e
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 0x36ba
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 0x4050(%rip), %rsi      # 0x73d7
movq %rax, %rdi
callq 0x10c0
movq 0x6c4a(%rip), %rsi      # 0x9fe0
movq 0x6c33(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x1160
leaq 0x1ad7(%rip), %rdi      # 0x4e83
leaq 0xd56(%rip), %rsi       # 0x4109
leaq 0x402d(%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_O3/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 0x342b
testq %rax, %rax
je 0x3423
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x27f0
testb %al, %al
je 0x3423
movq %r15, %rdi
movq %r14, %rsi
callq 0x346a
cmpq $0x0, 0x28(%rbx)
je 0x344a
movl 0x20(%rbx), %ecx
cmpl (%rax), %ecx
sete %al
jmp 0x3425
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1716(%rip), %rdi      # 0x4b48
leaq 0xcd0(%rip), %rsi       # 0x4109
leaq 0x2c6c(%rip), %rcx      # 0x60ac
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10a0
leaq 0x1a32(%rip), %rdi      # 0x4e83
leaq 0xcb1(%rip), %rsi       # 0x4109
leaq 0x1a34(%rip), %rcx      # 0x4e93
movl $0x1da, %edx            # imm = 0x1DA
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r12
movq %r12, %rdi
callq 0x8b12
leaq 0x8(%rbx), %r13
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x44ed
leaq -0x8(%rsi), %rax
leaq -0x4(%rsi), %rcx
jmp 0x450a
movq 0x50(%rbx), %rax
movq -0x8(%rax), %rsi
leaq 0x1f8(%rsi), %rax
leaq 0x1fc(%rsi), %rcx
addq $0x200, %rsi            # imm = 0x200
movl (%rax), %r14d
movl (%rcx), %ebp
addq $-0x8, %rsi
movq %r12, %rdi
callq 0x8876
movq %r13, %rdi
callq 0x4ec0
cmpl (%r15), %r14d
jne 0x44d9
movq (%rsp), %rax
cmpl (%rax), %ebp
jne 0x44d9
addq $0x148, %rbx            # imm = 0x148
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4bda
leaq 0x8(%rsp), %rdi
callq 0x8b3e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x455f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8b3e
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, (%rdi)
movq 0x160(%rdi), %rbp
cmpq 0x168(%rdi), %rbp
je 0x488b
movq %rdi, %rbx
leaq 0x58(%rdi), %r15
leaq 0x88(%rdi), %r14
leaq 0xb8(%rdi), %r12
movq %rsp, %r13
movl (%rbp), %eax
movl %eax, (%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r13, %rsi
callq 0x5932
movl (%rbp), %eax
movl %eax, (%rsp)
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x5932
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 0x5932
addq $0x4, %rbp
cmpq 0x168(%rbx), %rbp
jne 0x47f1
movq 0x160(%rbx), %r15
cmpq %r15, %rbp
je 0x488b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c06
cmpl $0x0, (%rax)
jne 0x487e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4574
addq $0x4, %r15
cmpq 0x168(%rbx), %r15
jne 0x4863
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
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 %ebx, %ebx
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x59dc
leaq 0x60(%r14), %rax
movl %ebx, 0x60(%r14)
movq %rbx, 0x68(%r14)
movq %rax, 0x70(%r14)
movq %rax, 0x78(%r14)
movq %rbx, 0x80(%r14)
leaq 0x90(%r14), %rax
movl %ebx, 0x90(%r14)
movq %rbx, 0x98(%r14)
movq %rax, 0xa0(%r14)
movq %rax, 0xa8(%r14)
movq %rbx, 0xb0(%r14)
leaq 0xc0(%r14), %rax
movl %ebx, 0xc0(%r14)
movq %rbx, 0xc8(%r14)
movq %rax, 0xd0(%r14)
movq %rax, 0xd8(%r14)
movq %rbx, 0xe0(%r14)
leaq 0xe8(%r14), %r15
movq %r15, %rdi
callq 0x8b12
leaq 0x180(%r14), %rax
movl %ebx, 0x180(%r14)
movq %rbx, 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 %rbx, 0x1a0(%r14)
leaq 0x1a8(%r14), %r12
leaq 0x1b0(%r14), %rbp
movl %ebx, 0x1b0(%r14)
movq %rbx, 0x1b8(%r14)
movq %rbp, 0x1c0(%r14)
movq %rbp, 0x1c8(%r14)
movq %rbx, 0x1d0(%r14)
movq %r15, %rdi
movq %r13, %rsi
callq 0x8b78
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x83f6
movq 0x160(%r14), %rdi
movq 0x170(%r14), %rsi
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x160(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x170(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4a44
subq %rdi, %rsi
callq 0x2160
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4a44
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x83b6
movq %r12, %rdi
callq 0x4d24
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x4aa5
leaq 0x18(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x1b0(%r14)
movq %rax, 0x1b8(%r14)
movups 0x10(%rcx), %xmm0
movups %xmm0, 0x1c0(%r14)
movq %rbp, 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 0x10(%rsp), %rdi
callq 0x4db4
movq %r14, %rdi
callq 0x47b4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4acf
jmp 0x4acf
movq %rax, %rbx
jmp 0x4b1b
movq %rax, %rbx
leaq 0x148(%r14), %rbp
leaq 0x178(%r14), %r13
movq %r12, %rdi
callq 0x4db4
movq %r13, %rdi
callq 0x4dc8
movq 0x160(%r14), %rdi
testq %rdi, %rdi
je 0x4b0b
movq 0x170(%r14), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbp, %rdi
callq 0x4cd2
movq %r15, %rdi
callq 0x8b3e
leaq 0xb8(%r14), %rdi
leaq 0x88(%r14), %r15
addq $0x58, %r14
callq 0x4e18
movq %r15, %rdi
callq 0x4e18
movq %r14, %rdi
callq 0x4e18
movq 0x8(%rsp), %rdi
callq 0x4e68
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x83f6
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
testq %r13, %r13
je 0x5b8a
movq 0x18(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x2160
cmpq %r15, %r13
je 0x5c08
movq %r14, %rdi
callq 0x5c2e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8a40
movq 0x90(%r14), %r13
cmpq %rbp, %r13
je 0x5be4
cmpb $0x0, 0x24(%r13)
jne 0x5bc8
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x7f48
testb $0x1, 0x24(%r13)
je 0x5bd4
movl 0x20(%r13), %esi
movq %rbx, %rdi
callq 0x7f48
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
cmpq %rbp, %rax
jne 0x5bae
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4bda
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5b38
movq %r12, %rdi
callq 0x8b3e
jmp 0x5b60
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c19
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8b3e
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x83f6
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 0x5f4e
leaq 0x78(%rbx), %r14
movq %r14, %rdi
callq 0x5e1a
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x5e9e
movq %r14, %rdi
callq 0x5e1a
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5ce8
leaq 0x80(%rbx), %rcx
leaq 0x18(%rsp), %rdx
movl (%rdx), %esi
movl %esi, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movups 0x10(%rdx), %xmm0
movups %xmm0, 0x90(%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 0x5e84
leaq 0x40(%rsp), %rdi
callq 0x616a
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x616a
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5c2e
movq 0x90(%rbx), %rax
subq $-0x80, %rbx
cmpq %rbx, %rax
je 0x5d53
movb 0x24(%rax), %bpl
testb %bpl, %bpl
je 0x5d56
movq %rax, %rdi
callq 0x20f0
cmpq %rbx, %rax
jne 0x5d3b
jmp 0x5d56
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c6c
movq (%rax), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
je 0x5f3f
leaq 0xc0(%r14), %r13
leaq 0x60(%r14), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x61b4
cmpb $0x0, (%rax)
jne 0x5f2a
movq %r13, %rdi
movq %r12, %rsi
callq 0x61b4
movb $0x1, (%rax)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8464
movq %r14, %rdi
movq %r12, %rsi
callq 0x5eb4
addq $0x4, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
jne 0x5ef3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8b12
leaq 0x60(%rbx), %rdi
movq %rdi, 0x30(%rsp)
callq 0x8b12
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 0x108(%rbx), %r12
leaq 0x110(%rbx), %r14
movl %ecx, 0x110(%rbx)
movq %rcx, 0x118(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movq %r14, 0x120(%rbx)
movq %r14, 0x128(%rbx)
movq %rcx, 0x130(%rbx)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x8b78
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x83f6
movq 0xf0(%rbx), %rdi
movq 0x100(%rbx), %rsi
movaps (%rsp), %xmm0
movups %xmm0, 0xf0(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x100(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x6052
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6052
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x83b6
movq %r12, %rdi
callq 0x4d24
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x60af
leaq 0x8(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movups 0x10(%rcx), %xmm0
movups %xmm0, 0x120(%rbx)
movq %r14, 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)
movq %rsp, %rdi
callq 0x4db4
movq 0xf0(%rbx), %r14
cmpq 0xf8(%rbx), %r14
je 0x60ed
movq %rsp, %rbp
movl (%r14), %eax
movl %eax, (%rsp)
movb $0x0, 0x4(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x65b2
addq $0x4, %r14
cmpq 0xf8(%rbx), %r14
jne 0x60ca
movq %r15, %rdi
movq %r13, %rsi
callq 0x61b4
movb $0x1, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5eb4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6122
jmp 0x6122
jmp 0x6122
movq %rax, %r13
jmp 0x615a
jmp 0x6122
movq %rax, %r13
movq %r12, %rdi
callq 0x4db4
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x6148
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x5e84
movq 0x30(%rsp), %rdi
callq 0x8b3e
movq %rbx, %rdi
callq 0x8b3e
movq %r13, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15d
movl %r15d, 0x4(%rsp)
movq 0xb946(%rip), %r14      # 0x11fd8
leaq 0x59df(%rip), %rsi      # 0xc078
movl $0x13, %edx
movq %r14, %rdi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
callq 0x21f0
movq %rax, %r12
leaq 0x59d2(%rip), %rsi      # 0xc08c
movl $0x4, %edx
movq %rax, %rdi
callq 0x2180
movq %r12, %rdi
movl %r15d, %esi
callq 0x21f0
movq %rax, %r15
leaq 0x59b5(%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 0x6754
movq 0xb8b5(%rip), %r15      # 0x11fd8
leaq 0x596c(%rip), %r12      # 0xc096
cmpq (%r13), %rbp
je 0x6740
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 0x672a
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 0x5919(%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 0x58d6(%rip), %rsi      # 0xc0a8
movl $0xb, %edx
movq %r14, %rdi
callq 0x2180
addq $0x108, %rbx            # imm = 0x108
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x719e
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7204
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)
movq 0xe8(%r15), %rax
testq %rax, %rax
je 0x68f4
leaq 0xe0(%r15), %r13
movl (%r12), %ebp
movq %r13, %rcx
xorl %edx, %edx
cmpl %ebp, 0x20(%rax)
setl %dl
cmovgeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x689f
cmpq %r13, %rcx
je 0x68f4
cmpl 0x20(%rcx), %ebp
jl 0x68f4
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)
movq 0xe8(%r15), %rax
testq %rax, %rax
jne 0x689c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7240
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_O3/AraKhachatryan[P]GraphAlgo/dijkstra.cpp
// Function: GraphAlgo::dijkstra::set_edge_weight(int const&, int const&, double)
void dijkstra::
set_edge_weight( const vertex& s, const vertex& d, double w )
{
	if ( e_weight.find(edge(s,d)) != e_weight.end() ) {
		e_weight[edge(s,d)] = w;
	} else if ( e_weight.find( edge(d,s)) != e_weight.end() ) {
		e_weight[edge(d,s)] = w;
	} else {
		e_weight.insert( edge_weight::value_type(edge(s, d), w) );
	}
}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x168(%rdi), %rbx
movl (%rsi), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%rdx), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x76da
addq $0x170, %r13            # imm = 0x170
cmpq %r13, %rax
je 0x6ade
movl (%r15), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r14), %eax
jmp 0x6b0b
movq %rax, %r12
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x76da
cmpq %r12, %rax
je 0x6b28
movl (%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl (%r15), %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
callq 0x7290
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movsd 0x5540(%rip), %xmm0     # 0xc070
jmp 0x6b1a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x719e
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6a90
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x719e
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x6c4b
leaq 0x138(%r14), %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x719e
movsd (%rax), %xmm0
movl (%rbx), %eax
leaq 0x8(%rsp), %rbp
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x7b1e
movq %r13, %rdi
movq %rax, %rsi
callq 0x7c02
movq %r12, %rdi
movq %r15, %rsi
callq 0x719e
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6a90
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x719e
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x719e
movsd (%rax), %xmm0
movl (%rbx), %eax
movsd %xmm0, (%rbp)
movl %eax, 0x8(%rbp)
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x7ca8
movl (%r15), %ebp
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c06
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_O3/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 0x7e04
leaq 0x138(%rbx), %r12
movq %r12, %rdi
callq 0x7c7a
leaq 0xd8(%rbx), %rdi
callq 0x7e32
movq 0x60(%rbx), %rbp
cmpq 0x68(%rbx), %rbp
je 0x6d0b
movq %rsp, %r13
movl (%rbp), %eax
cmpl (%r14), %eax
jne 0x6ccc
movl %eax, (%rsp)
xorl %r15d, %r15d
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x7e60
movl (%r14), %eax
jmp 0x6cee
movl %eax, (%rsp)
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x7e60
movl (%rbp), %eax
movq %r15, (%rsp)
movl %eax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7ca8
addq $0x4, %rbp
cmpq 0x68(%rbx), %rbp
jne 0x6ca7
movq 0x78(%rbx), %r12
cmpq 0x80(%rbx), %r12
je 0x6d4b
leaq 0x168(%rbx), %r14
movq %rsp, %r15
movq (%r12), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x79b8
addq $0x8, %r12
cmpq 0x80(%rbx), %r12
jne 0x6d22
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c5a
cmpq $0x0, 0x160(%rbx)
je 0x6ddf
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 0x7f0c
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c6c
movq (%rax), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r13
je 0x6dd5
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6b32
addq $0x4, %r13
jmp 0x6db0
cmpq $0x0, 0x160(%rbx)
jne 0x6d8c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c6c
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x7faa
leaq 0x4(%rsp), %r15
movl 0x4(%rsp), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
movq 0x8(%rax), %rax
movl -0x4(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x800a
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x7f76
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x92a4
movq %r14, %rdi
movq %rax, %rsi
callq 0x9322
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq %r15, %rdx
callq 0x9397
movq 0x20(%rbx), %rdx
cmpq %rdx, %rax
je 0x7ffe
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x7ff6
subq %rsi, %rdx
movq %rax, %rdi
callq 0x21d0
movq 0x20(%rbx), %rdx
addq $-0x4, %rdx
movq %rdx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::remove_edge(int, int)
void graph::
remove_edge( vertex s, vertex d )
{
	edges::iterator e_it = find( m_edges.begin(), m_edges.end(), edge(s, d) );
	if ( e_it != m_edges.end() ) 
	{
		m_edges.erase(e_it);
	}
	
	e_it = find( m_edges.begin(), m_edges.end(), edge(d, s) );
	if ( e_it != m_edges.end() ) 
	{
		m_edges.erase(e_it);
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, (%rdx)
movl %r14d, 0x4(%rdx)
callq 0x943c
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
je 0x8083
leaq 0x8(%rax), %rdx
cmpq %rsi, %rdx
je 0x807b
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x807b
incq %rcx
addq $0xc, %rax
movq -0x4(%rax), %rdx
movq %rdx, -0xc(%rax)
decq %rcx
addq $0x8, %rax
cmpq $0x1, %rcx
ja 0x8066
addq $-0x8, %rsi
movq %rsi, 0x8(%rbx)
leaq 0x10(%rsp), %rdx
movl %r14d, (%rdx)
movl %ebp, 0x4(%rdx)
callq 0x943c
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x80d8
leaq 0x8(%rax), %rsi
cmpq %rcx, %rsi
je 0x80d0
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
testq %rdx, %rdx
jle 0x80d0
incq %rdx
addq $0xc, %rax
movq -0x4(%rax), %rsi
movq %rsi, -0xc(%rax)
decq %rdx
addq $0x8, %rax
cmpq $0x1, %rdx
ja 0x80bb
addq $-0x8, %rcx
movq %rcx, 0x8(%rbx)
addq $0x30, %rbx
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x9397
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r14
je 0x8153
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c6c
movq %rax, %r15
leaq 0x4(%r14), %rsi
movq 0x8(%rax), %rdx
cmpq %rdx, %rsi
je 0x814b
subq %rsi, %rdx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%r15), %rdx
addq $-0x4, %rdx
movq %rdx, 0x8(%r15)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
movq (%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x9397
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r14
je 0x81ca
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c6c
movq %rax, %rbx
leaq 0x4(%r14), %rsi
movq 0x8(%rax), %rdx
cmpq %rdx, %rsi
je 0x81c2
subq %rsi, %rdx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdx
addq $-0x4, %rdx
movq %rdx, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x845a
movq %rdi, %r14
movq 0x28(%r15), %r12
cmpq 0x30(%r15), %r12
je 0x844a
leaq 0x20(%r15), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x8464
addq $0x4, %r12
cmpq 0x30(%r15), %r12
jne 0x8432
movq %r15, %rdi
callq 0x2190
movq %rax, %r15
cmpq %rbx, %rax
jne 0x8424
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x84d2
movq 0x9b56(%rip), %r12      # 0x11fd8
leaq 0x3c5a(%rip), %rsi      # 0xc0e3
movl $0x8, %edx
movq %r12, %rdi
callq 0x2180
leaq 0x3c4f(%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 0x82d6
testb %al, %al
jne 0x85ec
movl (%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl (%r14), %eax
movl %eax, 0x4(%rsi)
movq %r15, %rdi
callq 0x990c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8662
movq %r15, %rdi
movq %r14, %rsi
callq 0x8662
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq (%rax), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x9397
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
jne 0x8582
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8577
movl (%r14), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x8582
movq %rax, %rdi
movq %r14, %rdx
callq 0x95f2
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c6c
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x9397
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
jne 0x85ec
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x85e1
movl (%rbx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x85ec
movq %rax, %rdi
movq %rbx, %rdx
callq 0x95f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81f4
testb %al, %al
jne 0x8999
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x88a8
movq (%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x88b3
movq %r14, %rdi
movq %rbx, %rdx
callq 0x97e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8662
leaq 0x4(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8662
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq (%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x9397
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
jne 0x893c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8931
movl (%r15), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x893c
movq %rax, %rdi
movq %r15, %rdx
callq 0x95f2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
movq (%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x9397
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
cmpq 0x8(%rax), %r12
jne 0x8999
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c6c
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x89a5
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 0x95f2
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %r14, %rdi
callq 0x4d24
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8a92
movq %rax, 0x8(%rbx)
movq (%r15), %r12
cmpq 0x8(%r15), %r12
je 0x8aac
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8876
addq $0x8, %r12
jmp 0x8a95
movq 0x18(%r15), %r12
cmpq 0x20(%r15), %r12
je 0x8ac7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8662
addq $0x4, %r12
jmp 0x8ab0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8ad5
movq %rax, %r15
movq %r14, %rdi
callq 0x4db4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8af5
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8b09
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8b91
movq %rax, 0x20(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x4d24
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8ba7
movq %rax, 0x8(%rbx)
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x8bc1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8876
addq $0x8, %r15
jmp 0x8baa
movq 0x18(%r14), %r15
cmpq 0x20(%r14), %r15
je 0x8bdc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8662
addq $0x4, %r15
jmp 0x8bc5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop