LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: void ripser<sparse_distance_matrix>::add_coboundary<std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>>(compressed_sparse_matrix<diameter_entry_t>&, std::vector<std::pair<float, long>, std::allocator<std::pair<float, long>>> const&, unsigned long, unsigned short, unsigned long const&, std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>&, std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>&)
void add_coboundary(compressed_sparse_matrix<diameter_entry_t>& reduction_matrix,
	                    const std::vector<diameter_index_t>& columns_to_reduce,
	                    const size_t index_column_to_add, const coefficient_t factor,
	                    const size_t& dim, Column& working_reduction_column,
	                    Column& working_coboundary) {
		diameter_entry_t column_to_add(columns_to_reduce[index_column_to_add], factor);
		add_simplex_coboundary(column_to_add, dim, working_reduction_column, working_coboundary);

		for (diameter_entry_t simplex : reduction_matrix.subrange(index_column_to_add)) {
			set_coefficient(simplex, get_coefficient(simplex) * factor % modulus);
			add_simplex_coboundary(simplex, dim, working_reduction_column, working_coboundary);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r15
movq %rsi, %rbp
movq %rdi, %r14
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %rcx
movq (%rdx), %rax
movq %r15, %rdx
shlq $0x4, %rdx
movss (%rax,%rdx), %xmm0
movq 0x8(%rax,%rdx), %rsi
movq (%r9), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rcx, %r13
movq %r8, %r12
callq 0x8c28
movq %rbp, %rdi
movq %r15, %rsi
callq 0x9218
movq %rax, %rbp
movq %rdx, %r15
cmpq %r15, %rbp
je 0x8b76
movss (%rbp), %xmm0
movq 0x8(%rbp), %rsi
movq (%rbx), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rsp, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x8c28
addq $0x10, %rbp
jmp 0x8b4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: ripser<sparse_distance_matrix>::get_zero_apparent_facet(diameter_entry_t, long)
diameter_entry_t get_zero_apparent_facet(const diameter_entry_t simplex, const index_t dim) {
		diameter_entry_t facet = get_zero_pivot_facet(simplex, dim);
		return ((get_index(facet) != -1) &&
		        (get_index(get_zero_pivot_cofacet(facet, dim - 1)) == get_index(simplex)))
		           ? facet
		           : diameter_entry_t(-1);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0x7ca8
cmpq $-0x1, %rax
je 0x8c13
movq %rax, %rbx
decq %r15
movq %r12, %rdi
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
movq %rax, %rsi
movq %r15, %rdx
callq 0x7b96
movss 0x4(%rsp), %xmm0
cmpq %r14, %rax
je 0x8c19
pushq $-0x1
popq %rbx
xorps %xmm0, %xmm0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: void ripser<sparse_distance_matrix>::add_simplex_coboundary<std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>>(diameter_entry_t, long const&, std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>&, std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>&)
void add_simplex_coboundary(const diameter_entry_t simplex, const index_t& dim,
	                            Column& working_reduction_column, Column& working_coboundary) {
		static simplex_coboundary_enumerator cofacets(*this);
		working_reduction_column.push(simplex);
		cofacets.set_simplex(simplex, dim);
		while (cofacets.has_next()) {
			diameter_entry_t cofacet = cofacets.next();
			if (get_diameter(cofacet) <= threshold) working_coboundary.push(cofacet);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r14
movss %xmm0, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movb 0xa805(%rip), %al       # 0x13458
testb %al, %al
je 0x8cd3
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8f98
movss (%r13), %xmm0
movq 0x8(%r13), %rsi
movq (%r15), %rdx
leaq 0xa73d(%rip), %r15      # 0x133b8
movq %r15, %rdi
callq 0x7dcc
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x7e84
testb %al, %al
je 0x8cc4
movq %r15, %rdi
callq 0x7fe8
movss %xmm0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movss 0x30(%r14), %xmm1
ucomiss %xmm0, %xmm1
jb 0x8c8b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8f98
jmp 0x8c8b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa77e(%rip), %rdi      # 0x13458
callq 0x2310
testl %eax, %eax
je 0x8c57
andq $0x0, 0xa701(%rip)      # 0x133f0
leaq 0xa6c2(%rip), %rsi      # 0x133b8
xorps %xmm0, %xmm0
movups %xmm0, 0xa6d0(%rip)     # 0x133d0
movups %xmm0, 0xa6d5(%rip)     # 0x133dc
movzwl 0x38(%r14), %eax
movw %ax, 0xa6e5(%rip)       # 0x133f8
movq %r14, 0xa6e6(%rip)      # 0x13400
leaq 0x40(%r14), %rax
movq %rax, 0xa6e3(%rip)      # 0x13408
movups %xmm0, 0xa6e4(%rip)     # 0x13410
movups %xmm0, 0xa6ed(%rip)     # 0x13420
movups %xmm0, 0xa6f6(%rip)     # 0x13430
movups %xmm0, 0xa6fb(%rip)     # 0x1343c
movq %r14, 0xa708(%rip)      # 0x13450
leaq -0xfa7(%rip), %rdi      # 0x7da8
leaq 0xa472(%rip), %rdx      # 0x131c8
callq 0x21c0
leaq 0xa6f6(%rip), %rdi      # 0x13458
callq 0x2160
jmp 0x8c57
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: diameter_entry_t ripser<sparse_distance_matrix>::pop_pivot<std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>>(std::priority_queue<diameter_entry_t, std::vector<diameter_entry_t, std::allocator<diameter_entry_t>>, greater_diameter_or_smaller_index_comp<diameter_entry_t>>&)
diameter_entry_t pop_pivot(Column& column) {
		diameter_entry_t pivot(-1);
#ifdef USE_COEFFICIENTS
		while (!column.empty()) {
			if (get_coefficient(pivot) == 0)
				pivot = column.top();
			else if (get_index(column.top()) != get_index(pivot))
				return pivot;
			else
				set_coefficient(pivot,
				                (get_coefficient(pivot) + get_coefficient(column.top())) % modulus);
			column.pop();
		}
		return (get_coefficient(pivot) == 0) ? -1 : pivot;
#else
		while (!column.empty()) {
			pivot = column.top();
			column.pop();
			if (column.empty() || get_index(column.top()) != get_index(pivot)) return pivot;
			column.pop();
		}
		return -1;
#endif
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
pushq $-0x1
popq %r15
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x8db4
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x8(%rax), %r14
movq %rbx, %rdi
callq 0x93fa
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x8dc0
cmpq %r14, 0x8(%rax)
jne 0x8dc0
movq %rbx, %rdi
callq 0x93fa
jmp 0x8d7c
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %r14
movss 0xc(%rsp), %xmm0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: ripser<compressed_distance_matrix<(compressed_matrix_layout)0>>::simplex_coboundary_enumerator::set_simplex(diameter_entry_t, long)
void set_simplex(const diameter_entry_t _simplex, const index_t _dim) {
		idx_below = get_index(_simplex);
		idx_above = 0;
		j = parent.n - 1;
		k = _dim + 1;
		simplex = _simplex;
		vertices.resize(_dim + 1);
		parent.get_simplex_vertices(get_index(_simplex), _dim, parent.n, vertices.rbegin());
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
movq 0x60(%rdi), %rax
movq 0x30(%rax), %rax
decq %rax
movq %rax, 0x10(%rdi)
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%rdi)
movss %xmm0, 0x38(%rdi)
movq %r14, 0x40(%rdi)
addq $0x20, %rdi
callq 0x8030
movq 0x28(%r15), %rax
movq 0x60(%r15), %rsi
movq 0x30(%rsi), %r8
leaq 0x8(%rsp), %r9
movq %rax, (%r9)
movq %rsp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3e3c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ripser[P]ripser/ripser.cpp
// Function: ripser<compressed_distance_matrix<(compressed_matrix_layout)0>>::simplex_coboundary_enumerator::next()
diameter_entry_t next() {
		while ((binomial_coeff(j, k) <= idx_below)) {
			idx_below -= binomial_coeff(j, k);
			idx_above += binomial_coeff(j, k + 1);
			--j;
			--k;
			assert(k != -1);
		}
		value_t cofacet_diameter = get_diameter(simplex);
		for (index_t i : vertices) cofacet_diameter = std::max(cofacet_diameter, dist(j, i));
		index_t cofacet_index = idx_above + binomial_coeff(j--, k + 1) + idx_below;
		coefficient_t cofacet_coefficient =
		    (k & 1 ? modulus - 1 : 1) * get_coefficient(simplex) % modulus;
		return diameter_entry_t(cofacet_diameter, cofacet_index, cofacet_coefficient);
	}

// Assembly:
pushq %r14
pushq %rbx
movq 0x58(%rdi), %rax
movq (%rax), %rdx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
imulq $0x18, %r8, %r9
addq %r9, %rdx
addq $0x18, %rdx
decq %r8
movq %rsi, %r9
movq -0x18(%rdx), %r10
subq (%r10,%rcx,8), %r9
jl 0xa8cd
movq %r9, (%rdi)
movq (%rdx), %rsi
addq (%rsi,%rcx,8), %rax
movq %rax, 0x8(%rdi)
decq %rcx
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
addq $-0x18, %rdx
decq %r8
movq %r9, %rsi
jmp 0xa89e
movss 0x38(%rdi), %xmm0
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %r9
movq 0x50(%rdi), %r10
cmpq %r9, %r8
je 0xa914
movq (%r8), %r11
xorps %xmm1, %xmm1
cmpq %rcx, %r11
je 0xa907
movq 0x18(%r10), %rbx
movq %r11, %r14
cmovlq %rcx, %r14
cmovgq %rcx, %r11
movq (%rbx,%r14,8), %rbx
movss (%rbx,%r11,4), %xmm1
maxss %xmm0, %xmm1
addq $0x8, %r8
movaps %xmm1, %xmm0
jmp 0xa8de
leaq -0x1(%rcx), %r8
movq %r8, 0x10(%rdi)
movq (%rdx), %rdx
addq %rsi, %rax
addq (%rdx,%rcx,8), %rax
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/expansion.cc
// Function: f(int, int, int, int)
void f(int i, int j = 0, int k = 0, int l = 0)
{
	cout << i << " + "
	     << j << " + "
	     << k << " + "
	     << l << " =  "
	     << i + j + k + l << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebx
movl %esi, %r15d
movl %edi, %r12d
movq 0x2de1(%rip), %rdi      # 0x3fd8
movl %r12d, %esi
callq 0x1080
leaq 0xdfe(%rip), %r13       # 0x2004
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
movq %rax, %rdi
movl %r15d, %esi
callq 0x1080
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
movq %rax, %rdi
movl %ebx, %esi
callq 0x1080
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
movq %rax, %rdi
movl %r14d, %esi
callq 0x1080
leaq 0xdba(%rip), %rsi       # 0x2008
movq %rax, %rdi
callq 0x1060
addl %r12d, %r15d
addl %r14d, %ebx
addl %r15d, %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x1080
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/expansion.cc
// Function: void g<int, int, int, int>(int, int, int, int)
void g(Args ... args)
{
	cout << sizeof...(Args) << endl;  // number of type parameters
	cout << sizeof...(args) << endl;  // number of function parameters
	// call f passing it the arguments from args
	f(args...);                // f(a1, a2, a3, ..., an)

	// call h passing it the arguments from args
	cout << h(args...) << endl; // h(a1, a2, a3, ..., an)

	// the pattern is h(x),
	// the expansion calls h on each argument in args
	f(h(args) ...);            // f(h(a1), h(a2), h(a3), ..., h(an))

	// args is expanded in the call to h
	f(h(args ...));            // f(h(a1, a2, a3, ..., an2)

	// pattern adds the argument value to result from calling h(5,6,7,8)
	f(h(5,6,7,8 ) + args ...); // f(h(5,6,7,8) + a1, h(5,6,7,8) + a2,
	                           //   h(5,6,7,8) + a3, ..., h(5,6,7,8) + an)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
movq 0x2d09(%rip), %r13      # 0x3fd8
pushq $0x4
popq %rsi
movq %r13, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1030
movq %r13, %rdi
pushq $0x4
popq %rsi
callq 0x1040
movq %rax, %rdi
callq 0x1030
movl %r12d, %edi
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x11d7
leal 0x2a(%r12), %eax
movl %eax, -0x2c(%rbp)
leal (%r12,%r15), %r13d
addl $0x2a, %r13d
addl %r14d, %r13d
addl %ebx, %r13d
movq 0x2cb6(%rip), %rdi      # 0x3fd8
movl %r13d, %esi
callq 0x1080
movq %rax, %rdi
callq 0x1030
leal 0x2a(%r15), %esi
leal 0x2a(%r14), %edx
leal 0x2a(%rbx), %ecx
movl -0x2c(%rbp), %edi
callq 0x11d7
movl %r13d, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x11d7
addl $0x44, %r12d
addl $0x44, %r15d
addl $0x44, %r14d
addl $0x44, %ebx
movl %r12d, %edi
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11d7
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/config.hpp
// Function: ConfigData::configure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ConfigData::configure(string filename)
{
  // try to open
  FILE *fin = fopen(filename.c_str(),"r");
  if(fin == NULL) 
  {
    printf("config file not found\n"); 
    exit(0);
  }
  // check for [main]
  char next[200];
  if(fscanf(fin,"%[^\n]\n",next) == 0)
  {
    printf("config file appears empty\n");
    exit(0);
  }
  if(string(next) != "[main]")
  {
    printf("no [main] in config file\n"); 
    exit(0);
  }
  // update for the rest of the lines
  while(fscanf(fin,"%[^\n]\n",next) != EOF)
    use(string(next));
  fclose(fin);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x33ea6(%rip), %rsi     # 0x4319c
callq 0xe650
testq %rax, %rax
je 0xf3c2
movq %rax, %r14
leaq 0x31377(%rip), %rsi     # 0x40685
leaq 0x50(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0xea50
testl %eax, %eax
je 0xf3cb
leaq 0x30(%rsp), %r15
leaq 0x50(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1866e
leaq 0x31349(%rip), %rsi     # 0x4068c
movq %r15, %rdi
callq 0x186d2
movl %eax, %ebp
movq %r15, %rdi
callq 0xe290
testb %bpl, %bpl
jne 0xf3d4
leaq 0x31324(%rip), %r15     # 0x40685
leaq 0x50(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xea50
cmpl $-0x1, %eax
je 0xf3a8
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1866e
movq %rbx, %rdi
movq %r13, %rsi
callq 0xecec
movq %r13, %rdi
callq 0xe290
jmp 0xf370
movq %r14, %rdi
callq 0xe550
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49662(%rip), %rdi     # 0x58a2b
jmp 0xf3db
leaq 0x4963f(%rip), %rdi     # 0x58a11
jmp 0xf3db
leaq 0x4961d(%rip), %rdi     # 0x589f8
callq 0xe8d0
xorl %edi, %edi
callq 0xe6a0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/config.hpp
// Function: ConfigData::print()
void ConfigData::print()
{
  printf("Ggraph: %s\nHgraph: %s\nGsigs: %s\nHsigs: %s\nSeqScores: %s\n"
          "nneighbors: %d\nsearchiter: %d\nbeta: %lf\nratio: %lf\n", 
          Ggraph.c_str(), 
          Hgraph.c_str(), 
          Gsigs.c_str(), 
          Hsigs.c_str(), 
          SeqScores.c_str(), 
          nneighbors,
          searchiter, 
          beta, 
          ratio);
}

// Assembly:
pushq %rax
movq (%rdi), %rsi
movq 0x20(%rdi), %rdx
movq 0x40(%rdi), %rcx
movq 0x60(%rdi), %r8
movq 0x80(%rdi), %r9
movl 0x108(%rdi), %r10d
movl 0x10c(%rdi), %r11d
movsd 0x118(%rdi), %xmm0
movsd 0x120(%rdi), %xmm1
leaq 0x3125b(%rip), %rdi     # 0x40693
movb $0x2, %al
pushq %r11
pushq %r10
callq 0xe060
popq %rcx
popq %rdx
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/graph.hpp
// Function: Graph::nodes[abi:cxx11]()
vector<string> Graph::nodes()
{
  adjacencyMap::iterator iter = m.begin(),
  iend = m.end();
  vector<string> result;
  for(; iter != iend; ++iter)
    result.push_back(iter->first);
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x186dc
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
testq %r14, %r14
je 0xf47b
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x186ec
movq (%r14), %r14
jmp 0xf465
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x18718
movq %r14, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/graph.hpp
// Function: Graph::print()
void Graph::print()
{
  adjacencyMap::iterator iter = m.begin(),
  iend = m.end();
  for(; iter != iend; ++iter)
  {
    std::cout << iter->first << ": [";
    vlist::iterator vit = (iter->second).begin(),
    vend = (iter->second).end();
    if(vit == vend)
      std::cout << "]\n";
    else
    {
      vlist::iterator vtemp = (iter->second).begin();
      vtemp++;
      for(; vtemp != vend; vit++, vtemp++)
        std::cout << (*vit) << ", ";
      std::cout << (*vit) << "]\n";
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x186dc
movq %rax, %rbx
movq 0x6dae4(%rip), %r14     # 0x7cf98
leaq 0x311ce(%rip), %r12     # 0x40689
leaq 0x31550(%rip), %r13     # 0x40a12
testq %rbx, %rbx
je 0xf539
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xe4a0
movq %rax, %rdi
leaq 0x31222(%rip), %rsi     # 0x406ff
callq 0xe540
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x1873a
movq %rax, %rbp
movq %r14, %rax
testq %rbp, %rbp
je 0xf529
movq %r15, %rdi
callq 0x1873a
movq %rax, %r15
movq (%r15), %r15
leaq 0x10(%rbp), %rsi
movq %r14, %rdi
callq 0xe4a0
testq %r15, %r15
je 0xf529
movq %rax, %rdi
movq %r13, %rsi
callq 0xe540
movq (%rbp), %rbp
jmp 0xf504
movq %rax, %rdi
movq %r12, %rsi
callq 0xe540
movq (%rbx), %rbx
jmp 0xf4c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/readFromGexf.hpp
// Function: nextTag[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>*)
string nextTag(ifstream *fin)
{
  string result = "";
  char c = (*fin).get();
  while(c!='<')
  {
    if((*fin).good())
      c=(*fin).get();
    else
      return "<EOF>"; // otherwise impossible return value
  }
  while(c!='>')
  {
    c = (*fin).get();
    result += c;
  }
  result=result.substr(0,result.size()-1);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x31369(%rip), %rsi     # 0x408c8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1866e
movq %r14, %rdi
callq 0xe680
movl %eax, %ebp
cmpb $0x3c, %bpl
je 0xf59d
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0xf617
movq %r14, %rdi
callq 0xe680
movl %eax, %ebp
jmp 0xf578
leaq 0x8(%rsp), %r15
cmpb $0x3e, %bpl
je 0xf5c0
movq %r14, %rdi
callq 0xe680
movl %eax, %ebp
movsbl %bpl, %esi
movq %r15, %rdi
callq 0xe460
jmp 0xf5a2
leaq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rcx
decq %rcx
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0xe5b0
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xe6b0
movq %r15, %rdi
callq 0xe290
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0xf62d
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xf633
leaq 0x310e5(%rip), %rsi     # 0x40703
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1866e
jmp 0xf64c
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xe290
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf66c
jmp 0xf66c
jmp 0xf66c
jmp 0xf66c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/readFromGexf.hpp
// Function: getAttribute[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>*)
string getAttribute(ifstream *fin)
{
  string cur = nextTag(fin);
  while(cur.substr(0,10) != "attributes")
  {
    cur = nextTag(fin);
    if(cur == "<EOF>") {cout << "read attribute error\n"; break;}
  }
  while(cur != "/attributes")
  {
    cur = nextTag(fin);
    if(cur == "<EOF>") {cout << "read attribute error\n"; break;}
    string title = extract(cur,"title");
    if(title != "<EOS>")
      return title;
  }
  return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf548
leaq 0x28(%rsp), %r12
leaq 0x30e4f(%rip), %rbp     # 0x40728
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
pushq $0xa
popq %rcx
callq 0xe5b0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x186d2
movl %eax, %r13d
movq %r12, %rdi
callq 0xe290
testb %r13b, %r13b
je 0xf948
movq %r12, %rdi
movq %r14, %rsi
callq 0xf548
movq %r15, %rdi
movq %r12, %rsi
callq 0xe6b0
movq %r12, %rdi
callq 0xe290
movq %r15, %rdi
leaq 0x30dd7(%rip), %rsi     # 0x40703
callq 0x18661
testb %al, %al
je 0xf8d9
movq 0x6d65c(%rip), %rdi     # 0x7cf98
leaq 0x30dce(%rip), %rsi     # 0x40711
callq 0xe540
leaq 0x30dd8(%rip), %rsi     # 0x40727
leaq 0x8(%rsp), %rdi
callq 0x186d2
testb %al, %al
je 0xfa1c
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xf548
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe6b0
movq %r12, %rdi
callq 0xe290
leaq 0x30d71(%rip), %rsi     # 0x40703
movq %r15, %rdi
callq 0x18661
testb %al, %al
jne 0xfa09
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe7a0
leaq 0x30d7f(%rip), %rsi     # 0x40733
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1866e
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0xf681
leaq 0x48(%rsp), %rdi
callq 0xe290
leaq 0x68(%rsp), %rdi
callq 0xe290
leaq 0x30d1b(%rip), %rsi     # 0x4070b
movq %rbx, %rdi
callq 0x186d2
testb %al, %al
jne 0xfa30
movq %rbx, %rdi
callq 0xe290
jmp 0xf948
movq 0x6d588(%rip), %rdi     # 0x7cf98
leaq 0x30cfa(%rip), %rsi     # 0x40711
callq 0xe540
leaq 0x30ea5(%rip), %rsi     # 0x408c8
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1866e
leaq 0x8(%rsp), %rdi
callq 0xe290
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfa77
jmp 0xfa77
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xe290
jmp 0xfa65
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xe290
jmp 0xfa7a
jmp 0xfa77
jmp 0xfa77
jmp 0xfa77
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe290
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/sigApprox.hpp
// Function: rayleigh(Eigen::Matrix<double, -1, -1, 0, -1, -1>*)
double rayleigh(MatrixXd *A)
{
  int N=(*A).rows();
  double prev=200, cur;
  bool flag=false;
  VectorXd seed = randomVec(N);
  for(int i=0;i<1000;i++)
  {
    VectorXd mu = seed.transpose()*(*A)*seed;
    cur=mu[0];
    for(int i=0;i<N;i++)
      (*A)(i,i) -= cur;
    seed = (*A).ldlt().solve(seed);
    seed.normalize();
    for(int i=0;i<N;i++)
      (*A)(i,i) += cur;
    if(fabs(cur-prev) < ZERO) {flag=true; break;}
    prev=cur;
  }
//  if(!flag) cout << "warning: did not converge\n"; // uncomment for warning
  return cur;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x10980
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movsd 0x2f3e9(%rip), %xmm0    # 0x40060
movsd %xmm0, 0x10(%rsp)
leaq 0x68(%rsp), %r12
cmpl $0x3e8, %eax            # imm = 0x3E8
je 0x10dce
movq %rax, 0x28(%rsp)
movq %r15, 0x40(%rsp)
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x27ba4
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r12, %rbp
movq %r12, %rsi
movq %r15, %r12
movq %r15, %rdx
callq 0x27be2
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x18c72
movq 0x78(%rsp), %rdi
callq 0xe670
movq %r15, %rdi
xorl %esi, %esi
callq 0x18cb6
movq %r12, %r15
movq %rbp, %r12
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x10d1d
movq %rbx, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x18b38
movsd (%rax), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
jmp 0x10cf7
movq %r12, %rdi
movq %rbx, %rsi
callq 0x23c34
movq %r12, %rdi
movq %r15, %rsi
callq 0x18bc4
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
callq 0x25dfa
movq %r12, %rdi
callq 0x18c52
movq %r15, %rdi
callq 0x18af8
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x10d83
movq %rbx, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x18b38
movsd (%rax), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
jmp 0x10d5d
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
andpd 0x2f399(%rip), %xmm0    # 0x40130
movapd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0xe670
movq 0x28(%rsp), %rax
incl %eax
movsd 0x2f2b2(%rip), %xmm0    # 0x40068
ucomisd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jbe 0x10c82
movq 0x58(%rsp), %rdi
callq 0xe670
movsd 0x8(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10e14
movq %rax, %rbx
jmp 0x10e21
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x18c52
jmp 0x10e17
jmp 0x10e14
movq %rax, %rbx
movq 0x78(%rsp), %rdi
jmp 0x10e1c
jmp 0x10e14
movq %rax, %rbx
movq 0x48(%rsp), %rdi
callq 0xe670
movq 0x58(%rsp), %rdi
callq 0xe670
movq %rbx, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/laplacian.hpp
// Function: AdjacencyMatrix::getEigen()
vector<double> AdjacencyMatrix::getEigen()
{
  vector<double> v;
  if(nodes.size() == 0)
    return v;
  SelfAdjointEigenSolver<MatrixXd> es(m, EigenvaluesOnly);
  VectorXd evals = es.eigenvalues();
  for(int i=0; i<evals.rows(); i++)
    v.push_back(evals(i));
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x28(%rsi)
je 0x112cd
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rdx
callq 0x18e34
leaq 0x10(%rsp), %rdi
callq 0x18ede
movq %rsp, %rdi
movq %rax, %rsi
callq 0x18b82
xorl %r14d, %r14d
movq %rsp, %r15
cmpq %r14, 0x8(%rsp)
jle 0x112ba
movq %r15, %rdi
movq %r14, %rsi
callq 0x18c1c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18f0c
incq %r14
jmp 0x11298
movq (%rsp), %rdi
callq 0xe670
leaq 0x10(%rsp), %rdi
callq 0x18f2e
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x112f0
movq %rax, %r14
jmp 0x112fa
movq %rax, %r14
movq (%rsp), %rdi
callq 0xe670
leaq 0x10(%rsp), %rdi
callq 0x18f2e
movq %rbx, %rdi
callq 0x29310
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/laplacian.hpp
// Function: AdjacencyMatrix::rayleighEigen()
vector<double> AdjacencyMatrix::rayleighEigen()
{
  vector<double> result;
//  int tries = m.rows()/2;
//  if(tries<1) tries=1;
  int tries = 10;
  for(int i=0;i<tries;i++)
  {
    double d = rayleigh(&m);
    bool found=false;
    for(int i=0;i<result.size();i++)
      if(fabs(d-result[i])<ZERO)
        found=true;
    if(!found) result.push_back(d);
  }
  if(result.size()==0) cout << "whut?\n";
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %ebp, %ebp
movq %rsp, %r15
cmpl $0xa, %ebp
je 0x11390
movq %r14, %rdi
callq 0x10c3e
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x1137b
movapd %xmm0, %xmm1
subsd (%rax,%rdx,8), %xmm1
andpd 0x2edcd(%rip), %xmm1    # 0x40130
movsd 0x2ecfd(%rip), %xmm2    # 0x40068
ucomisd %xmm1, %xmm2
seta %dil
orb %dil, %sil
incq %rdx
jmp 0x1134d
testb $0x1, %sil
jne 0x1138c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18f0c
incl %ebp
jmp 0x11329
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0x113ac
movq 0x6bbf8(%rip), %rdi     # 0x7cf98
leaq 0x2f476(%rip), %rsi     # 0x4081d
callq 0xe540
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x113be
jmp 0x113be
movq %rax, %r14
movq %rbx, %rdi
callq 0x29310
movq %r14, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/laplacian.hpp
// Function: AdjacencyMatrix::inverseEigen()
vector<double> AdjacencyMatrix::inverseEigen()
{
  vector<double> result;
  int tries = 2;
  double mu = 1.0/(tries+1);
  for(int i=1;i<=tries;i++)
  {
    double d = inverseIter(&m, 2*mu*i);
    bool found=false;
    for(int i=0;i<result.size();i++)
      if(fabs(d-result[i])<ZERO)
        found=true;
    if(!found) result.push_back(d);
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0x1
popq %rbp
movq %rsp, %r15
cmpl $0x3, %ebp
je 0x11465
cvtsi2sd %ebp, %xmm0
mulsd 0x2ec85(%rip), %xmm0    # 0x40088
movq %r14, %rdi
callq 0x109f2
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x11450
movapd %xmm0, %xmm1
subsd (%rax,%rdx,8), %xmm1
andpd 0x2ecf8(%rip), %xmm1    # 0x40130
movsd 0x2ec28(%rip), %xmm2    # 0x40068
ucomisd %xmm1, %xmm2
seta %dil
orb %dil, %sil
incq %rdx
jmp 0x11422
testb $0x1, %sil
jne 0x11461
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18f0c
incl %ebp
jmp 0x113f2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11475
movq %rax, %r14
movq %rbx, %rdi
callq 0x29310
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzWriter.hpp
// Function: GzWriter::writeString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void GzWriter::writeString(string s)
{
  int16_t i = (int16_t)(s.size());
  swap_endian(i);
  out.write(reinterpret_cast<const char*>(&i),sizeof(i));
  out.write(reinterpret_cast<const char*>(&s[0]),s.size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x8(%rsi), %eax
leaq 0xe(%rsp), %r15
movw %ax, (%r15)
movq %r15, %rdi
callq 0x18f4d
addq $0x10, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe750
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xe750
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzWriter.hpp
// Function: GzWriter::writeData(boost::unordered::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<LevelData, std::allocator<LevelData>>, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<LevelData, std::allocator<LevelData>>>>>)
void GzWriter::writeData(levelMap levelmap)
{
  levelMap::iterator iter = levelmap.begin(),
  iend = levelmap.end();
  for(; iter != iend; iter++)
  {
    writeString(iter->first);
    for(int i=1;i<=(iter->second).size();i++)
    {
      writeInt(i);
      int sz = (iter->second)[i-1].vnames.size();
      writeInt(sz);
      for(int j=0;j<sz;j++)
        writeString((iter->second)[i-1].vnames[j]);
      sz = (iter->second)[i-1].spectrum.size();
      writeInt(sz);
      for(int j=0;j<sz;j++)
        writeDouble((iter->second)[i-1].spectrum[j]);
      writeDouble((iter->second)[i-1].density);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x18f56
movq %rax, %r15
leaq 0x8(%rsp), %r12
testq %r15, %r15
je 0x1161d
leaq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xe7a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11488
movq %rbx, %rdi
callq 0xe290
pushq $0x1
popq %rbx
movq 0x38(%r15), %rax
subq 0x30(%r15), %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jb 0x11615
movq %r14, %rdi
movl %ebx, %esi
callq 0x18f66
movq %rbx, (%rsp)
leaq -0x1(%rbx), %rax
movq 0x30(%r15), %rcx
imulq $0x38, %rax, %rbx
movq 0x8(%rcx,%rbx), %rbp
subq (%rcx,%rbx), %rbp
shrq $0x5, %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x18f66
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
shlq $0x5, %rbp
xorl %r13d, %r13d
movq 0x30(%r15), %rax
cmpq %r13, %rbp
je 0x115b5
movq (%rax,%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xe7a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x11488
movq %r12, %rdi
callq 0xe290
addq $0x20, %r13
jmp 0x11584
movq 0x20(%rax,%rbx), %rbp
subq 0x18(%rax,%rbx), %rbp
shrq $0x3, %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x18f66
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
xorl %r13d, %r13d
movq 0x30(%r15), %rax
cmpq %r13, %rbp
je 0x115fb
movq 0x18(%rax,%rbx), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x18f98
incq %r13
jmp 0x115da
movsd 0x30(%rax,%rbx), %xmm0
movq %r14, %rdi
callq 0x18f98
movq (%rsp), %rbx
incq %rbx
jmp 0x11529
movq (%r15), %r15
jmp 0x114f9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
jmp 0x1163a
movq %rax, %r14
movq %r12, %rdi
callq 0xe290
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/computeSpectralSignatures.hpp
// Function: spectrum(Graph*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<LevelData, std::allocator<LevelData>>*, ProgressBar*)
void spectrum(Graph *input, int numHops, string source, 
              vector<LevelData> *output, ProgressBar *p)
{
  AdjacencyMatrix m;
  for(int i=1;i<=numHops;i++)
  {
    m.extend(input, source);
    (*output).push_back(LevelData(m.getPrev(), m.getEigen(), m.getDensity()));
  }
  (*p).update();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, %ebx
movq %rdi, 0x18(%rsp)
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
callq 0x18fca
xorl %r12d, %r12d
testl %ebx, %ebx
cmovgl %ebx, %r12d
leaq 0x58(%rsp), %rbx
leaq 0x40(%rsp), %rbp
leaq 0x28(%rsp), %r14
leaq 0x78(%rsp), %r15
subl $0x1, %r12d
jb 0x11732
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0xe7a0
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x10e34
movq %rbx, %rdi
callq 0xe290
movq %rbp, %rdi
leaq 0x158(%rsp), %rsi
callq 0x197e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x11252
cvtdq2pd 0x170(%rsp), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1904c
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2ee0c
movq %r15, %rdi
callq 0x19092
movq %r14, %rdi
callq 0x29310
movq %rbp, %rdi
callq 0x18718
jmp 0x1169b
movq 0x8(%rsp), %rdi
callq 0x107b0
leaq 0xb0(%rsp), %rdi
callq 0x190a8
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1178c
jmp 0x1178c
movq %rax, %rbx
jmp 0x11780
movq %rax, %rbx
jmp 0x11776
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x19092
leaq 0x28(%rsp), %rdi
callq 0x29310
leaq 0x40(%rsp), %rdi
callq 0x18718
jmp 0x1179e
movq %rax, %rbx
jmp 0x1179e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xe290
leaq 0xb0(%rsp), %rdi
callq 0x190a8
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/computeSpectralSignatures.hpp
// Function: spectrumR(Graph*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<LevelData, std::allocator<LevelData>>*, ProgressBar*)
void spectrumR(Graph *input, int numHops, string source, 
              vector<LevelData> *output, ProgressBar *p)
{
  AdjacencyMatrix m;
  for(int i=1;i<=numHops;i++)
  {
    m.extend(input, source);
    (*output).push_back(LevelData(m.getPrev(), m.rayleighEigen(), 
                                  m.getDensity()));
  }
  (*p).update();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, %ebx
movq %rdi, 0x18(%rsp)
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
callq 0x18fca
xorl %r12d, %r12d
testl %ebx, %ebx
cmovgl %ebx, %r12d
leaq 0x58(%rsp), %rbx
leaq 0x40(%rsp), %rbp
leaq 0x28(%rsp), %r14
leaq 0x78(%rsp), %r15
subl $0x1, %r12d
jb 0x1189e
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0xe7a0
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x10e34
movq %rbx, %rdi
callq 0xe290
movq %rbp, %rdi
leaq 0x158(%rsp), %rsi
callq 0x197e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1130a
cvtdq2pd 0x170(%rsp), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1904c
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2ee0c
movq %r15, %rdi
callq 0x19092
movq %r14, %rdi
callq 0x29310
movq %rbp, %rdi
callq 0x18718
jmp 0x11807
movq 0x8(%rsp), %rdi
callq 0x107b0
leaq 0xb0(%rsp), %rdi
callq 0x190a8
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x118f8
jmp 0x118f8
movq %rax, %rbx
jmp 0x118ec
movq %rax, %rbx
jmp 0x118e2
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x19092
leaq 0x28(%rsp), %rdi
callq 0x29310
leaq 0x40(%rsp), %rdi
callq 0x18718
jmp 0x1190a
movq %rax, %rbx
jmp 0x1190a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xe290
leaq 0xb0(%rsp), %rdi
callq 0x190a8
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/computeSpectralSignatures.hpp
// Function: spectrumI(Graph*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<LevelData, std::allocator<LevelData>>*, ProgressBar*)
void spectrumI(Graph *input, int numHops, string source, 
              vector<LevelData> *output, ProgressBar *p)
{
  AdjacencyMatrix m;
  for(int i=1;i<=numHops;i++)
  {
    m.extend(input, source);
    (*output).push_back(LevelData(m.getPrev(), m.inverseEigen(), 
                                  m.getDensity()));
  }
  (*p).update();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, %ebx
movq %rdi, 0x18(%rsp)
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
callq 0x18fca
xorl %r12d, %r12d
testl %ebx, %ebx
cmovgl %ebx, %r12d
leaq 0x58(%rsp), %rbx
leaq 0x40(%rsp), %rbp
leaq 0x28(%rsp), %r14
leaq 0x78(%rsp), %r15
subl $0x1, %r12d
jb 0x11a0a
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0xe7a0
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x10e34
movq %rbx, %rdi
callq 0xe290
movq %rbp, %rdi
leaq 0x158(%rsp), %rsi
callq 0x197e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x113d2
cvtdq2pd 0x170(%rsp), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1904c
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2ee0c
movq %r15, %rdi
callq 0x19092
movq %r14, %rdi
callq 0x29310
movq %rbp, %rdi
callq 0x18718
jmp 0x11973
movq 0x8(%rsp), %rdi
callq 0x107b0
leaq 0xb0(%rsp), %rdi
callq 0x190a8
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11a64
jmp 0x11a64
movq %rax, %rbx
jmp 0x11a58
movq %rax, %rbx
jmp 0x11a4e
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x19092
leaq 0x28(%rsp), %rdi
callq 0x29310
leaq 0x40(%rsp), %rdi
callq 0x18718
jmp 0x11a76
movq %rax, %rbx
jmp 0x11a76
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xe290
leaq 0xb0(%rsp), %rdi
callq 0x190a8
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/blastDistance.hpp
// Function: getBlastMap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
blastMap getBlastMap(string filename)
{
  blastMap bevals;
  ifstream fin (filename);
  if(!fin.good()) {std::cout << "sequencescores file is bad\n"; exit(0);}
  while(1)
  {
    string n1,n2;
    double d;
    fin >> n1 >> n2 >> d;
    if(fin.eof()) break;
    bevals[make_pair(n1,n2)] = d;
  }
  fin.close();
  return bevals;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
callq 0x19658
leaq 0xa0(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0xe950
movq 0xa0(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0xc0(%rsp,%rax)
jne 0x1230e
xorl %ebx, %ebx
leaq 0xa0(%rsp), %r14
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x60(%rsp), %rbp
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
andq $0x0, 0x48(%rsp)
movb %bl, 0x50(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb %bl, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe710
movq %rax, %rdi
movq %r12, %rsi
callq 0xe710
movq %rax, %rdi
movq %r13, %rsi
callq 0xe390
movq 0xa0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0xc0(%rsp,%rax)
jne 0x122c9
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21726
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x33e70
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x50(%rax)
movq %rbp, %rdi
callq 0x19672
movq %r12, %rdi
callq 0xe290
movq %r15, %rdi
callq 0xe290
jmp 0x1221b
leaq 0x20(%rsp), %rdi
callq 0xe290
leaq 0x40(%rsp), %rdi
callq 0xe290
leaq 0xa0(%rsp), %rdi
callq 0xe140
leaq 0xa0(%rsp), %rdi
callq 0xe170
movq 0x8(%rsp), %rax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6ac83(%rip), %rdi     # 0x7cf98
leaq 0x2e583(%rip), %rsi     # 0x4089f
callq 0xe540
xorl %edi, %edi
callq 0xe6a0
movq %rax, %r14
jmp 0x12367
movq %rax, %r14
jmp 0x1235a
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x19672
jmp 0x12346
jmp 0x12343
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe290
leaq 0x40(%rsp), %rdi
callq 0xe290
leaq 0xa0(%rsp), %rdi
callq 0xe170
movq 0x8(%rsp), %rdi
callq 0x33d9c
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: readInt(std::istream&)
int readInt(istream& in)
{
  int num = sizeof(int32_t)/sizeof(char);
  char* s = new char [num];
  in.read(s, num);
  int32_t d = *((int32_t*)s);
  swap_endian(d);
  delete[] s;
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x4
popq %r14
movq %r14, %rdi
callq 0xe040
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xe700
movl (%r15), %eax
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x19688
movq %r15, %rdi
callq 0xe720
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: readDouble(std::istream&)
double readDouble(istream& in)
{
  int num = sizeof(int64_t)/sizeof(char);
  char* s = new char [num];
  in.read(s, num);
  int64_t d = *((int64_t*)s);
  swap_endian(d);
  double ans = *((double*)&d);
  delete[] s;
  return ans;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0xe040
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xe700
movq (%r15), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x19691
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0xe720
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: readString[abi:cxx11](std::istream&)
string readString(istream& in)
{
  int num = sizeof(int16_t)/sizeof(char);
  char* s = new char [num];
  in.read(s, num);
  int16_t d = *((int16_t*)s);
  swap_endian(d);
  delete[] s;
  s = new char [d+1];
  in.read(s, d);
  s[d]='\0';
  string ss = string(s);
  delete[] s;
  return ss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %r15
movq %r15, %rdi
callq 0xe040
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe700
movzwl (%r12), %eax
leaq 0xe(%rsp), %r15
movw %ax, (%r15)
movq %r15, %rdi
callq 0x18f4d
movq %r12, %rdi
callq 0xe720
movswq (%r15), %r12
leaq 0x1(%r12), %rdi
callq 0xe040
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xe700
movswq (%r15), %rax
movb $0x0, (%r13,%rax)
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1866e
movq %r13, %rdi
callq 0xe720
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: gaussianDensity(double*, int, double, double, double)
double gaussianDensity(double* spec, int s, double omega, double sigsq, double norm)
{
  double d = 1e-30;
  for(int i=0; i<s; i++) 
    d += norm * fastpow2(1.442695040f * -((omega - spec[i]) * (omega - spec[i])) / sigsq);
  return d;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movsd 0x2dbbd(%rip), %xmm3    # 0x40090
xorps %xmm5, %xmm5
movss 0x2dce2(%rip), %xmm6    # 0x401c0
movss 0x2dcde(%rip), %xmm4    # 0x401c4
movss 0x2dcd9(%rip), %xmm8    # 0x401c8
movss 0x2dcd4(%rip), %xmm9    # 0x401cc
movss 0x2dccf(%rip), %xmm10   # 0x401d0
movss 0x2dcca(%rip), %xmm11   # 0x401d4
movss 0x2dcc5(%rip), %xmm12   # 0x401d8
cmpq %rax, %rsi
je 0x125b0
movapd %xmm0, %xmm13
subsd (%rdi,%rax,8), %xmm13
mulsd %xmm13, %xmm13
mulsd 0x2db63(%rip), %xmm13   # 0x40098
divsd %xmm1, %xmm13
cvtsd2ss %xmm13, %xmm13
movaps %xmm4, %xmm7
maxss %xmm13, %xmm7
cmpltss %xmm5, %xmm13
andps %xmm6, %xmm13
cvttps2dq %xmm7, %xmm15
cvtdq2ps %xmm15, %xmm15
movaps %xmm7, %xmm14
subss %xmm15, %xmm14
addss %xmm13, %xmm14
movaps %xmm9, %xmm13
subss %xmm14, %xmm13
movaps %xmm10, %xmm15
divss %xmm13, %xmm15
addss %xmm8, %xmm7
addss %xmm7, %xmm15
mulss %xmm11, %xmm14
addss %xmm15, %xmm14
mulss %xmm12, %xmm14
cvttss2si %xmm14, %rcx
movd %ecx, %xmm7
cvtss2sd %xmm7, %xmm7
mulsd %xmm2, %xmm7
addsd %xmm7, %xmm3
incq %rax
jmp 0x12513
movapd %xmm3, %xmm0
retq