LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/GCW.cpp
// Function: create_dist(Graph&, int, std::vector<float, std::allocator<float>>&)
void create_dist(Graph & g, int p, vector<float> &RR_user_Prs){
	float IP;
	float not_AP;
	// cout << "Event: " << p << endl; 
	for(int v = 1; v <= g.getSize(); v++){
		not_AP = 1.0;
		map<double, int>::iterator it = g.A[v].begin();
		while (it->second != p and not_AP != 0){
			not_AP *= 1 - g.AP[it->second][v]; //Probability not influenced by the stronger competitors
			++it;
		}
		// if (v <= g.getSize()){
		// 	cout << v << " " << not_AP << endl;
		// }
		IP = (g.similarities[v][p]/g.tsim_V_p[p]) * not_AP;
		RR_user_Prs[v - 1] = IP;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
pushq $0x1
popq %r12
movq %r14, %rdi
callq 0xba86
cltq
cmpq %rax, %r12
jg 0x5191
imulq $0x30, %r12, %rax
movq 0xaf8(%r14), %rcx
movq 0xb18(%r14), %r13
movq 0x18(%rcx,%rax), %rax
movss 0xdf7b(%rip), %xmm1     # 0x1308c
movslq 0x28(%rax), %rcx
cmpl %ebp, %ecx
je 0x5151
ucomiss 0xdf78(%rip), %xmm1     # 0x13098
jne 0x5124
jnp 0x5151
movq (%r13,%rcx,8), %rcx
movss 0xdf5b(%rip), %xmm0     # 0x1308c
subss (%rcx,%r12,4), %xmm0
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movq %rax, %rdi
callq 0x3260
movss 0x4(%rsp), %xmm1
jmp 0x5111
imulq $0x18, %r12, %rax
movq 0xae0(%r14), %rcx
movq 0xb00(%r14), %rdx
movq (%rcx,%rax), %rax
movsd (%rax,%r15,8), %xmm0
divsd (%rdx,%r15,8), %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movq (%rbx), %rax
movss %xmm0, -0x4(%rax,%r12,4)
incq %r12
jmp 0x50df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/GCW.cpp
// Function: count_change_strat(Graph&, Locations*, int)
int count_change_strat(Graph & g, Locations * usersLocations, int p){
	int changedSeedsets = 0;
	for (int seed : g.seedSets[p]){
		// Did not find it in the previous seedset
		if (g.seedSets_before[p].find(seed) == g.seedSets_before[p].end()){
			bool not_same_location = true;
			for (int old_seed : g.seedSets_before[p]){
				if (usersLocations->same_location(seed, old_seed)){
					not_same_location = false;
					break;	
				}
			}
			if (not_same_location)
				++changedSeedsets;
		}
	}		
	if(changedSeedsets > 0){
		g.seedSets_before[p].clear();
		for (int seed : g.seedSets[p])
			g.seedSets_before[p].insert(seed);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xad0(%rdi), %rax
movslq %edx, %rcx
imulq $0x30, %rcx, %r12
leaq (%rax,%r12), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r15
movl $0x0, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
cmpq %rbp, %r15
je 0x5264
movl 0x20(%r15), %eax
movl %eax, 0x4(%rsp)
movq 0xad8(%rbx), %rdi
addq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x9a10
movq %rax, %r13
movq 0xad8(%rbx), %rax
leaq (%rax,%r12), %rcx
addq $0x8, %rcx
cmpq %rcx, %r13
jne 0x5254
addq %r12, %rax
movq 0x18(%rax), %rbp
cmpq %r13, %rbp
je 0x5243
movl 0x20(%rbp), %edx
movl 0x4(%rsp), %esi
movq %r14, %rdi
callq 0xab16
testb %al, %al
jne 0x5243
movq %rbp, %rdi
callq 0x33a0
movq %rax, %rbp
jmp 0x521e
xorl %eax, %eax
cmpq %r13, %rbp
sete %al
addl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rbp
movq %r15, %rdi
callq 0x33a0
movq %rax, %r15
jmp 0x51db
movq 0xad8(%rbx), %rdi
addq %r12, %rdi
callq 0x9a62
movq 0xad0(%rbx), %rax
movq 0x18(%rax,%r12), %r15
leaq 0xc(%rsp), %r14
movl 0x20(%r15), %eax
movl %eax, 0xc(%rsp)
movq 0xad8(%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x9ac4
movq %r15, %rdi
callq 0x33a0
movq %rax, %r15
jmp 0x5284
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/GCW.cpp
// Function: output_stats_q_and_t(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>*, std::vector<double, std::allocator<double>>*, int)
void output_stats_q_and_t(ostream * output, string algorithms, vector<double> * round_data_time, vector<double> * round_data_score, int rounds){
	for (int i = 0; i < algorithms.size(); i += 2){
		*output << algorithms.substr(i,2) << endl;
		for (int j = 0; j <= rounds; ++j){
			*output << round_data_time[i/2][j] << "\t" << round_data_score[i/2][j] << endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, %r12
movslq %r8d, %r14
xorl %r15d, %r15d
leaq 0x28(%rsp), %r13
leaq 0xdb53(%rip), %rbx      # 0x130c2
movq %rsi, 0x8(%rsp)
cmpq %r15, 0x8(%rsi)
jbe 0x561c
movq %r13, %rdi
movq %r15, %rdx
pushq $0x2
popq %rcx
callq 0x3380
movq %r12, %rdi
movq %r13, %rsi
callq 0x3310
movq %rax, %rdi
callq 0x3190
movq %r13, %rdi
callq 0x3160
movq %r15, 0x20(%rsp)
shrq %r15
imulq $0x18, %r15, %rbp
movq 0x10(%rsp), %rax
leaq (%rax,%rbp), %r15
addq 0x18(%rsp), %rbp
xorl %r13d, %r13d
cmpq %r14, %r13
jg 0x5604
movq (%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq %r12, %rdi
callq 0x34f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3360
movq (%rbp), %rcx
movsd (%rcx,%r13,8), %xmm0
movq %rax, %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x3190
incq %r13
jmp 0x55c4
movq 0x20(%rsp), %r15
addq $0x2, %r15
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %r13
jmp 0x5574
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3160
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/GCW.cpp
// Function: output_clust(std::ostream*, double***, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_clust(ostream * output, double *** data, string variable, string algorithms){
	for (int i = 0; i < algorithms.size(); i += 2){
		if (algorithms.substr(i,2) == "EG"){
			*output << setw(16) << "GCW";
		}
		else{
			*output << setw(16) << algorithms.substr(i,2);
		}
		*output << setw(16) << data[0][i/2][0] << setw(16) << data[1][i/2][0] << setw(16) << data[2][i/2][0] << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x18(%rsp), %r13
pushq $0x2
popq %rbp
movq %rcx, 0x10(%rsp)
cmpq %r12, 0x8(%r14)
jbe 0x6051
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x3380
movq %r13, %rdi
leaq 0xd14a(%rip), %rsi      # 0x130bb
callq 0x8830
movq %rbp, %rbx
movl %eax, %ebp
movq %r13, %rdi
callq 0x3160
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x10, 0x10(%r15,%rax)
testb %bpl, %bpl
je 0x5fac
movq %r15, %rdi
leaq 0xd11c(%rip), %rsi      # 0x130be
callq 0x3360
movq %rbx, %rbp
jmp 0x5fd3
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3380
movq %r15, %rdi
movq %r13, %rsi
callq 0x3310
movq %rbx, %rbp
movq %r13, %rdi
callq 0x3160
movq (%r15), %rax
movq -0x18(%rax), %rax
pushq $0x10
popq %r14
movq %r14, 0x10(%r15,%rax)
movq 0x8(%rsp), %rbx
movq (%rbx), %rax
movq (%rax,%r12,4), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x34f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x34f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
movq 0x10(%rbx), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x3190
addq $0x2, %r12
movq 0x10(%rsp), %r14
jmp 0x5f4c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3160
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::MappedHeap(std::vector<int, std::allocator<int>> const&, InfCost<int>)
MappedHeap<CompareLess>::MappedHeap(const vector<int> &v,CompareLess cl):compLess(cl) {
	if (v.empty())
		n = 0;
	else {
		n = v.size();
		heap.resize(n + 1);
		position.resize(max<int> (*max_element(v.begin(), v.end()), n) + 3, -1);
		for (int i = 0; i < n; i++) {
			heap[i + 1] = v[i];
			position[v[i]] = i + 1;
		}
		for (size_t i = n/ 2; i >= 1; i--)
			down_heap(i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x38(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0x854f
movq %rsi, %r15
leaq 0x18(%rbx), %r14
subq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, 0x30(%rbx)
shlq $0x1e, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rax, %rsi
sarq $0x20, %rsi
movq %rbx, %rdi
callq 0x9252
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x963a
movl (%rax), %eax
movl 0x30(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
addl $0x3, %ecx
movslq %ecx, %rsi
leaq 0xc(%rsp), %rdx
orl $-0x1, (%rdx)
movq %r14, %rdi
callq 0x9284
movq (%r15), %rcx
movq (%rbx), %rdx
movq 0x18(%rbx), %rsi
xorl %edi, %edi
movslq 0x30(%rbx), %rax
cmpq %rax, %rdi
jge 0x8530
movslq (%rcx,%rdi,4), %rax
movl %eax, 0x4(%rdx,%rdi,4)
incq %rdi
movl %edi, (%rsi,%rax,4)
jmp 0x8517
pushq $0x2
popq %rcx
cltd
idivl %ecx
movslq %eax, %rsi
movq %rsi, %r15
subq $0x1, %r15
jb 0x8553
movq %rbx, %rdi
callq 0x92b8
movq %r15, %rsi
jmp 0x853c
andl $0x0, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8563
jmp 0x8563
jmp 0x8563
movq %rax, %r15
movq %r14, %rdi
callq 0x90a0
movq %rbx, %rdi
callq 0x90a0
movq %r15, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::heapify(int)
inline int MappedHeap<CompareLess>::heapify(int key) {
	//DCHECK(key < (int)position.size(),"Error:MappedHeap:heapify: index out of range " << key <<endl )
	//DCHECK((1 <= position[key]) && (position[key] <= n), "Error:MappedHeap:heapify: invalid position " << position[key] << " key: "<<key<< endl);
	up_heap(position[key]);    
	return down_heap(position[key]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq 0x18(%rdi), %rax
movl (%rax,%r14,4), %esi
callq 0x9784
movq 0x18(%rbx), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92b8
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::down_heap(int)
int MappedHeap<CompareLess>::down_heap(int k) {
	while (k * 2 <= n) {
		int child = k * 2, right_child = child + 1;
		if ((right_child <= n)
				&& (compLess(heap[child], heap[right_child])))
                    child = right_child;
		if ((compLess(heap[k], heap[child]))) {
			swap(position[heap[k]], position[heap[child]]);
            swap(heap[k], heap[child]);			
			k = child;
		} else
			break;
	}
	return k;
}

// Assembly:
pushq %rbp
pushq %rbx
movl %esi, %eax
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
leal (%rax,%rax), %r8d
cmpl 0x30(%rdi), %r8d
jg 0x9332
jge 0x92f8
movl %r8d, %r9d
orl $0x1, %r9d
movslq %r8d, %r10
movslq %r9d, %r11
movslq (%rcx,%r10,4), %r10
movl (%rsi,%r10,4), %r10d
movslq (%rcx,%r11,4), %r11
cmpl (%rsi,%r11,4), %r10d
jl 0x92f5
movl %r8d, %r9d
movl %r9d, %r8d
movslq %eax, %r9
movslq %r8d, %r10
movslq (%rcx,%r9,4), %r11
movl (%rsi,%r11,4), %ebp
movslq (%rcx,%r10,4), %rbx
cmpl (%rsi,%rbx,4), %ebp
jge 0x9332
movl (%rdx,%r11,4), %eax
movl (%rdx,%rbx,4), %ebp
movl %ebp, (%rdx,%r11,4)
movl %eax, (%rdx,%rbx,4)
movl (%rcx,%r9,4), %eax
movl (%rcx,%r10,4), %r11d
movl %r11d, (%rcx,%r9,4)
movl %eax, (%rcx,%r10,4)
movl %r8d, %eax
jmp 0x92c7
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::up_heap(int)
int MappedHeap<CompareLess>::up_heap(int k) {
	while (k > 1) {
		int p = k / 2;
		if (compLess(heap[p], heap[k])) {
			swap(position[heap[p]], position[heap[k]]);
			swap(heap[p], heap[k]);
		}
		k = p;
	}
	return k;
}

// Assembly:
movl %esi, %eax
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
cmpl $0x2, %eax
jl 0x97ce
movl %eax, %edi
shrl %eax
movslq (%rcx,%rax,4), %r8
movl (%rsi,%r8,4), %r10d
movslq (%rcx,%rdi,4), %r9
cmpl (%rsi,%r9,4), %r10d
jge 0x9791
movl (%rdx,%r8,4), %r10d
movl (%rdx,%r9,4), %r11d
movl %r11d, (%rdx,%r8,4)
movl %r10d, (%rdx,%r9,4)
movl (%rcx,%rax,4), %r8d
movl (%rcx,%rdi,4), %r9d
movl %r9d, (%rcx,%rax,4)
movl %r8d, (%rcx,%rdi,4)
jmp 0x9791
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/Utilities.cpp
// Function: Utilities::computeMinimumDistance(double, double, double, double, char)
double Utilities::computeMinimumDistance(double lat1, double lon1, double lat2, double lon2, char unit){
    double R = 6371; // Radius of the earth in km
    double dLat = deg2rad(lat2-lat1);  // deg2rad below
    double dLon = deg2rad(lon2-lon1); 
    double a = sin(dLat/2) * sin(dLat/2) + cos(deg2rad(lat1)) * cos(deg2rad(lat2)) * sin(dLon/2) * sin(dLon/2); 
    double c = 2 * atan2(sqrt(a), sqrt(1-a)); 
    double d = R * c; // Distance in km
    return d;
}

// Assembly:
subq $0x28, %rsp
movapd %xmm2, %xmm4
movsd %xmm2, (%rsp)
movsd %xmm0, 0x18(%rsp)
subsd %xmm0, %xmm4
movsd 0x8e17(%rip), %xmm0     # 0x134e0
mulsd %xmm0, %xmm4
movsd 0x8e13(%rip), %xmm2     # 0x134e8
divsd %xmm2, %xmm4
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rsp)
mulsd 0x8dfd(%rip), %xmm4     # 0x134f0
movsd %xmm4, 0x8(%rsp)
movapd %xmm4, %xmm0
callq 0x30c0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x30c0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x8db9(%rip), %xmm0     # 0x134e0
divsd 0x8db9(%rip), %xmm0     # 0x134e8
callq 0x35e0
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
mulsd 0x8d99(%rip), %xmm0     # 0x134e0
divsd 0x8d99(%rip), %xmm0     # 0x134e8
callq 0x35e0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x8d83(%rip), %xmm0     # 0x134f0
movsd %xmm0, 0x10(%rsp)
callq 0x30c0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x30c0
movsd 0x8(%rsp), %xmm1
mulsd (%rsp), %xmm0
mulsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jb 0xa7b2
sqrtsd %xmm1, %xmm2
jmp 0xa7cf
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x32d0
xorpd %xmm3, %xmm3
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x8869(%rip), %xmm0     # 0x13040
subsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0xa7e7
sqrtsd %xmm0, %xmm1
jmp 0xa7fc
movsd %xmm2, 0x10(%rsp)
callq 0x32d0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x3070
addsd %xmm0, %xmm0
mulsd 0x8ce7(%rip), %xmm0     # 0x134f8
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/Locations.cpp
// Function: Locations::same_location(int, int)
bool Locations::same_location(int id1, int id2){
    pair <double, double> coord1;
    vector<int> users_list;

    get_coordinates(id1, coord1);
    users_list = *get_users(coord1);
    for (int i = 0; i < users_list.size(); ++i){
        if (users_list[i] == id2)
            return true;
    }
    return false;

}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movups (%rax), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
addq $0x10, %rdi
callq 0xabaa
movq %rsp, %rdi
movq %rax, %rsi
callq 0x85f4
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %esi, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0xab76
leaq 0x1(%rdx), %rsi
cmpl %ebx, (%rcx,%rdx,4)
jne 0xab65
cmpq %rdx, %rax
seta %bl
movq %rsp, %rdi
callq 0x90a0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x90a0
movq %rbx, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::BinaryHeap(int)
BinaryHeap::BinaryHeap(int numItems){
	size = numItems;
	distances = new double[size];
	vertices = new int[size];
	for (int i = 0; i < size; ++i){
		distances[i] = numeric_limits<double>::max();
		vertices[i] = 0;
	}

	for (int i = parent(size - 1); i >= 0; --i){
		hipify(i);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movslq %esi, %rax
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %r13d
cmovgl %esi, %r13d
movq %rdi, %rbx
leaq (,%rax,4), %r15
testl %eax, %eax
pushq $-0x1
popq %rcx
cmovsq %rcx, %r15
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
movl %eax, 0x10(%rbx)
cmovsq %rcx, %rdi
callq 0x3030
movq %rax, %r14
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %r12, %r13
je 0xb0ff
movq %rcx, (%r14,%r12,8)
andl $0x0, (%rax,%r12,4)
incq %r12
jmp 0xb0ec
addl $-0x2, %ebp
pushq $0x2
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %ebp
testl %ebp, %ebp
js 0xb11e
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb138
decl %ebp
jmp 0xb10c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::hipify(int)
void BinaryHeap::hipify(int idx){
	int l = left(idx);
	int r = right(idx);

	int max = idx;
	if (l < size && priority(l) > priority(idx)){
		max = l;
	}

	if (r < size && priority(r) > priority(max)){
		max = r;
	}

	if (max != idx){
		swap(max, idx);
		hipify(max);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
leal 0x1(,%rdx,2), %ecx
movl 0x10(%rbx), %eax
movl %edx, %ebp
cmpl %eax, %ecx
jge 0xb169
movq (%rbx), %rsi
movslq %ecx, %rdi
movsd (%rsi,%rdi,8), %xmm0
movslq %edx, %rdi
ucomisd (%rsi,%rdi,8), %xmm0
movl %edx, %ebp
jbe 0xb169
movl %ecx, %ebp
leal 0x2(,%rdx,2), %ecx
cmpl %eax, %ecx
jge 0xb18b
movq (%rbx), %rax
movslq %ecx, %rsi
movsd (%rax,%rsi,8), %xmm0
movslq %ebp, %rsi
ucomisd (%rax,%rsi,8), %xmm0
jbe 0xb18b
movl %ecx, %ebp
cmpl %edx, %ebp
je 0xb19d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb1c0
movl %ebp, %edx
jmp 0xb140
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::percolate(int)
void BinaryHeap::percolate(int idx){
	int curr = idx;
	int p = parent(idx);
	while (curr > 0 && priority(p) < priority(curr)){
		swap(p, curr);
		curr = p;
		p = parent(curr);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
pushq $0x2
popq %r14
leal -0x1(%rcx), %eax
cltd
idivl %r14d
testl %ecx, %ecx
jle 0xb22e
movl %eax, %ebp
movq (%rbx), %rax
movslq %ebp, %rdx
movl %ecx, %esi
movsd (%rax,%rsi,8), %xmm0
ucomisd (%rax,%rdx,8), %xmm0
jbe 0xb22e
movq %rbx, %rdi
movl %ebp, %esi
movl %ecx, %edx
callq 0xb1c0
movl %ebp, %ecx
jmp 0xb1fd
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::popMax()
void BinaryHeap::popMax(){
	distances[0] = -1;
	vertices[0] = -1;
	swap(0, size - 1);
	--size;
	hipify(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rax)
movq 0x8(%rdi), %rax
orl $-0x1, (%rax)
movl 0x10(%rdi), %edx
decl %edx
xorl %esi, %esi
callq 0xb1c0
decl 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0xb138
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::print()
void BinaryHeap::print(){
	cout << "[";
	for (int i = 0; i < size; ++i){
		cout << "(" << distances[i] << ", " << vertices[i] << "), ";
	}
	cout << "]" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10cf9(%rip), %r14     # 0x1bfc8
leaq 0x834b(%rip), %rsi      # 0x13621
movq %r14, %rdi
callq 0x3360
xorl %ebp, %ebp
leaq 0x7fad(%rip), %r15      # 0x13294
leaq 0x8336(%rip), %r12      # 0x13624
leaq 0x832e(%rip), %r13      # 0x13623
movslq 0x10(%rbx), %rax
cmpq %rax, %rbp
jge 0xb343
movq %r14, %rdi
movq %r15, %rsi
callq 0x3360
movq (%rbx), %rcx
movsd (%rcx,%rbp,8), %xmm0
movq %rax, %rdi
callq 0x34f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3360
movq 0x8(%rbx), %rcx
movl (%rcx,%rbp,4), %esi
movq %rax, %rdi
callq 0x3580
movq %rax, %rdi
movq %r13, %rsi
callq 0x3360
incq %rbp
jmp 0xb2f5
movq 0x10c7e(%rip), %rdi     # 0x1bfc8
leaq 0x7d94(%rip), %rsi      # 0x130e5
callq 0x3360
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3190
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::~Graph()
Graph::~Graph(){
    delete [] seedSets;
    delete [] seedSets_before;
    for (int p = 0; p < numEvents; ++p){
        delete [] AP[p];
    }
    delete [] AP;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xad0(%rdi), %r15
testq %r15, %r15
je 0xbe93
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xbe8b
addq $-0x30, %r15
imulq $0x30, %rax, %r12
leaq (%r15,%r12), %rdi
callq 0xee8e
addq $-0x30, %r12
jne 0xbe7c
movq %r14, %rdi
callq 0x33f0
movq 0xad8(%rbx), %r15
testq %r15, %r15
je 0xbecb
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xbec3
addq $-0x30, %r15
imulq $0x30, %rax, %r12
leaq (%r15,%r12), %rdi
callq 0xee8e
addq $-0x30, %r12
jne 0xbeb4
movq %r14, %rdi
callq 0x33f0
xorl %r14d, %r14d
movslq 0x9d0(%rbx), %rax
movq 0xb18(%rbx), %rdi
cmpq %rax, %r14
jge 0xbef4
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0xbeef
callq 0x33f0
incq %r14
jmp 0xbece
testq %rdi, %rdi
je 0xbefe
callq 0x33f0
leaq 0xb00(%rbx), %rdi
callq 0x9976
leaq 0xae0(%rbx), %rdi
callq 0xeb00
leaq 0xab8(%rbx), %rdi
callq 0x98b0
leaq 0xaa0(%rbx), %rdi
callq 0xeb22
leaq 0xa88(%rbx), %rdi
callq 0x8c04
leaq 0xa70(%rbx), %rdi
callq 0x90a0
leaq 0xa38(%rbx), %rdi
callq 0x8470
leaq 0xa20(%rbx), %rdi
callq 0x90a0
leaq 0xa08(%rbx), %rdi
callq 0xeb22
leaq 0x9f0(%rbx), %rdi
callq 0xeb22
addq $0x9d8, %rbx            # imm = 0x9D8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8c04
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::set_events(int&)
void Graph::set_events(int &P){
    numEvents = P;
    seedSets = new set<int>[P];
    seedSets_before = new set<int>[P];
    tsim_V_p.clear();
    tsim_V_p.resize(P, 0);
    for (int i = 1; i < getSize() + 1; i++){
        similarities[i].resize(P);
    }

    AP = new float*[P]; // Awareness probability of node from competitor
    for (int p = 0; p < P; p++)
        AP[p] = new float[getSize() + 1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %r15
pushq $0x30
popq %rcx
movq %r15, %rax
mulq %rcx
movq %rax, %r12
seto %al
orq $0x8, %r12
movl %r15d, 0x9d0(%rdi)
pushq $-0x1
popq %rcx
testb %al, %al
cmovneq %rcx, %r12
movq %r12, %rdi
callq 0x3030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testq %r15, %r15
je 0xc00a
addq $0x10, %rax
imulq $0x30, %r15, %rdx
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0xbfeb
movq %rcx, 0xad0(%rbx)
movq %r12, %rdi
callq 0x3030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testl %r15d, %r15d
je 0xc04c
addq $0x10, %rax
imulq $0x30, %r15, %rdx
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0xc02d
movq %rcx, 0xad8(%rbx)
leaq 0xb00(%rbx), %rdi
movq 0xb00(%rbx), %rax
cmpq %rax, 0xb08(%rbx)
je 0xc071
movq %rax, 0xb08(%rbx)
movq %rsp, %rdx
andq $0x0, (%rdx)
movq %r15, %rsi
callq 0xeb44
pushq $0x1
popq %r15
pushq $0x18
popq %r12
movslq 0x9c8(%rbx), %rbp
cmpq %rbp, %r15
jg 0xc0af
movq 0xae0(%rbx), %rdi
addq %r12, %rdi
movslq (%r14), %rsi
callq 0xeb78
incq %r15
addq $0x18, %r12
jmp 0xc088
movslq (%r14), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x3030
movq %rax, 0xb18(%rbx)
cmpl $-0x1, %ebp
leaq 0x4(,%rbp,4), %r14
cmovlq %r15, %r14
xorl %r15d, %r15d
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
cmpq %r15, %r12
je 0xc10d
movq %r14, %rdi
callq 0x3030
movq 0xb18(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0xc0f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::change_events(int&)
void Graph::change_events(int &P){
    delete [] seedSets;
    delete [] seedSets_before;
    for (int p = 0; p < numEvents; ++p){
        delete [] AP[p];
    }
    delete [] AP;
    set_events(P);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xad0(%rdi), %r12
testq %r12, %r12
je 0xc165
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xc15d
addq $-0x30, %r12
imulq $0x30, %rax, %r13
leaq (%r12,%r13), %rdi
callq 0xee8e
addq $-0x30, %r13
jne 0xc14e
movq %r15, %rdi
callq 0x33f0
movq 0xad8(%r14), %r12
testq %r12, %r12
je 0xc19f
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xc197
addq $-0x30, %r12
imulq $0x30, %rax, %r13
leaq (%r12,%r13), %rdi
callq 0xee8e
addq $-0x30, %r13
jne 0xc188
movq %r15, %rdi
callq 0x33f0
xorl %r15d, %r15d
movslq 0x9d0(%r14), %rax
movq 0xb18(%r14), %rdi
cmpq %rax, %r15
jge 0xc1c8
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0xc1c3
callq 0x33f0
incq %r15
jmp 0xc1a2
testq %rdi, %rdi
je 0xc1d2
callq 0x33f0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbf98
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_AP_IC(int, int, int, int)
float Graph::get_AP_IC(int u, int v, int idx, int p){
    float prob = probabilities[u][idx]; // (u) ---probabilities[u][idx]---> (v) (idx of (v) in adjacency list of (u))
    if (sim)
        prob *= similarities[v][p]; // similarity of the node (v) for the product p
    return prob;
}

// Assembly:
movslq %esi, %rax
movq 0x9f0(%rdi), %rsi
imulq $0x18, %rax, %rax
movslq %ecx, %rcx
movq (%rsi,%rax), %rax
movss (%rax,%rcx,4), %xmm0
cmpb $0x1, 0xb20(%rdi)
jne 0xc281
movslq %edx, %rax
movq 0xae0(%rdi), %rcx
imulq $0x18, %rax, %rax
movslq %r8d, %rdx
movq (%rcx,%rax), %rax
cvtss2sd %xmm0, %xmm0
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_inv_AP_IC(int, int, int, int)
float Graph::get_inv_AP_IC(int u, int v, int idx, int p){
    float prob = weights[u][idx]; // (u) ---probabilities[u][idx]---> (v) (idx of (v) in adjacency list of (u))
    if (sim)
        prob *= similarities[u][p]; // similarity of the node (u) for the product p
    return prob;
}

// Assembly:
movslq %esi, %rax
movq 0xaa0(%rdi), %rdx
imulq $0x18, %rax, %rax
movslq %ecx, %rcx
movq (%rdx,%rax), %rdx
movss (%rdx,%rcx,4), %xmm0
cmpb $0x1, 0xb20(%rdi)
jne 0xc2c0
movq 0xae0(%rdi), %rcx
movslq %r8d, %rdx
movq (%rcx,%rax), %rax
cvtss2sd %xmm0, %xmm0
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_AP_LT(float, int, int)
float Graph::get_AP_LT(float active_prob, int u, int p){
    if (sim)
        return active_prob * similarities[u][p];
    else
        return active_prob;
}

// Assembly:
cmpb $0x1, 0xb20(%rdi)
jne 0xc2ed
cvtss2sd %xmm0, %xmm0
movslq %esi, %rax
movq 0xae0(%rdi), %rcx
imulq $0x18, %rax, %rax
movslq %edx, %rdx
movq (%rcx,%rax), %rax
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::create_AV_sets(Locations*, Locations*, int, Utilities)
void Graph::create_AV_sets(Locations* usersLocations, Locations* eventsLocations, int P, Utilities util){
    double max_dist = find_max_dist(P, usersLocations, eventsLocations, util);
    for (int v = 1; v <= getSize(); v++){
        A[v].clear();
        for (int p = 0; p < P; p++){
            similarities[v][p] = util.computeSimilarity(usersLocations->locations[v][0], usersLocations->locations[v][1], eventsLocations->locations[p][0], eventsLocations->locations[p][1], max_dist);
            A[v].insert(pair<double, int>(-similarities[v][p], p));
            tsim_V_p[p] += similarities[v][p];
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r12
movl %ebx, %esi
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
callq 0xc416
movsd %xmm0, 0x10(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
pushq $0x1
popq %r13
movslq 0x9c8(%r12), %rax
cmpq %rax, %r13
jg 0xc406
imulq $0x30, %r13, %rbp
movq 0xaf8(%r12), %rdi
addq %rbp, %rdi
callq 0xf59e
imulq $0x18, %r13, %r14
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0xc3fe
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
leaq 0xf(%rsp), %rdi
movsd 0x10(%rsp), %xmm4
callq 0xa828
movq 0xae0(%r12), %rax
movq (%rax,%r14), %rax
movsd %xmm0, (%rax,%r15,8)
movq 0xaf8(%r12), %rdi
addq %rbp, %rdi
xorps 0x7284(%rip), %xmm0     # 0x13640
movlps %xmm0, 0x28(%rsp)
movl %r15d, 0x30(%rsp)
leaq 0x28(%rsp), %rsi
callq 0xf600
movq 0xae0(%r12), %rax
movq 0xb00(%r12), %rcx
movq (%rax,%r14), %rax
movsd (%rax,%r15,8), %xmm0
addsd (%rcx,%r15,8), %xmm0
movsd %xmm0, (%rcx,%r15,8)
incq %r15
jmp 0xc355
incq %r13
jmp 0xc329
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::find_max_dist(int, Locations*, Locations*, Utilities)
double Graph::find_max_dist(int P,  Locations* usersLocations, Locations* eventsLocations, Utilities util){
    double max_dist = 0;
    double dist;
    for (int p = 0; p < P; ++p){
        for (int v = 1; v <= getSize(); ++v){
            dist = util.computeMinimumDistance(usersLocations->locations[v][0], usersLocations->locations[v][1], eventsLocations->locations[p][0], eventsLocations->locations[p][1], 'K');
            if (dist > max_dist){
                max_dist = dist;
            }
        }
    }
    return max_dist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %esi
movq %rsi, 0x10(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x4b
popq %rbp
cmpq 0x10(%rsp), %r15
je 0xc4a2
pushq $0x1
popq %r13
movslq 0x9c8(%r12), %rax
cmpq %rax, %r13
jg 0xc49d
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
leaq 0x7(%rsp), %rdi
movl %ebp, %esi
callq 0xa6aa
maxsd 0x8(%rsp), %xmm0
incq %r13
movsd %xmm0, 0x8(%rsp)
jmp 0xc453
incq %r15
jmp 0xc448
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::read_similarities(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Graph::read_similarities(string filename, int P){
    ifstream infile(filename);
    int num_nodes;
    int max_P;
    double tmp;
    stringstream tmp_s;
    int node_id;
    string a;
    infile >> num_nodes >> max_P;
    for (int v = 1; v <= getSize(); v++){
        A[v].clear();
        // infile.getline(tmp_s, 256, "\n");
        infile >> node_id;
        for (int p = 0; p < max_P; p++){
            if (p < P){
                infile >> setprecision(16) >> tmp;
                similarities[v][p] = tmp;
                A[v].insert(pair<double, int>(-similarities[v][p], p));
                tsim_V_p[p] += similarities[v][p];
            }
            else{
                infile >> setprecision(16) >> tmp;
            }
        }
        // infile.seekg(sizeof(double) * (max_P - P) * 2, infile.cur);
        // infile.ignore(max_P - P, "\n");
        // for (int i = 0; i < max_P - P; i++)
        //     infile.ignore(max_P - P, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x3500
leaq 0x260(%rsp), %rdi
callq 0x3270
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x31f0
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x31f0
movslq %ebp, %rbp
pushq $0x1
popq %r12
leaq 0x58(%rsp), %r14
movslq 0x9c8(%rbx), %rax
cmpq %rax, %r12
jg 0xc613
imulq $0x30, %r12, %r15
movq 0xaf8(%rbx), %rdi
addq %r15, %rdi
callq 0xf59e
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x31f0
movq %r12, 0x18(%rsp)
imulq $0x18, %r12, %r13
xorl %r12d, %r12d
movslq 0xc(%rsp), %rax
cmpq %rax, %r12
jge 0xc606
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rax
movq $0x10, 0x60(%rsp,%rax)
cmpq %rbp, %r12
jge 0xc5f1
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3230
movsd 0x10(%rsp), %xmm0
movq 0xae0(%rbx), %rax
movq (%rax,%r13), %rax
movsd %xmm0, (%rax,%r12,8)
movq 0xaf8(%rbx), %rdi
addq %r15, %rdi
xorps 0x7089(%rip), %xmm0     # 0x13640
movlps %xmm0, 0x28(%rsp)
movl %r12d, 0x30(%rsp)
leaq 0x28(%rsp), %rsi
callq 0xf600
movq 0xae0(%rbx), %rax
movq 0xb00(%rbx), %rcx
movq (%rax,%r13), %rax
movsd (%rax,%r12,8), %xmm0
addsd (%rcx,%r12,8), %xmm0
movsd %xmm0, (%rcx,%r12,8)
jmp 0xc5fe
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3230
incq %r12
jmp 0xc55d
movq 0x18(%rsp), %r12
incq %r12
jmp 0xc521
leaq 0x38(%rsp), %rdi
callq 0x3160
leaq 0x260(%rsp), %rdi
callq 0x32a0
leaq 0x58(%rsp), %rdi
callq 0x30e0
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc66b
jmp 0xc651
jmp 0xc651
jmp 0xc651
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3160
leaq 0x260(%rsp), %rdi
callq 0x32a0
leaq 0x58(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::rand_graph(float, float)
void Graph::rand_graph(float m, float s){
    default_random_engine generator;
    normal_distribution<float> distribution(m, s);
    float rand;
    int v;
    for (int i = 1; i <= numNodes; i++){
        probabilities[i].resize(node_deg[i]);
        for (int j = 0; j < node_deg[i]; j++){
            rand = distribution(generator);
            if (rand < 0)
                rand = 0;
            else if (rand > 1)
                rand = 1;
            probabilities[i][j] = rand;
            v = adjList[i][j];
            weights[v].push_back(rand);
        }
    }

    for (int i = 1; i <= numNodes; i++){
        weights[i].resize(inv_node_deg[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
leaq 0x18(%rsp), %r15
movss %xmm0, (%r15)
movss %xmm1, 0x4(%r15)
andl $0x0, 0x8(%r15)
movb $0x0, 0xc(%r15)
pushq $0x1
popq %r13
leaq 0xc(%rsp), %r12
movl 0x9c8(%rbx), %eax
cmpq %rax, %r13
ja 0xc77f
imulq $0x18, %r13, %rbp
movq 0x9f0(%rbx), %rdi
addq %rbp, %rdi
movq 0xa20(%rbx), %rax
movslq (%rax,%r13,4), %rsi
callq 0xea98
xorl %r14d, %r14d
movq 0xa20(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r14
jge 0xc777
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0xebaa
movss %xmm0, 0xc(%rsp)
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xc723
andl $0x0, 0xc(%rsp)
xorps %xmm0, %xmm0
jmp 0xc73c
ucomiss 0x6962(%rip), %xmm0     # 0x1308c
jbe 0xc73c
movl $0x3f800000, 0xc(%rsp)  # imm = 0x3F800000
movss 0x6950(%rip), %xmm0     # 0x1308c
movq 0x9f0(%rbx), %rax
movq (%rax,%rbp), %rax
movss %xmm0, (%rax,%r14,4)
movq 0x9d8(%rbx), %rax
movq (%rax,%rbp), %rax
movslq (%rax,%r14,4), %rax
imulq $0x18, %rax, %rdi
addq 0xaa0(%rbx), %rdi
movq %r12, %rsi
callq 0xebb2
incq %r14
jmp 0xc6ee
incq %r13
jmp 0xc6be
pushq $0x1
popq %r14
pushq $0x18
popq %r15
movl %eax, %eax
cmpq %rax, %r14
ja 0xc7b7
movq 0xaa0(%rbx), %rdi
addq %r15, %rdi
movq 0xa70(%rbx), %rax
movslq (%rax,%r14,4), %rsi
callq 0xea98
incq %r14
movl 0x9c8(%rbx), %eax
addq $0x18, %r15
jmp 0xc787
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::HyperGraph(unsigned int)
HyperGraph::HyperGraph(unsigned int n)
{
	sfmt_init_gen_rand(&sfmtSeed, rand());
	node_edge = vector<vector<int> >(n+1);
	maxDegree = 0;
	numNodes = n;
	curEdge=0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x30f0
movq %r15, %rdi
movl %eax, %esi
callq 0x12319
leal 0x1(%r14), %esi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xec40
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfec0
movq %r15, %rdi
callq 0x8c04
movl %r14d, 0x38(%rbx)
andq $0x0, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc838
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x8c04
movq %rbx, %rdi
callq 0x8c04
movq %r14, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::updateDeg()
void HyperGraph::updateDeg(){
	unsigned int num=edge_node.size();
	for (unsigned int i = curEdge; i < num; ++i){
		unsigned int num2 = edge_node[i].size();
		for (unsigned int j=0;j<num2;++j){
			node_edge[edge_node[i][j]].push_back(i);
		}
	}
	curEdge = edge_node.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl 0x30(%rdi), %r12d
movl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0xc(%rsp), %r14
cmpq 0x10(%rsp), %r12
jae 0xc8d6
movq 0x18(%rbx), %rax
imulq $0x18, %r12, %rbp
movq 0x8(%rax,%rbp), %rcx
subq (%rax,%rbp), %rcx
shrq $0x2, %rcx
movl %ecx, %r15d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0xc8d1
movq 0x18(%rbx), %rax
movq (%rax,%rbp), %rax
movslq (%rax,%r13,4), %rax
imulq $0x18, %rax, %rdi
addq (%rbx), %rdi
movl %r12d, 0xc(%rsp)
movq %r14, %rsi
callq 0x96a4
incq %r13
jmp 0xc8a7
incq %r12
jmp 0xc885
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
movl %eax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdge(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdge(vector<int> & edge)
{
	edge_node.push_back(edge);
	unsigned int ind = edge_node.size() - 1;
	for (unsigned int i = 0; i < edge.size(); ++i)
		node_edge[edge[i]].push_back(ind);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xec92
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
decl %r15d
xorl %eax, %eax
leaq 0xc(%rsp), %r12
movl %eax, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0xc979
movslq (%rax,%r13,4), %rax
imulq $0x18, %rax, %rdi
addq (%r14), %rdi
movl %r15d, 0xc(%rsp)
movq %r12, %rsi
callq 0x96a4
leal 0x1(%r13), %eax
jmp 0xc945
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdgeD(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdgeD(vector<int> & edge)
{
    edge_node.push_back(edge);
    int ind = edge_node.size() - 1;
    for (unsigned int i = 0; i < edge.size(); ++i){
        node_edge[edge[i]].push_back(ind);
    	if (node_edge[edge[i]].size() > maxDegree)
    		maxDegree = node_edge[edge[i]].size();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xec92
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
decl %eax
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movq (%rbx), %rax
xorl %r12d, %r12d
movl %r12d, %r12d
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0xca12
movslq (%rax,%r12,4), %rax
imulq $0x18, %rax, %rdi
addq (%r14), %rdi
movq %r15, %rsi
callq 0xac10
movq (%rbx), %rax
movslq (%rax,%r12,4), %rcx
movq (%r14), %rdx
imulq $0x18, %rcx, %rsi
movq 0x8(%rdx,%rsi), %rcx
subq (%rdx,%rsi), %rcx
sarq $0x2, %rcx
movl 0x34(%r14), %edx
cmpq %rdx, %rcx
jbe 0xca0d
movl %ecx, 0x34(%r14)
incl %r12d
jmp 0xc9bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::clearEdges()
void HyperGraph::clearEdges()
{
    edge_node.clear();
    node_edge.clear();
    cout << "clear edges!" << endl;
    maxDegree = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0xecbe
movq %rbx, %rdi
callq 0xecbe
movq 0xf548(%rip), %rdi      # 0x1bfc8
leaq 0x6bf9(%rip), %rsi      # 0x13680
callq 0x3360
movq %rax, %rdi
callq 0x3190
andl $0x0, 0x34(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::pollingLT(Graph&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int, std::vector<bool, std::allocator<bool>>&, std::vector<int, std::allocator<int>>&, sampler<int>&, int)
bool HyperGraph::pollingLT(Graph &g, vector<unsigned int> & link, unsigned int k, vector<bool> &visit, vector<int> &visit_mark, sampler<int> &samp, int p)
{
    unsigned int i;
    bool t = false;
    unsigned int gSize = g.getSize();
    // unsigned int cur = sfmt_genrand_uint32(&sfmtSeed)%gSize+1;
    unsigned cur = samp();
    unsigned int num_marked = 0;
    // cout << "startLT: " << cur << endl;
    for (i = 0; i < gSize; ++i){
    	if (link[cur] < k){
            t=true;
    		break;
        }
        if (visit[cur] == true) break;
        visit[cur] = true;
        visit_mark[num_marked] = cur;
    	num_marked++;
    	int ind;

        ind = randIndex_lin(g, g.weights[cur],g.inv_node_deg[cur], cur, p);
        if (g.weights[cur].size() >= 32)
        //     ind = randIndex_bin(g, g.weights[cur],g.inv_node_deg[cur], cur, p);
        // else
        //     ind = randIndex_lin(g, g.weights[cur],g.inv_node_deg[cur], cur, p);
        
        if (ind == -1)
            break;

        // cur = g.invAdjList[cur][ind-1];
        cur = g.invAdjList[cur][ind];
        // cout << cur << endl;
    }
    for (i = 0; i < num_marked; ++i){
        visit[visit_mark[i]]=false;
    }
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movl %ecx, 0x4(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x60(%rsp), %rdi
movl 0x9c8(%rsi), %eax
movq %rax, 0x10(%rsp)
callq 0xecc6
movl %eax, %r13d
xorl %r15d, %r15d
cmpq %r15, 0x10(%rsp)
je 0xcb92
movl %r13d, %ebp
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rsp), %ecx
cmpl %ecx, (%rax,%rbp,4)
jb 0xcb9b
movq %r14, %rdi
movq %rbp, %rsi
callq 0x85d6
testq %rdx, (%rax)
jne 0xcba3
movq %r14, %rdi
movq %rbp, %rsi
callq 0x85d6
orq %rdx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %r13d, (%rax,%r15,4)
imulq $0x18, %rbp, %rbx
movq 0xaa0(%r12), %rdx
addq %rbx, %rdx
movq 0xa70(%r12), %rax
movl (%rax,%rbp,4), %ecx
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movl %r13d, %r8d
movl 0x68(%rsp), %r9d
callq 0xed9c
cmpl $-0x1, %eax
jne 0xcb78
movq 0xaa0(%r12), %rcx
movq 0x8(%rcx,%rbx), %rdx
subq (%rcx,%rbx), %rdx
cmpq $0x7c, %rdx
ja 0xcba0
movq 0xa88(%r12), %rcx
cltq
movq (%rcx,%rbx), %rcx
movl (%rcx,%rax,4), %r13d
incq %r15
jmp 0xcadc
xorl %ebp, %ebp
movq 0x10(%rsp), %r15
jmp 0xcba5
movb $0x1, %bpl
jmp 0xcba5
incl %r15d
xorl %ebp, %ebp
movl %r15d, %ebx
xorl %r15d, %r15d
movq 0x8(%rsp), %r12
cmpq %r15, %rbx
je 0xcbd0
movq (%r12), %rax
movslq (%rax,%r15,4), %rsi
movq %r14, %rdi
callq 0x85d6
notq %rdx
andq %rdx, (%rax)
incq %r15
jmp 0xcbb0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::BFS_IC(int, float**)
void Graph::BFS_IC(int p, float** APc){
    queue<int> myqueue;
    vector<bool> visited(getSize() + 1,false);
    for (int seed : seedSets[p]){
        myqueue.push(seed);
        APc[p][seed] += 1;
        visited[seed] = true;
    }
    // (u) ---> (v)
    int u; //current node
    int v; //current node's friend
    while (!myqueue.empty()){
        u = myqueue.front();
        myqueue.pop();
        for (int i = 0; i < node_deg[u]; ++i){
            v = adjList[u][i];
            if (!visited[v] and sfmt_genrand_real1(&sfmtSeed) <= get_AP_IC(u, v, i, p)){
            // if (!visited[v] and sfmt_genrand_real1(&sfmtSeed) < probabilities[u][i] * similarities[v][p]){
                myqueue.push(v);
                APc[p][v] += 1;
                visited[v] = true;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %r14
leaq 0x48(%rsp), %rdi
callq 0xee54
movslq 0x9c8(%r14), %rsi
incq %rsi
movq %rsp, %rdx
movb $0x0, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x840c
movq 0xad0(%r14), %rax
movslq %ebp, %rdx
movq %rdx, 0x8(%rsp)
imulq $0x30, %rdx, %rcx
leaq (%rax,%rcx), %rbx
addq $0x8, %rbx
movq 0x10(%rbx), %r13
movq %rsp, %r12
leaq 0x20(%rsp), %r15
cmpq %rbx, %r13
je 0xd7d6
movl 0x20(%r13), %eax
movl %eax, (%rsp)
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x10694
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rsi
movss (%rax,%rsi,4), %xmm0
addss 0x58d3(%rip), %xmm0     # 0x1308c
movss %xmm0, (%rax,%rsi,4)
movq %r15, %rdi
callq 0x85d6
orq %rdx, (%rax)
movq %r13, %rdi
callq 0x33a0
movq %rax, %r13
jmp 0xd781
leaq 0x20(%rsp), %r12
movq 0x58(%rsp), %rax
cmpq %rax, 0x78(%rsp)
je 0xd8a0
movslq (%rax), %r13
leaq 0x48(%rsp), %rdi
callq 0x108bc
imulq $0x18, %r13, %rbx
xorl %r15d, %r15d
movq 0xa20(%r14), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r15
jge 0xd7db
movq 0x9d8(%r14), %rax
movq (%rax,%rbx), %rax
movslq (%rax,%r15,4), %rsi
movl %esi, (%rsp)
movq %r12, %rdi
callq 0x85d6
testq %rdx, (%rax)
jne 0xd898
movq %r14, %rdi
callq 0xd09d
movl (%rsp), %edx
movq %r14, %rdi
movl %r13d, %esi
movl %r15d, %ecx
movl %ebp, %r8d
movsd %xmm0, 0x18(%rsp)
callq 0xc23c
cvtss2sd %xmm0, %xmm0
ucomisd 0x18(%rsp), %xmm0
jb 0xd898
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x10694
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rsi
movss (%rax,%rsi,4), %xmm0
addss 0x5804(%rip), %xmm0     # 0x1308c
movss %xmm0, (%rax,%rsi,4)
movq %r12, %rdi
callq 0x85d6
orq %rdx, (%rax)
incq %r15
jmp 0xd7ff
leaq 0x20(%rsp), %rdi
callq 0x8470
leaq 0x48(%rsp), %rdi
callq 0xeea2
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xd8e0
jmp 0xd8d3
jmp 0xd8d3
jmp 0xd8d3
jmp 0xd8d3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8470
leaq 0x48(%rsp), %rdi
callq 0xeea2
movq %rbx, %rdi
callq 0x3590