LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::transformLat(double, double)
double GpsBaidu::transformLat(double x, double y)
{
	double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * sqrt(abs(x));
	ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
	ret += (20.0 * sin(y * pi) + 40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0;
	ret += (160.0 * sin(y / 12.0 * pi) + 320 * sin(y * pi / 30.0)) * 2.0 / 3.0;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm1, -0x10(%rbp)
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, -0x30(%rbp)
movsd 0xf6e(%rip), %xmm3      # 0x41f8
addsd %xmm2, %xmm3
movapd %xmm1, %xmm2
mulsd 0xf66(%rip), %xmm2      # 0x4200
addsd %xmm3, %xmm2
movsd 0xf62(%rip), %xmm4      # 0x4208
movapd %xmm1, %xmm3
mulsd %xmm4, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd 0xf52(%rip), %xmm2      # 0x4210
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movapd 0xffe(%rip), %xmm3      # 0x42d0
andpd %xmm0, %xmm3
xorps %xmm1, %xmm1
sqrtsd %xmm3, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, -0x8(%rbp)
mulsd 0xf26(%rip), %xmm0      # 0x4218
mulsd 0xf26(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x18(%rbp)
movapd -0x30(%rbp), %xmm0
mulsd 0xf0f(%rip), %xmm0      # 0x4220
callq 0x2070
movsd 0xf0a(%rip), %xmm1      # 0x4228
mulsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0xec5(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0xece(%rip), %xmm0      # 0x4220
movsd %xmm0, -0x30(%rbp)
callq 0x2070
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0xe92(%rip), %xmm0      # 0x4200
mulsd 0xeaa(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xead(%rip), %xmm0      # 0x4230
movsd -0x18(%rbp), %xmm1
mulsd 0xe98(%rip), %xmm1      # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xe60(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0xe81(%rip), %xmm0      # 0x4238
mulsd 0xe61(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x10(%rbp)
movsd -0x30(%rbp), %xmm0
divsd 0xe6a(%rip), %xmm0      # 0x4240
callq 0x2070
mulsd 0xe65(%rip), %xmm0      # 0x4248
movsd -0x10(%rbp), %xmm1
mulsd 0xe60(%rip), %xmm1      # 0x4250
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xe00(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::transformLon(double, double)
double GpsBaidu::transformLon(double x, double y)
{
	double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt(abs(x));
	ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
	ret += (20.0 * sin(x * pi) + 40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0;
	ret += (150.0 * sin(x / 12.0 * pi) + 300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movapd %xmm0, %xmm5
movapd %xmm0, -0x20(%rbp)
addsd 0xe33(%rip), %xmm0      # 0x4258
movsd 0xde3(%rip), %xmm2      # 0x4210
movapd %xmm5, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm3, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm5, %xmm4
addsd %xmm1, %xmm4
addsd %xmm4, %xmm3
movapd 0xe77(%rip), %xmm0      # 0x42d0
andpd %xmm5, %xmm0
sqrtsd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0xda2(%rip), %xmm0      # 0x4218
mulsd %xmm5, %xmm0
mulsd 0xd9e(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
addsd %xmm0, %xmm0
mulsd 0xd83(%rip), %xmm0      # 0x4220
callq 0x2070
movsd 0xd7e(%rip), %xmm1      # 0x4228
mulsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0xd39(%rip), %xmm0      # 0x4200
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
mulsd 0xd42(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xd0b(%rip), %xmm0      # 0x4200
mulsd 0xd23(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xd26(%rip), %xmm0      # 0x4230
movsd -0x8(%rbp), %xmm1
mulsd 0xd11(%rip), %xmm1      # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xcd9(%rip), %xmm0      # 0x4200
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xcfa(%rip), %xmm0      # 0x4238
mulsd 0xcda(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xce3(%rip), %xmm0      # 0x4240
mulsd 0xcbb(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xce6(%rip), %xmm0      # 0x4258
movsd -0x8(%rbp), %xmm1
mulsd 0xce1(%rip), %xmm1      # 0x4260
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xc71(%rip), %xmm0      # 0x4200
addsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::gps_transform(double, double, double&, double&)
void GpsBaidu::gps_transform( double wgLat, double wgLon, double& mgLat, double& mgLon)
{
	double dLat = transformLat(wgLon - 105.0, wgLat - 35.0);
	double dLon = transformLon(wgLon - 105.0, wgLat - 35.0);
	double radLat = wgLat / 180.0 * pi;
       	double magic = sin(radLat);
	magic = 1 - ee * magic * magic;
       	double sqrtMagic = sqrt(magic);
	dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
	dLon = (dLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi);
	mgLat = wgLat + dLat;
       	mgLon = wgLon + dLon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, -0x38(%rbp)
movsd 0xcb0(%rip), %xmm2      # 0x4268
movsd %xmm1, -0x40(%rbp)
addsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xca2(%rip), %xmm1      # 0x4270
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movapd %xmm2, %xmm0
callq 0x3268
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x340c
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
divsd 0xc72(%rip), %xmm0      # 0x4278
mulsd 0xc12(%rip), %xmm0      # 0x4220
movsd %xmm0, -0x28(%rbp)
callq 0x2070
movsd 0xc60(%rip), %xmm3      # 0x4280
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd 0xc58(%rip), %xmm3      # 0x4288
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0x3643
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x3656
movapd %xmm3, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x2160
movsd -0x20(%rbp), %xmm3
movsd 0xc1a(%rip), %xmm1      # 0x4278
movsd -0x30(%rbp), %xmm2
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm4
mulsd %xmm0, %xmm3
movsd 0xc19(%rip), %xmm2      # 0x4290
divsd %xmm3, %xmm2
mulsd 0xb9d(%rip), %xmm2      # 0x4220
divsd %xmm2, %xmm4
movsd %xmm4, -0x30(%rbp)
movsd -0x18(%rbp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xbf6(%rip), %xmm1      # 0x4298
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x22d0
mulsd -0x20(%rbp), %xmm0
mulsd 0xb5e(%rip), %xmm0      # 0x4220
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, (%r14)
addsd -0x40(%rbp), %xmm1
movsd %xmm1, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::bd_encrypt(double, double, double&, double&)
void GpsBaidu::bd_encrypt(double gg_lat, double gg_lon, double &bd_lat, double &bd_lon)
{
	double x = gg_lon, y = gg_lat;
	double z = sqrt(x * x + y * y) + 0.00002 * sin(y * x_pi);
	double theta = atan2(y, x) + 0.000003 * cos(x * x_pi);
	bd_lon = z * cos(theta) + 0.0065;
	bd_lat = z * sin(theta) + 0.006;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm1, -0x18(%rbp)
movapd %xmm0, %xmm3
movsd %xmm0, -0x28(%rbp)
mulsd %xmm0, %xmm0
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
movsd %xmm0, -0x20(%rbp)
mulsd 0xb71(%rip), %xmm3      # 0x42a0
movapd %xmm3, %xmm0
callq 0x2070
mulsd 0xb68(%rip), %xmm0      # 0x42a8
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x2060
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0xb35(%rip), %xmm0      # 0x42a0
callq 0x22d0
mulsd 0xb38(%rip), %xmm0      # 0x42b0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x22d0
mulsd -0x20(%rbp), %xmm0
addsd 0xb24(%rip), %xmm0      # 0x42b8
movsd %xmm0, (%r14)
movsd -0x18(%rbp), %xmm0
callq 0x2070
mulsd -0x20(%rbp), %xmm0
addsd 0xb10(%rip), %xmm0      # 0x42c0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/./hypergraph.hpp
// Function: addHyperedge(Graph&, HyperGraph&, int, long long, bool, sampler<int>&, int)
long long addHyperedge(Graph & g, HyperGraph & hg, int t, long long num, bool lt, sampler<int> &samp, int p)
{
	int numNodes = g.getSize();

	omp_set_num_threads(t);
	
	long long iter = 0;
	int c = 100;
	// cout << "@@@@@@@@@@ 1" << endl;
    #pragma omp parallel
	{
		vector<int> visit_mark(numNodes+1,0);
		vector<bool> visit(numNodes+1,false);
		vector<unsigned int> link;
		// cout << "@@@@@@@@@@ 2" << endl;     
		if (lt == 0){
			while (iter < num){
				// cout << "@@@@@@@@@@ 3" << endl;
            	for (int i = 0; i < c; ++i){
					vector<int> he;
           	        hg.pollingLT1(g,visit,visit_mark, samp, p);
               	}
               	// cout << "@@@@@@@@@@ 4" << endl;
				#pragma omp atomic
				iter += c;
			}
		} else {
			while (iter < num){
                for (int i = 0; i < c; ++i){
                    vector<int> he;
                    hg.pollingIC1(g,visit,visit_mark, samp, p);
                }
                #pragma omp atomic
                iter += c;
        	}
		}
	}
	// cout << "@@@@@@@@@@ 5" << endl;
	hg.updateDeg();
	// cout << "@@@@@@@@@@ 6" << endl;
	return hg.getNumEdge();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movl %r8d, %r13d
movq %rcx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
callq 0xdfbe
incl %eax
movslq %eax, %r15
leaq 0x30(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x6(%rsp), %rbp
movq %r15, %rsi
movq %rbp, %rcx
callq 0xa214
movb $0x0, (%rbp)
leaq 0x30(%rsp), %rdi
leaq 0x6(%rsp), %rdx
leaq 0x7(%rsp), %rcx
movq %r15, %rsi
callq 0xa390
movl 0x90(%rsp), %ebp
testb %r13b, %r13b
je 0x3a31
cmpq $0x0, 0x10(%rsp)
jle 0x3a80
movq $0x0, 0x8(%rsp)
leaq 0x18(%rsp), %r15
movl $0x64, %r13d
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x30(%rsp), %rdx
movq %r15, %rcx
movq %r14, %r8
movl %ebp, %r9d
callq 0xfac0
decl %r13d
jne 0x39fc
movq 0x8(%rsp), %rcx
addq $0x64, %rcx
movq %rcx, 0x8(%rsp)
cmpq 0x10(%rsp), %rcx
jl 0x39f6
jmp 0x3a80
cmpq $0x0, 0x10(%rsp)
jle 0x3a80
movq $0x0, 0x8(%rsp)
leaq 0x18(%rsp), %r15
movl $0x64, %r13d
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x30(%rsp), %rdx
movq %r15, %rcx
movq %r14, %r8
movl %ebp, %r9d
callq 0xf55a
decl %r13d
jne 0x3a4d
movq 0x8(%rsp), %rcx
addq $0x64, %rcx
movq %rcx, 0x8(%rsp)
cmpq 0x10(%rsp), %rcx
jl 0x3a47
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3a8f
callq 0x3340
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3a9e
callq 0x3340
movq %rbx, %rdi
callq 0xefd8
movq %rbx, %rdi
callq 0xf262
cltq
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3ad8
jmp 0x3ac6
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3ad8
callq 0x3340
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3ae7
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %r14
callq 0xdfbe
testl %eax, %eax
jle 0x55c4
movslq %ebp, %r15
movl $0x1, %r12d
movq 0xaf8(%r14), %rax
leaq (%r12,%r12,2), %r13
movq %r13, %rcx
shlq $0x4, %rcx
movq 0x18(%rax,%rcx), %rax
movl 0x28(%rax), %ecx
movsd 0x11b55(%rip), %xmm0    # 0x17070
cmpl %ebp, %ecx
je 0x5571
movq 0xb18(%r14), %rbx
movss 0x11b8e(%rip), %xmm0    # 0x170bc
movslq %ecx, %rcx
movq (%rbx,%rcx,8), %rcx
movss 0x11b7f(%rip), %xmm1    # 0x170bc
subss (%rcx,%r12,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %rax, %rdi
callq 0x3250
movss 0xc(%rsp), %xmm0
movl 0x28(%rax), %ecx
cmpl %ebp, %ecx
je 0x556d
ucomiss 0x11b5f(%rip), %xmm0    # 0x170c8
jne 0x552e
jp 0x552e
cvtss2sd %xmm0, %xmm0
movq 0xae0(%r14), %rax
movq 0xb00(%r14), %rcx
movq (%rax,%r13,8), %rax
movsd (%rax,%r15,8), %xmm1
divsd (%rcx,%r15,8), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss %xmm0, -0x4(%rax,%r12,4)
leaq 0x1(%r12), %rbx
movq %r14, %rdi
callq 0xdfbe
cltq
cmpq %rax, %r12
movq %rbx, %r12
jl 0x54f9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movq 0xad0(%rdi), %rax
movslq %edx, %rcx
movq %rcx, 0x8(%rsp)
leaq (%rcx,%rcx,2), %rbp
shlq $0x4, %rbp
leaq (%rax,%rbp), %r13
addq $0x8, %r13
movq 0x10(%r13), %rdi
xorl %r12d, %r12d
movq %r13, 0x10(%rsp)
movl 0x20(%rdi), %r15d
movq 0xad8(%rbx), %rax
leaq (%rax,%rbp), %r14
addq $0x8, %r14
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x5656
movq %r14, %rdx
xorl %esi, %esi
cmpl %r15d, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x5633
cmpq %r14, %rdx
je 0x5656
cmpl 0x20(%rdx), %r15d
jge 0x56b4
movl %r12d, (%rsp)
addq %rbp, %rax
movq 0x18(%rax), %r12
cmpq %r14, %r12
je 0x56a8
movq %rdi, 0x18(%rsp)
movl 0x20(%r12), %edx
movq 0x20(%rsp), %rdi
movl %r15d, %esi
callq 0xce14
movl %eax, %r13d
testb %al, %al
jne 0x5694
movq %r12, %rdi
callq 0x33c0
movq %rax, %r12
cmpq %r14, %rax
jne 0x566b
xorb $0x1, %r13b
movzbl %r13b, %eax
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rdi
jmp 0x56ad
movl $0x1, %eax
movl (%rsp), %r12d
addl %eax, %r12d
callq 0x33c0
movq %rax, %rdi
cmpq %r13, %rax
jne 0x5614
movq 0x8(%rsp), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r14
movq 0xad8(%rbx), %rdi
addq %r14, %rdi
callq 0xbc94
movq 0xad0(%rbx), %rax
movq 0x18(%rax,%r14), %r15
leaq 0x4(%rsp), %r14
movl 0x20(%r15), %eax
movl %eax, 0x4(%rsp)
movq 0xad8(%rbx), %rdi
addq %rbp, %rdi
movq %r14, %rsi
callq 0xbcf8
movq %r15, %rdi
callq 0x33c0
movq %rax, %r15
jmp 0x56f2
// File: /workspace/github_cpp_makefile_star2_O3/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 %r8, (%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x8(%rsi)
je 0x5bfd
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsp), %rax
leal 0x1(%rax), %ebp
xorl %r12d, %r12d
movq %rsi, 0x20(%rsp)
movl $0x2, %ecx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3380
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
movq %rbp, %r13
movq %r12, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5b49
callq 0x3340
cmpl $0x0, (%rsp)
js 0x5be2
movq 0x8(%rsp), %rax
leaq (,%rax,4), %rax
leaq (%rax,%rax,2), %r12
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %rbp
addq 0x18(%rsp), %r12
xorl %r14d, %r14d
movq (%rbp), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x3520
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x11559(%rip), %rsi     # 0x170f2
callq 0x33b0
movq (%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %r15, %rdi
callq 0x3520
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
incq %r14
cmpq %r14, %r13
jne 0x5b75
movq 0x8(%rsp), %r12
addq $0x2, %r12
movq 0x20(%rsp), %r14
cmpq %r12, 0x8(%r14)
movq %r13, %rbp
ja 0x5adc
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5c23
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
cmpq $0x0, 0x8(%rcx)
je 0x6b8a
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x10, %r13d
movl $0x2, %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3380
movq %rbp, %rdi
leaq 0x10678(%rip), %rsi     # 0x170eb
callq 0x3100
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6a8e
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x10, 0x10(%r15,%rax)
testl %ebp, %ebp
je 0x6adf
movl $0x2, %ecx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3380
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x33b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6af3
callq 0x3340
jmp 0x6af3
movl $0x3, %edx
movq %r15, %rdi
leaq 0x10600(%rip), %rsi     # 0x170ee
callq 0x33b0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq (%r14), %rax
movq (%rax,%r12,4), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x3520
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
movq 0x8(%r14), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x3520
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
movq 0x10(%r14), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x3520
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
addq $0x2, %r12
cmpq %r12, 0x8(%rbx)
ja 0x6a51
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6bb0
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa501
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 0xb36a
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
sete %sil
movq %rax, %rdx
addq $0x4, %rdx
cmpq %rcx, %rdx
sete %dil
orb %sil, %dil
jne 0xa48e
movl (%rax), %esi
movl (%rdx), %edi
cmpl %edi, %esi
cmovlel %edi, %esi
cmovlq %rdx, %rax
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0xa47a
movl (%rax), %eax
movl 0x30(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
addl $0x3, %ecx
movslq %ecx, %rsi
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0xb39c
movl 0x30(%rbx), %eax
testl %eax, %eax
jle 0xa4db
movq (%r15), %rcx
movq (%rbx), %rdx
movq 0x18(%rbx), %rsi
xorl %edi, %edi
movslq (%rcx,%rdi,4), %rax
movl %eax, 0x4(%rdx,%rdi,4)
incq %rdi
movl %edi, (%rsi,%rax,4)
movslq 0x30(%rbx), %rax
cmpq %rax, %rdi
jl 0xa4c4
leal 0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0xa508
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb3d0
decq %r15
jne 0xa4ef
jmp 0xa508
movl $0x0, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa516
jmp 0xa516
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa526
callq 0x3340
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa533
callq 0x3340
movq %r15, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %esi, %eax
leal (%rax,%rax), %r8d
movl 0x30(%rdi), %r10d
cmpl %r10d, %r8d
jg 0xb459
pushq %rbp
pushq %rbx
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
cmpl %r10d, %r8d
jge 0xb410
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 0xb413
movl %r8d, %r9d
movslq %eax, %r10
movslq %r9d, %r8
movslq (%rcx,%r10,4), %r11
movl (%rsi,%r11,4), %ebp
movslq (%rcx,%r8,4), %rbx
cmpl (%rsi,%rbx,4), %ebp
jge 0xb457
movl (%rdx,%r11,4), %eax
movl (%rdx,%rbx,4), %ebp
movl %ebp, (%rdx,%r11,4)
movl %eax, (%rdx,%rbx,4)
movl (%rcx,%r10,4), %eax
movl (%rcx,%r8,4), %r11d
movl %r11d, (%rcx,%r10,4)
movl %eax, (%rcx,%r8,4)
addl %r8d, %r8d
movl 0x30(%rdi), %r10d
movl %r9d, %eax
cmpl %r10d, %r8d
jle 0xb3ec
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl $0x2, %esi
jl 0xbc3f
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
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 0xbc3a
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)
cmpl $0x3, %edi
ja 0xbc04
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xabd9(%rip), %xmm0     # 0x17540
mulsd %xmm0, %xmm4
movsd 0xabd5(%rip), %xmm2     # 0x17548
divsd %xmm2, %xmm4
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rsp)
mulsd 0xabbf(%rip), %xmm4     # 0x17550
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 0xab7b(%rip), %xmm0     # 0x17540
divsd 0xab7b(%rip), %xmm0     # 0x17548
callq 0x3630
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
mulsd 0xab5b(%rip), %xmm0     # 0x17540
divsd 0xab5b(%rip), %xmm0     # 0x17548
callq 0x3630
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0xab45(%rip), %xmm0     # 0x17550
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 0xca53
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
jmp 0xca70
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x32c0
xorpd %xmm3, %xmm3
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0xa5f8(%rip), %xmm0     # 0x17070
subsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0xca8b
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xcaa0
movsd %xmm2, 0x10(%rsp)
callq 0x32c0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x3080
addsd %xmm0, %xmm0
mulsd 0xaaa3(%rip), %xmm0     # 0x17558
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%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 0xced0
movq %rsp, %rdi
movq %rax, %rsi
callq 0xa5c2
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0xce98
sarq $0x2, %rax
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
movb $0x1, %bpl
cmpl %ebx, (%rdi)
je 0xce9f
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rcx
je 0xce8f
leaq 0x1(%rdx), %rsi
cmpl %ebx, (%rdi,%rdx,4)
jne 0xce7e
cmpq %rdx, %rax
seta %bpl
jmp 0xce9f
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xcea4
callq 0x3340
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xcebe
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movslq %esi, %r13
leaq (,%r13,8), %rdi
testl %r13d, %r13d
movq $-0x1, %rax
cmovsq %rax, %rdi
leaq (,%r13,4), %r12
cmovsq %rax, %r12
callq 0x3030
movq %rax, %r15
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
testl %r13d, %r13d
jle 0xd509
movl %r14d, %r13d
leaq (,%r13,4), %rdx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x31c0
leal 0x1(%r14), %eax
decq %r13
movq %r13, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %eax
shlq $0x4, %rax
movdqa 0x9bb4(%rip), %xmm1     # 0x17020
movdqa 0x9bbc(%rip), %xmm2     # 0x17030
pxor %xmm2, %xmm0
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
pcmpeqd %xmm3, %xmm3
movdqa 0xa202(%rip), %xmm4     # 0x17690
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0xd4c3
movq %rcx, (%r15,%r12)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0xd4d6
movq %rcx, 0x8(%r15,%r12)
paddq %xmm4, %xmm1
addq $0x10, %r12
cmpq %r12, %rax
jne 0xd48e
testl %r14d, %r14d
jle 0xd509
movl %r14d, %eax
addl $-0x2, %eax
shrl $0x1f, %eax
leal (%r14,%rax), %ebp
addl $-0x2, %ebp
sarl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd526
addl $-0x1, %ebp
jb 0xd4fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leal 0x1(,%rsi,2), %r10d
movl 0x10(%rdi), %r9d
movslq %esi, %rdx
movl %esi, %r8d
cmpl %r9d, %r10d
jge 0xd55a
movslq %r10d, %r8
movsd (%rax,%r8,8), %xmm0
ucomisd (%rax,%rdx,8), %xmm0
movl %esi, %r8d
jbe 0xd55a
movl %r10d, %r8d
leal 0x2(,%rsi,2), %r10d
cmpl %r9d, %r10d
jge 0xd57e
movslq %r10d, %r9
movsd (%rax,%r9,8), %xmm0
movslq %r8d, %r9
ucomisd (%rax,%r9,8), %xmm0
jbe 0xd57e
movl %r10d, %r8d
cmpl %esi, %r8d
je 0xd5b2
movslq %r8d, %rsi
movsd (%rax,%rsi,8), %xmm0
movl (%rcx,%rsi,4), %r9d
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, (%rax,%rsi,8)
movl (%rcx,%rdx,4), %r10d
movl %r10d, (%rcx,%rsi,4)
movsd %xmm0, (%rax,%rdx,8)
movl %r9d, (%rcx,%rdx,4)
movl %r8d, %esi
jmp 0xd52d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
jle 0xd64b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leal -0x1(%rsi), %edi
shrl $0x1f, %edi
movl %esi, %edx
addl %edi, %esi
decl %esi
sarl %esi
movslq %esi, %rdi
movsd (%rax,%rdi,8), %xmm0
movsd (%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd64b
movl (%rcx,%rdi,4), %r8d
movsd %xmm1, (%rax,%rdi,8)
movl (%rcx,%rdx,4), %r9d
movl %r9d, (%rcx,%rdi,4)
movsd %xmm0, (%rax,%rdx,8)
movl %r8d, (%rcx,%rdx,4)
cmpl $0x2, %edx
jg 0xd60b
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq 0x108d9(%rip), %rdi     # 0x1dfd0
leaq 0x9fa2(%rip), %rsi      # 0x176a0
movl $0x1, %edx
callq 0x33b0
cmpl $0x0, 0x10(%r14)
jle 0xd78b
xorl %r12d, %r12d
movq 0x108b7(%rip), %r15     # 0x1dfd0
leaq 0x9f83(%rip), %r13      # 0x176a3
leaq 0x9f7b(%rip), %rbp      # 0x176a2
movl $0x1, %edx
movq %r15, %rdi
leaq 0x9b8e(%rip), %rsi      # 0x172c4
callq 0x33b0
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %r15, %rdi
callq 0x3520
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33b0
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x35b0
movl $0x3, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x33b0
incq %r12
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0xd727
leaq 0x9983(%rip), %rsi      # 0x17115
movl $0x1, %edx
movq 0x10832(%rip), %rbx     # 0x1dfd0
movq %rbx, %rdi
callq 0x33b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe437
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xe42f
addq $-0x30, %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
leaq (%r15,%r12), %rdi
callq 0x12ace
addq $-0x30, %r12
jne 0xe420
movq %r14, %rdi
callq 0x3410
movq 0xad8(%rbx), %r15
testq %r15, %r15
je 0xe473
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xe46b
addq $-0x30, %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
leaq (%r15,%r12), %rdi
callq 0x12ace
addq $-0x30, %r12
jne 0xe45c
movq %r14, %rdi
callq 0x3410
movl 0x9d0(%rbx), %eax
testl %eax, %eax
jle 0xe4a6
xorl %r14d, %r14d
movq 0xb18(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xe49b
callq 0x3410
movl 0x9d0(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0xe480
movq 0xb18(%rbx), %rdi
testq %rdi, %rdi
je 0xe4b7
callq 0x3410
movq 0xb00(%rbx), %rdi
testq %rdi, %rdi
je 0xe4c8
callq 0x3340
leaq 0xae0(%rbx), %rdi
callq 0x126a6
movq 0xab8(%rbx), %rdi
testq %rdi, %rdi
je 0xe4e5
callq 0x3340
leaq 0xaa0(%rbx), %rdi
callq 0x126ec
leaq 0xa88(%rbx), %rdi
callq 0xad82
movq 0xa70(%rbx), %rdi
testq %rdi, %rdi
je 0xe50e
callq 0x3340
leaq 0xa38(%rbx), %rdi
callq 0xb344
movq 0xa20(%rbx), %rdi
testq %rdi, %rdi
je 0xe52b
callq 0x3340
leaq 0xa08(%rbx), %rdi
callq 0x126ec
leaq 0x9f0(%rbx), %rdi
callq 0x126ec
addq $0x9d8, %rbx            # imm = 0x9D8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xad82
movq %rax, %rdi
callq 0xad76
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %r15
movl $0x30, %ecx
movq %r15, %rax
mulq %rcx
seto %cl
orq $0x8, %rax
movl %r15d, 0x9d0(%rdi)
movq $-0x1, %r12
testb %cl, %cl
cmoveq %rax, %r12
movq %r12, %rdi
callq 0x3030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testq %r15, %r15
je 0xe646
addq $0x10, %rax
movq %r15, %r13
shlq $0x4, %r13
leaq (,%r13,2), %rdx
addq %r13, %rdx
xorl %esi, %esi
movl $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rsi, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0xe5da
movq %rcx, 0xad0(%rbx)
movq %r12, %rdi
callq 0x3030
movq %rax, %rcx
movq %r15, (%rax)
addq $0x8, %rax
addq $0x10, %rcx
leaq (,%r13,2), %rdx
addq %r13, %rdx
xorl %esi, %esi
movl $0x0, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rsi, 0x20(%rcx)
addq $0x30, %rcx
addq $-0x30, %rdx
jne 0xe624
jmp 0xe65c
movq %rcx, 0xad0(%rbx)
movq %r12, %rdi
callq 0x3030
movq %r15, (%rax)
addq $0x8, %rax
movq %rax, 0xad8(%rbx)
leaq 0xb00(%rbx), %rdi
movq 0xb00(%rbx), %rax
cmpq %rax, 0xb08(%rbx)
je 0xe681
movq %rax, 0xb08(%rbx)
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rsi
callq 0x12732
movl 0x9c8(%rbx), %r12d
testl %r12d, %r12d
jle 0xe6cf
movl $0x18, %r15d
xorl %r13d, %r13d
movq 0xae0(%rbx), %rdi
addq %r15, %rdi
movslq (%r14), %rsi
callq 0x12766
movslq 0x9c8(%rbx), %r12
incq %r13
addq $0x18, %r15
cmpq %r12, %r13
jl 0xe6aa
movslq (%r14), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x3030
movq %rax, 0xb18(%rbx)
testq %r15, %r15
jle 0xe729
movslq %r12d, %rax
leaq 0x4(,%rax,4), %r14
cmpl $-0x1, %eax
cmovlq %r13, %r14
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3030
movq 0xb18(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xe70e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe785
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xe77d
addq $-0x30, %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
leaq (%r12,%r13), %rdi
callq 0x12ace
addq $-0x30, %r13
jne 0xe76e
movq %r15, %rdi
callq 0x3410
movq 0xad8(%r14), %r12
testq %r12, %r12
je 0xe7c3
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xe7bb
addq $-0x30, %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
leaq (%r12,%r13), %rdi
callq 0x12ace
addq $-0x30, %r13
jne 0xe7ac
movq %r15, %rdi
callq 0x3410
movl 0x9d0(%r14), %eax
testl %eax, %eax
jle 0xe7f8
xorl %r15d, %r15d
movq 0xb18(%r14), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0xe7ed
callq 0x3410
movl 0x9d0(%r14), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xe7d1
movq 0xb18(%r14), %rdi
testq %rdi, %rdi
je 0xe809
callq 0x3410
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe56e
nop
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::rand_graph(float, float)
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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x1, 0x20(%rsp)
movss %xmm0, 0x10(%rsp)
movss %xmm1, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movb $0x0, 0x1c(%rsp)
cmpl $0x0, 0x9c8(%rdi)
je 0xef0d
movq %rdi, %rbx
movq 0xa20(%rdi), %rax
movl $0x1, %r13d
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x3, %rdi
addq 0x9f0(%rbx), %rdi
movslq (%rax,%r13,4), %rsi
callq 0x125f2
movq 0xa20(%rbx), %rax
cmpl $0x0, (%rax,%r13,4)
jle 0xeebd
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13492
movss %xmm0, 0xc(%rsp)
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xee36
movl $0x0, 0xc(%rsp)
xorps %xmm0, %xmm0
jmp 0xee4f
ucomiss 0x827f(%rip), %xmm0     # 0x170bc
jbe 0xee4f
movl $0x3f800000, 0xc(%rsp)  # imm = 0x3F800000
movss 0x826d(%rip), %xmm0     # 0x170bc
movq 0x9f0(%rbx), %rax
movq (%rax,%rbp), %rax
movss %xmm0, (%rax,%r12,4)
movq 0x9d8(%rbx), %rax
movq 0xaa0(%rbx), %rcx
movq (%rax,%rbp), %rax
movslq (%rax,%r12,4), %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xee9c
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xeea6
leaq 0xc(%rsp), %rdx
callq 0x136c6
incq %r12
movq 0xa20(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r12
jl 0xee0d
leaq 0x1(%r13), %rdx
movl 0x9c8(%rbx), %ecx
cmpq %rcx, %r13
movq %rdx, %r13
jb 0xedcd
testl %ecx, %ecx
je 0xef0d
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0xaa0(%rbx), %rdi
addq %r14, %rdi
movq 0xa70(%rbx), %rax
movslq 0x4(%rax,%r15,4), %rsi
callq 0x125f2
movl 0x9c8(%rbx), %eax
incq %r15
addq $0x18, %r14
cmpq %rax, %r15
jb 0xeee0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe935
cvtss2sd %xmm0, %xmm0
movslq %esi, %rax
movq 0xae0(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rcx,%rax,8), %rax
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %r13
movl %ecx, 0x14(%rsp)
movl %ecx, %esi
movq %rdx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, %rcx
callq 0xeab8
movsd %xmm0, 0x30(%rsp)
cmpl $0x0, 0x9c8(%r13)
jle 0xeaa9
movl 0x14(%rsp), %eax
movq %rax, 0x20(%rsp)
movl $0x1, %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rbp
movq 0x20(%rsp), %r14
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0xaf8(%r13), %rdi
movq %rax, 0x40(%rsp)
addq %rax, %rdi
callq 0x13350
cmpl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rcx
leaq 0x7(%rsp), %rbx
jle 0xea8b
movq 0x8(%rsp), %rax
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x38(%rsp)
xorl %r15d, %r15d
movq (%rcx), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%rbp), %rax
movq (%rax,%r15,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x30(%rsp), %xmm4
callq 0xcacc
movq 0xae0(%r13), %rax
movq 0x38(%rsp), %r12
movq (%rax,%r12), %rax
movsd %xmm0, (%rax,%r15,8)
movq 0xaf8(%r13), %rdi
addq 0x40(%rsp), %rdi
xorps 0x8c7e(%rip), %xmm0     # 0x176c0
movlps %xmm0, 0x48(%rsp)
movl %r15d, 0x50(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x133b4
movq 0xae0(%r13), %rax
movq 0xb00(%r13), %rcx
movq (%rax,%r12), %rax
movsd (%rax,%r15,8), %xmm0
addsd (%rcx,%r15,8), %xmm0
movsd %xmm0, (%rcx,%r15,8)
movq 0x18(%rsp), %rcx
incq %r15
cmpq %r15, %r14
jne 0xe9e5
movq 0x8(%rsp), %rdx
leaq 0x1(%rdx), %rax
movslq 0x9c8(%r13), %rcx
cmpq %rcx, %rdx
movq %rax, 0x8(%rsp)
jl 0xe996
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
jle 0xeb58
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %eax
movq %rax, 0x8(%rsp)
movl 0x9c8(%rdi), %eax
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
leaq 0x7(%rsp), %r12
testl %eax, %eax
jle 0xeb3f
xorl %r13d, %r13d
movsd %xmm0, 0x10(%rsp)
movq (%r14), %rax
movq 0x8(%rax,%r13,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
movq %r12, %rdi
movl $0x4b, %esi
callq 0xc948
maxsd 0x10(%rsp), %xmm0
movslq 0x9c8(%r15), %rax
incq %r13
cmpq %rax, %r13
jl 0xeaf6
incq %rbp
cmpq 0x8(%rsp), %rbp
jne 0xeaef
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x48, %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 0x30e0
movq %r15, %rdi
movl %eax, %esi
callq 0x16911
leal 0x1(%r14), %esi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1289c
movq 0x10(%rbx), %rax
leaq 0x10(%rsp), %r15
movaps (%r15), %xmm0
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x30(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
callq 0xad82
movq %r15, %rdi
callq 0xad82
movl %r14d, 0x38(%rbx)
movq %r12, 0x30(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xefbb
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0xad82
movq %rbx, %rdi
callq 0xad82
movq %r14, %rdi
callq 0x35c0
nop