LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ripser[P]ripser/ripser.cpp
// Function: ripser<sparse_distance_matrix>::compute_diameter(long, long) const
value_t compute_diameter(const index_t index, const index_t dim) const {
		value_t diam = -std::numeric_limits<value_t>::infinity();

		vertices.resize(dim + 1);
		get_simplex_vertices(index, dim, dist.size(), vertices.rbegin());

		for (index_t i = 0; i <= dim; ++i)
			for (index_t j = 0; j < i; ++j) {
				diam = std::max(diam, dist(vertices[i], vertices[j]));
			}
		return diam;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x75c0
movq 0x10(%rsp), %rdi
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x5c(%rsp)
addq $0x88, %rdi
movq 0x60(%rsp), %rsi
addq $0x1, %rsi
callq 0x164d0
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x7090
movq 0x10(%rsp), %rsi
movq %rax, 0x28(%rsp)
addq $0x88, %rsi
leaq 0x50(%rsp), %rdi
callq 0x5e90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0x48(%rsp), %rdi
leaq 0x50(%rsp), %r9
callq 0x12670
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x60(%rsp), %rax
jg 0x17d56
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
jge 0x17d41
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movq 0x40(%rsp), %rsi
callq 0x5ee0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
movq 0x38(%rsp), %rsi
callq 0x5ee0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rax), %rdx
callq 0x17d70
movss %xmm0, 0x34(%rsp)
leaq 0x5c(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x75d0
movss (%rax), %xmm0
movss %xmm0, 0x5c(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x17cbd
jmp 0x17d43
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x17ca4
movss 0x5c(%rsp), %xmm0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Ripser[P]ripser/ripser.cpp
// Function: sparse_distance_matrix::operator()(long, long) const
value_t operator()(const index_t i, const index_t j) const {
		auto neighbor =
		    std::lower_bound(neighbors[i].begin(), neighbors[i].end(), index_diameter_t{j, 0});
		return (neighbor != neighbors[i].end() && get_index(*neighbor) == j)
		           ? get_diameter(*neighbor)
		           : std::numeric_limits<value_t>::infinity();
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x58(%rsp), %rsi
callq 0x6020
movq %rax, %rdi
callq 0x6040
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rsi
callq 0x6020
movq %rax, %rdi
callq 0x6070
movq %rax, 0x38(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x24(%rsp), %rdx
callq 0x17ed0
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x17e70
movq 0x10(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rsi
callq 0x6020
movq %rax, %rdi
callq 0x6070
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x60a0
testb $0x1, %al
jne 0x17e26
jmp 0x17e59
leaq 0x48(%rsp), %rdi
callq 0x60e0
movq %rax, %rdi
callq 0x2a30
cmpq 0x50(%rsp), %rax
jne 0x17e59
leaq 0x48(%rsp), %rdi
callq 0x60e0
movq %rax, %rdi
callq 0x2a40
movss %xmm0, 0xc(%rsp)
jmp 0x17e64
callq 0x75c0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0x88, %rsp
movss %xmm0, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdx
movss 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rsi
callq 0x158d0
movss %xmm0, 0x48(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a70
cmpq $-0x1, %rax
je 0x197c4
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdx
subq $0x1, %rdx
movss 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rsi
callq 0x15770
movss %xmm0, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2a70
movq %rax, (%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2a70
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x197c4
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x197dc
movq $-0x1, 0x10(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x15a10
movss 0x78(%rsp), %xmm0
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movss %xmm0, 0x58(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
cmpb $0x0, 0x15c85(%rip)     # 0x2f4b8
jne 0x1987e
leaq 0x15c7c(%rip), %rdi     # 0x2f4b8
callq 0x23a0
cmpl $0x0, %eax
je 0x1987e
movq (%rsp), %rsi
leaq 0x15bc7(%rip), %rdi     # 0x2f418
callq 0x15a40
jmp 0x19858
leaq -0x3d2f(%rip), %rdi     # 0x15b30
leaq 0x15bb2(%rip), %rsi     # 0x2f418
leaq 0x159bb(%rip), %rdx     # 0x2f228
callq 0x2210
leaq 0x15c3f(%rip), %rdi     # 0x2f4b8
callq 0x2190
movq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1a590
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rdx
movss 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rsi
leaq 0x15b5d(%rip), %rdi     # 0x2f418
callq 0x15b70
leaq 0x15b51(%rip), %rdi     # 0x2f418
movl $0x1, %esi
callq 0x15d40
testb $0x1, %al
jne 0x198d7
jmp 0x1993c
leaq 0x15b3a(%rip), %rdi     # 0x2f418
callq 0x16070
movss %xmm0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2ab0
movq %rax, %rcx
movq (%rsp), %rax
movss (%rcx), %xmm1
movss 0x30(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x1993a
movq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a590
jmp 0x1993a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x15b85(%rip), %rdi     # 0x2f4b8
callq 0x2180
jmp 0x19941
jmp 0x198c0
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2380
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $-0x1, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x15a10
movq 0x28(%rsp), %rdi
callq 0x1c1a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x19a0b
jmp 0x19a8b
movq 0x28(%rsp), %rdi
callq 0x1c1c0
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x164a0
movq 0x28(%rsp), %rdi
callq 0x1c1d0
movq 0x28(%rsp), %rdi
callq 0x1c1a0
testb $0x1, %al
jne 0x19a66
movq 0x28(%rsp), %rdi
callq 0x1c1c0
movq %rax, %rdi
callq 0x2a70
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2a70
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x19a7c
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x19aa3
movq 0x28(%rsp), %rdi
callq 0x1c1d0
jmp 0x199f6
movq $-0x1, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15a10
movss 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movss %xmm0, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a70
movq (%rsp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x60(%rdi), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rdi)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rdi)
addq $0x38, %rdi
leaq 0x48(%rsp), %rsi
callq 0x164a0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
addq $0x1, %rsi
callq 0x164d0
movq (%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a70
movq (%rsp), %rsi
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsi), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x20, %rsi
leaq 0x30(%rsp), %rdi
callq 0x5e90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %r9
callq 0x5d60
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %esi
movq 0x2dda(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
leaq 0xdf7(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xddd(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdc3(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdad(%rip), %rsi       # 0x2008
callq 0x1050
movq %rax, %rdi
movl -0x4(%rbp), %esi
addl -0x8(%rbp), %esi
addl -0xc(%rbp), %esi
addl -0x10(%rbp), %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d4a(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq 0x2c7d(%rip), %rdi      # 0x3fd8
movl $0x4, %esi
callq 0x1030
movq %rax, %rdi
movq 0x2c59(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2c5d(%rip), %rdi      # 0x3fd8
movl $0x4, %esi
callq 0x1030
movq %rax, %rdi
movq 0x2c39(%rip), %rsi      # 0x3fc8
callq 0x1060
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x11e0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x1540
movl %eax, %esi
movq 0x2c19(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
movq 0x2bfa(%rip), %rsi      # 0x3fc8
callq 0x1060
movl -0x4(%rbp), %edi
callq 0x1580
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %edi
callq 0x1580
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %edi
callq 0x1580
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %edi
callq 0x1580
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
movl %eax, %ecx
callq 0x11e0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x1540
movl %eax, %edi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x11e0
movl $0x5, %edi
movl $0x6, %esi
movl $0x7, %edx
movl $0x8, %ecx
callq 0x1540
addl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x5, %edi
movl $0x6, %esi
movl $0x7, %edx
movl $0x8, %ecx
callq 0x1540
addl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x5, %edi
movl $0x6, %esi
movl $0x7, %edx
movl $0x8, %ecx
callq 0x1540
addl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x5, %edi
movl $0x6, %esi
movl $0x7, %edx
movl $0x8, %ecx
callq 0x1540
movl -0x1c(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movl %eax, %ecx
addl -0x10(%rbp), %ecx
callq 0x11e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rsi, -0x150(%rbp)
movq %rdi, %rax
movq -0x150(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
callq 0x102f0
movq %rax, %rdi
leaq 0xad1eb(%rip), %rsi     # 0xbf259
callq 0x10840
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12093
leaq 0xaa584(%rip), %rdi     # 0xbc609
movb $0x0, %al
callq 0x10080
xorl %edi, %edi
callq 0x10890
movq -0x18(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq 0xaa57b(%rip), %rsi     # 0xbc620
movb $0x0, %al
callq 0x10d50
cmpl $0x0, %eax
jne 0x120c6
leaq 0xaa56f(%rip), %rdi     # 0xbc627
movb $0x0, %al
callq 0x10080
xorl %edi, %edi
callq 0x10890
leaq -0x101(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x10ce0
movq -0x158(%rbp), %rdx
leaq -0x100(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x23400
jmp 0x120f5
leaq 0xaa546(%rip), %rsi     # 0xbc642
leaq -0x100(%rbp), %rdi
callq 0x23540
movb %al, -0x159(%rbp)
jmp 0x12110
leaq -0x100(%rbp), %rdi
callq 0x10460
leaq -0x101(%rbp), %rdi
callq 0x10770
movb -0x159(%rbp), %al
testb $0x1, %al
jne 0x12134
jmp 0x1218c
leaq 0xaa50e(%rip), %rdi     # 0xbc649
movb $0x0, %al
callq 0x10080
xorl %edi, %edi
callq 0x10890
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x1217b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x10460
leaq -0x101(%rbp), %rdi
callq 0x10770
jmp 0x12260
jmp 0x1218e
movq -0x18(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq 0xaa480(%rip), %rsi     # 0xbc620
movb $0x0, %al
callq 0x10d50
cmpl $-0x1, %eax
je 0x1224e
leaq -0x139(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x10ce0
movq -0x168(%rbp), %rdx
leaq -0x138(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x23400
jmp 0x121df
movq -0x148(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x110f0
jmp 0x121f4
leaq -0x138(%rbp), %rdi
callq 0x10460
leaq -0x139(%rbp), %rdi
callq 0x10770
jmp 0x1218e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x12240
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x10460
leaq -0x139(%rbp), %rdi
callq 0x10770
jmp 0x12260
movq -0x18(%rbp), %rdi
callq 0x106d0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x10cc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x102f0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x102f0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x102f0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x60, %rdi
callq 0x102f0
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x80, %rdi
callq 0x102f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movq %rax, %r9
movl 0x108(%rdi), %r10d
movl 0x10c(%rdi), %eax
movsd 0x118(%rdi), %xmm0
movsd 0x120(%rdi), %xmm1
leaq 0xaa358(%rip), %rdi     # 0xbc663
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x2, %al
callq 0x10080
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x23570
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x235b0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x235d0
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x235f0
testb $0x1, %al
jne 0x12379
jmp 0x123bd
leaq -0x18(%rbp), %rdi
callq 0x23690
movq %rax, -0x58(%rbp)
jmp 0x12388
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x23620
jmp 0x12397
jmp 0x12399
leaq -0x18(%rbp), %rdi
callq 0x236b0
jmp 0x123a4
jmp 0x12366
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x236d0
jmp 0x123da
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x123d0
movq -0x40(%rbp), %rdi
callq 0x236d0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23570
movq -0x50(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x235b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x235f0
testb $0x1, %al
jne 0x12430
jmp 0x1256d
leaq -0x10(%rbp), %rdi
callq 0x23690
movq %rax, %rsi
movq 0x11eb55(%rip), %rdi    # 0x130f98
callq 0x10600
movq %rax, %rdi
leaq 0xaa27d(%rip), %rsi     # 0xbc6cf
callq 0x106c0
leaq -0x10(%rbp), %rdi
callq 0x23690
movq %rax, %rdi
addq $0x20, %rdi
callq 0x23730
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x23690
movq %rax, %rdi
addq $0x20, %rdi
callq 0x23770
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23790
testb $0x1, %al
jne 0x1249c
jmp 0x124b4
movq 0x11eaf5(%rip), %rdi    # 0x130f98
leaq 0xaa17a(%rip), %rsi     # 0xbc624
callq 0x106c0
jmp 0x1255d
leaq -0x10(%rbp), %rdi
callq 0x23690
movq %rax, %rdi
addq $0x20, %rdi
callq 0x23730
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x237c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23800
testb $0x1, %al
jne 0x124ef
jmp 0x12536
leaq -0x20(%rbp), %rdi
callq 0x23830
movq %rax, %rsi
movq 0x11ea96(%rip), %rdi    # 0x130f98
callq 0x10600
movq %rax, %rdi
leaq 0xaa4c5(%rip), %rsi     # 0xbc9d6
callq 0x106c0
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x237c0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x237c0
movq %rax, -0x48(%rbp)
jmp 0x124dc
leaq -0x20(%rbp), %rdi
callq 0x23830
movq %rax, %rsi
movq 0x11ea4f(%rip), %rdi    # 0x130f98
callq 0x10600
movq %rax, %rdi
leaq 0xaa0cc(%rip), %rsi     # 0xbc624
callq 0x106c0
jmp 0x1255f
leaq -0x10(%rbp), %rdi
callq 0x236b0
jmp 0x1241a
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10ce0
movq -0x78(%rbp), %rdx
leaq 0xaa2d3(%rip), %rsi     # 0xbc88c
leaq -0x30(%rbp), %rdi
callq 0x23400
jmp 0x125c4
leaq -0x31(%rbp), %rdi
callq 0x10770
movq -0x10(%rbp), %rdi
callq 0x10870
movl %eax, -0x8c(%rbp)
jmp 0x125de
movl -0x8c(%rbp), %eax
movb %al, -0x45(%rbp)
movsbl -0x45(%rbp), %eax
cmpl $0x3c, %eax
je 0x126c5
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10c60
movb %al, -0x8d(%rbp)
jmp 0x1260f
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x1261b
jmp 0x12665
movq -0x10(%rbp), %rdi
callq 0x10870
movl %eax, -0x94(%rbp)
jmp 0x1262c
movl -0x94(%rbp), %eax
movb %al, -0x45(%rbp)
jmp 0x126c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x10770
jmp 0x12773
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1276a
leaq -0x46(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x10ce0
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq 0xaa049(%rip), %rsi     # 0xbc6d3
callq 0x23400
jmp 0x12691
leaq -0x46(%rbp), %rdi
callq 0x10770
movl $0x1, -0x4c(%rbp)
jmp 0x12754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x46(%rbp), %rdi
callq 0x10770
jmp 0x1276a
jmp 0x125e7
jmp 0x126c7
movsbl -0x45(%rbp), %eax
cmpl $0x3e, %eax
je 0x126fb
movq -0x10(%rbp), %rdi
callq 0x10870
movl %eax, -0xa4(%rbp)
jmp 0x126e1
movl -0xa4(%rbp), %eax
movb %al, -0x45(%rbp)
movsbl -0x45(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x10470
jmp 0x126f9
jmp 0x126c7
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x104f0
movq -0xb0(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
callq 0x10740
jmp 0x12727
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x108a0
leaq -0x70(%rbp), %rdi
callq 0x10460
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10420
movl $0x1, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10460
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x10460
movq -0x40(%rbp), %rdi
callq 0x10cc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x251f0
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
callq 0x25040
cmpq $0x0, %rax
jne 0x158ee
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x159f5
movq -0x88(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x40, %edx
callq 0x25210
jmp 0x15905
leaq -0x58(%rbp), %rdi
callq 0x25350
movq %rax, -0xa0(%rbp)
jmp 0x15917
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x247b0
jmp 0x15929
movl $0x0, -0x7c(%rbp)
movslq -0x7c(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x253b0
movq %rax, -0xa8(%rbp)
jmp 0x1594d
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
cmpq %rcx, %rax
jge 0x159cb
movslq -0x7c(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x24960
movq %rax, -0xb8(%rbp)
jmp 0x15976
movq -0xb8(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x253d0
jmp 0x1598b
jmp 0x1598d
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x15930
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x15a17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x159ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x24650
jmp 0x159ea
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x24650
leaq -0x58(%rbp), %rdi
callq 0x25440
jmp 0x159f5
leaq -0x58(%rbp), %rdi
callq 0x25440
jmp 0x15a17
testb $0x1, -0x11(%rbp)
jne 0x15a07
movq -0x98(%rbp), %rdi
callq 0x25480
movq -0x90(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x25480
movq -0x60(%rbp), %rdi
callq 0x10cc0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x251f0
movl $0xa, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x15b42
movq -0x48(%rbp), %rdi
callq 0x14a60
movsd %xmm0, -0x60(%rbp)
jmp 0x15a86
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x35(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x254e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x15b1b
movq -0x58(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movslq -0x3c(%rbp), %rsi
callq 0x25500
movsd -0x70(%rbp), %xmm1
subsd (%rax), %xmm1
movaps 0xa6641(%rip), %xmm0    # 0xbc120
pand %xmm0, %xmm1
movsd 0xa657d(%rip), %xmm0    # 0xbc068
ucomisd %xmm1, %xmm0
jbe 0x15b0e
movb $0x1, -0x35(%rbp)
jmp 0x15b0e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x25480
jmp 0x15b85
jmp 0x15b10
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x15a9b
testb $0x1, -0x35(%rbp)
jne 0x15b32
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x253d0
jmp 0x15b30
jmp 0x15b32
jmp 0x15b34
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15a6a
movq -0x58(%rbp), %rdi
callq 0x254e0
cmpq $0x0, %rax
jne 0x15b68
movq 0x11b440(%rip), %rdi    # 0x130f98
leaq 0xa6c8e(%rip), %rsi     # 0xbc7ed
callq 0x106c0
jmp 0x15b66
jmp 0x15b68
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x15b7b
movq -0x58(%rbp), %rdi
callq 0x25480
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x251f0
movl $0x2, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xa6498(%rip), %xmm0    # 0xbc070
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x15cd2
movq -0x50(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
addsd %xmm0, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x14690
movsd %xmm0, -0x68(%rbp)
jmp 0x15c16
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x0, -0x3d(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x44(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x254e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x15cab
movq -0x60(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movslq -0x44(%rbp), %rsi
callq 0x25500
movsd -0x78(%rbp), %xmm1
subsd (%rax), %xmm1
movaps 0xa64b1(%rip), %xmm0    # 0xbc120
pand %xmm0, %xmm1
movsd 0xa63ed(%rip), %xmm0    # 0xbc068
ucomisd %xmm1, %xmm0
jbe 0x15c9e
movb $0x1, -0x3d(%rbp)
jmp 0x15c9e
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x25480
jmp 0x15cf2
jmp 0x15ca0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x15c2b
testb $0x1, -0x3d(%rbp)
jne 0x15cc2
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x253d0
jmp 0x15cc0
jmp 0x15cc2
jmp 0x15cc4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15be8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x15ce5
movq -0x60(%rbp), %rdi
callq 0x25480
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10cc0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x104f0
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x25520
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x10980
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x10e40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x104f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x10980
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x25710
movl $0x1, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x16248
movq -0x198(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10300
jmp 0x160ca
movq -0x1a0(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x118(%rbp), %rdx
callq 0x14db0
jmp 0x160e6
leaq -0x118(%rbp), %rdi
callq 0x10460
movq -0x20(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x25810
jmp 0x16112
leaq -0x190(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x15890
jmp 0x16127
leaq -0xf0(%rbp), %rdi
callq 0x25850
movsd %xmm0, -0x1b0(%rbp)
jmp 0x1613d
movsd -0x1b0(%rbp), %xmm0
leaq -0x160(%rbp), %rdi
leaq -0x178(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x25880
jmp 0x16161
movq -0x1a8(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x257e0
jmp 0x16176
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x1609b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x16268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10460
jmp 0x16268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1623a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1622e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
jmp 0x16268
movq -0x28(%rbp), %rdi
callq 0x14360
jmp 0x16253
leaq -0xf0(%rbp), %rdi
callq 0x25930
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
leaq -0xf0(%rbp), %rdi
callq 0x25930
movq -0x120(%rbp), %rdi
callq 0x10cc0
// File: 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
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x25710
movl $0x1, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x16468
movq -0x198(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10300
jmp 0x162ea
movq -0x1a0(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x118(%rbp), %rdx
callq 0x14db0
jmp 0x16306
leaq -0x118(%rbp), %rdi
callq 0x10460
movq -0x20(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x25810
jmp 0x16332
leaq -0x190(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x15a30
jmp 0x16347
leaq -0xf0(%rbp), %rdi
callq 0x25850
movsd %xmm0, -0x1b0(%rbp)
jmp 0x1635d
movsd -0x1b0(%rbp), %xmm0
leaq -0x160(%rbp), %rdi
leaq -0x178(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x25880
jmp 0x16381
movq -0x1a8(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x257e0
jmp 0x16396
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x162bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x16488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10460
jmp 0x16488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1645a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1644e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
jmp 0x16488
movq -0x28(%rbp), %rdi
callq 0x14360
jmp 0x16473
leaq -0xf0(%rbp), %rdi
callq 0x25930
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
leaq -0xf0(%rbp), %rdi
callq 0x25930
movq -0x120(%rbp), %rdi
callq 0x10cc0
// File: 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
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x25710
movl $0x1, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x16688
movq -0x198(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10300
jmp 0x1650a
movq -0x1a0(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x118(%rbp), %rdx
callq 0x14db0
jmp 0x16526
leaq -0x118(%rbp), %rdi
callq 0x10460
movq -0x20(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x25810
jmp 0x16552
leaq -0x190(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x15b90
jmp 0x16567
leaq -0xf0(%rbp), %rdi
callq 0x25850
movsd %xmm0, -0x1b0(%rbp)
jmp 0x1657d
movsd -0x1b0(%rbp), %xmm0
leaq -0x160(%rbp), %rdi
leaq -0x178(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x25880
jmp 0x165a1
movq -0x1a8(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x257e0
jmp 0x165b6
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x164db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x166a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10460
jmp 0x166a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1667a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x1666e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x25900
leaq -0x190(%rbp), %rdi
callq 0x25480
leaq -0x178(%rbp), %rdi
callq 0x236d0
jmp 0x166a8
movq -0x28(%rbp), %rdi
callq 0x14360
jmp 0x16693
leaq -0xf0(%rbp), %rdi
callq 0x25930
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
leaq -0xf0(%rbp), %rdi
callq 0x25930
movq -0x120(%rbp), %rdi
callq 0x10cc0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x10040
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x10900
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x26830
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1736a
movq -0x28(%rbp), %rdi
callq 0x10940
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x10040
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x10900
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x26860
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x173e6
movq -0x30(%rbp), %rdi
callq 0x10940
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x10040
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x10900
movq -0x20(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x22(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x25520
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1746b
movq -0x40(%rbp), %rdi
callq 0x10940
movswl -0x22(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x10040
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movswq -0x22(%rbp), %rdx
callq 0x10900
movq -0x20(%rbp), %rax
movswq -0x22(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, -0x23(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x24(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10ce0
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x23400
jmp 0x174c8
leaq -0x24(%rbp), %rdi
callq 0x10770
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x174e8
movq -0x68(%rbp), %rdi
callq 0x10940
movb $0x1, -0x23(%rbp)
testb $0x1, -0x23(%rbp)
jne 0x17514
jmp 0x1750b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x10770
jmp 0x1751e
movq -0x50(%rbp), %rdi
callq 0x10460
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd 0xa4b2a(%rip), %xmm0    # 0xbc080
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x175fd
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xa4ac9(%rip), %xmm0    # 0xbc088
mulsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x17610
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
cvtss2sd %xmm1, %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17562
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Kingsford-Group[P]ghost2/src/gzReader.hpp
// Function: fastpow2(float)
static inline float fastpow2 (float p)
{
  float offset = (p < 0) ? 1.0f : 0.0f;
  float clipp = (p < -126) ? -126.0f : p;
  int w = clipp;
  float z = clipp - w + offset;
  union { uint32_t i; float f; } v = { static_cast<uint32_t> ( (1 << 23) * (clipp + 121.2740575f + 27.7280233f / (4.84252568f - z) - 1.49012907f * z) ) };
  return v.f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
movss 0xa4b3e(%rip), %xmm3    # 0xbc164
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
movaps %xmm0, %xmm1
andps %xmm3, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss 0xa4b19(%rip), %xmm0    # 0xbc160
ucomiss -0x4(%rbp), %xmm0
jbe 0x1765c
movss 0xa4b0b(%rip), %xmm0    # 0xbc160
movss %xmm0, -0x1c(%rbp)
jmp 0x17666
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
cvttss2si -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
subss %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm1
movss 0xa4ac7(%rip), %xmm0    # 0xbc168
addss %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
movss 0xa4aba(%rip), %xmm3    # 0xbc16c
subss %xmm0, %xmm3
movss 0xa4ab2(%rip), %xmm2    # 0xbc170
divss %xmm3, %xmm2
addss %xmm2, %xmm1
movss 0xa4aa6(%rip), %xmm2    # 0xbc174
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0xa4a9a(%rip), %xmm1    # 0xbc178
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)