LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: set_speed_and_parity(int, int)
void set_speed_and_parity(int fd, int speed)
{
	int i=0;		//设置循环标志——注意不要在for内设置，否则会出错
	struct termios Opt;	//定义termios结构
	if(tcgetattr(fd,&Opt)!=0)
	{
		perror("tcgetattr fd");
		return;
	}
	tcflush(fd, TCIOFLUSH);
	cfsetispeed(&Opt, speed);
	cfsetospeed(&Opt, speed);
	/*tcsetattr函数标志：
	TCSANOW：立即执行而不等待数据发送或者接受完成。
	TCSADRAIN：等待所有数据传递完成后执行。
	TCSAFLUSH：Flush input and output buffers and make the change
	*/
	if(tcsetattr(fd, TCSANOW, &Opt) != 0)
	{	
		perror("tcsetattr fd");
		return;
	}
	tcflush(fd, TCIOFLUSH);
	//设置奇偶校验——默认8个数据位、没有校验位
        
    	Opt.c_cflag &= ~PARENB;
   	 Opt.c_cflag &= ~CSTOPB;
    	Opt.c_cflag &= ~CSIZE;
    	Opt.c_cflag |= CS8;
	
	//其他的一些配置
	//原始输入，输入字符只是被原封不动的接收
	Opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
	//软件流控制无效，因为硬件没有硬件流控制，所以就不需要管了
	Opt.c_iflag &= ~(IXON | IXOFF | IXANY);
	//原始输出方式可以通过在c_oflag中重置OPOST选项来选择：
	Opt.c_oflag |= ~OPOST;
	//VMIN可以指定读取的最小字符数。如果它被设置为0，那么VTIME值则会指定每个字符读取的等待时间。
    	Opt.c_cc[VTIME] = 0;
    	Opt.c_cc[VMIN] = 0;
//    	Opt.c_cflag &= ~INPCK;
//    	Opt.c_cflag |= (CLOCAL | CREAD);
//	
//    	Opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// 
//    	Opt.c_oflag &= ~OPOST;
   	Opt.c_oflag &= ~(ONLCR | OCRNL);    
//
   	Opt.c_iflag &= ~(ICRNL | INLCR);
//    	Opt.c_iflag &= ~(IXON | IXOFF | IXANY);    
//    
//    	Opt.c_cc[VTIME] = 0;
//    	Opt.c_cc[VMIN] = 0;
    
    	tcflush(fd, TCIOFLUSH);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %edi
leaq -0x48(%rbp), %rsi
callq 0x22a0
cmpl $0x0, %eax
je 0x25c7
leaq 0x2adf(%rip), %rdi      # 0x509c
callq 0x21c0
jmp 0x2686
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x2320
movl -0x8(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x2130
movl -0x8(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x2280
movl -0x4(%rbp), %edi
xorl %esi, %esi
leaq -0x48(%rbp), %rdx
callq 0x22c0
cmpl $0x0, %eax
je 0x260d
leaq 0x2aa3(%rip), %rdi      # 0x50a9
callq 0x21c0
jmp 0x2686
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x2320
movl -0x40(%rbp), %eax
andl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
andl $-0x41, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
andl $-0x31, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
andl $-0x1c, %eax
movl %eax, -0x3c(%rbp)
movl -0x48(%rbp), %eax
andl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
orl $-0x2, %eax
movl %eax, -0x44(%rbp)
movb $0x0, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
movl -0x44(%rbp), %eax
andl $-0xd, %eax
movl %eax, -0x44(%rbp)
movl -0x48(%rbp), %eax
andl $0xfffffebf, %eax       # imm = 0xFFFFFEBF
movl %eax, -0x48(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x2320
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: serial_write(int, char*, int)
int serial_write(int fd ,char *data, int datalen)
{
	int len=0;
	//获取实际传输数据的长度
	len=write(fd,data,datalen);
	printf("send data OK! datalen=%d\n",len);
	return len;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x20a0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
leaq 0x29f0(%rip), %rdi      # 0x50b6
movb $0x0, %al
callq 0x2040
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: serial_read(int, char*, int)
int serial_read(int fd,char buff[],int datalen)
{
	int nread=0;
	//printf("Ready for receiving data...");
	nread=read(fd,buff,datalen);
	if(nread>0)
	{
	//	printf("readlength=%d\n",nread);
		buff[nread]='\0';
	//	printf("%s\n",buff);
	}
	return nread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x22d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x271e
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: serialport()
int serialport()
{
	int fd;	
	//打开串口
	if((fd=open_port())<0)
    	{
        	perror("open_port error");
        	return 0;
    	}
	//设置波特率和校验位
	set_speed_and_parity(fd,9600);
	return (fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2520
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0x275a
leaq 0x2984(%rip), %rdi      # 0x50d0
callq 0x21c0
movl $0x0, -0x4(%rbp)
jmp 0x276d
movl -0x8(%rbp), %edi
movl $0x2580, %esi           # imm = 0x2580
callq 0x2590
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: split(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void split(vector<string> &elems, const string& s, const string& delim)
{
	size_t pos = 0;
	size_t len = s.length();
	size_t delim_len = delim.length();
	if (delim_len == 0) return;
	while (pos < len)
	{
		int find_pos = s.find(delim, pos);
		if (find_pos < 0)
		{
			elems.push_back(s.substr(pos, len - pos));
			break;
		}
		elems.push_back(s.substr(pos, find_pos - pos));
		pos = find_pos + delim_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2300
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2300
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x27c5
jmp 0x28cf
jmp 0x27c7
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x28cf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x2856
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2230
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3080
jmp 0x282e
leaq -0x58(%rbp), %rdi
callq 0x2150
jmp 0x28cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2150
jmp 0x28d8
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movslq -0x34(%rbp), %rcx
subq %rdx, %rcx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2230
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3080
jmp 0x2898
leaq -0x88(%rbp), %rdi
callq 0x2150
movslq -0x34(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x27c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2150
jmp 0x28d8
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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 $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0xb4e(%rip), %xmm1      # 0x5258
addsd -0x8(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0xb1c(%rip), %xmm1      # 0x5240
mulsd -0x8(%rbp), %xmm1
movsd -0x8(%rbp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xb02(%rip), %xmm0      # 0x5240
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x4c50
callq 0x21a0
movsd -0x38(%rbp), %xmm1
movsd 0xacf(%rip), %xmm2      # 0x5240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xaaa(%rip), %xmm0      # 0x5230
mulsd -0x8(%rbp), %xmm0
movsd 0xa7d(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
callq 0x2070
movsd %xmm0, -0x30(%rbp)
movsd 0xa47(%rip), %xmm0      # 0x51f0
mulsd -0x8(%rbp), %xmm0
movsd 0xa5a(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
callq 0x2070
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0xa51(%rip), %xmm1      # 0x5220
mulsd %xmm2, %xmm1
movsd 0xa45(%rip), %xmm2      # 0x5220
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xa05(%rip), %xmm1      # 0x51f0
mulsd %xmm1, %xmm0
movsd 0x9f1(%rip), %xmm1      # 0x51e8
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xa03(%rip), %xmm0      # 0x5210
mulsd -0x8(%rbp), %xmm0
callq 0x2070
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x9bf(%rip), %xmm1      # 0x51e8
divsd %xmm1, %xmm0
movsd 0x9db(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
callq 0x2070
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd 0x9da(%rip), %xmm1      # 0x5228
mulsd %xmm2, %xmm1
movsd 0x9c6(%rip), %xmm2      # 0x5220
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x986(%rip), %xmm1      # 0x51f0
mulsd %xmm1, %xmm0
movsd 0x972(%rip), %xmm1      # 0x51e8
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x987(%rip), %xmm1      # 0x5218
divsd %xmm1, %xmm0
movsd 0x973(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
callq 0x2070
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x950(%rip), %xmm1      # 0x5208
divsd %xmm1, %xmm0
movsd 0x94c(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
callq 0x2070
movaps %xmm0, %xmm2
movsd -0x20(%rbp), %xmm0
movsd 0x97b(%rip), %xmm1      # 0x5258
mulsd %xmm2, %xmm1
movsd 0x967(%rip), %xmm2      # 0x5250
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x8f7(%rip), %xmm1      # 0x51f0
mulsd %xmm1, %xmm0
movsd 0x8e3(%rip), %xmm1      # 0x51e8
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x949(%rip), %xmm1      # 0x5290
subsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm1
movsd 0x930(%rip), %xmm2      # 0x5288
subsd %xmm2, %xmm1
callq 0x44b0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x91d(%rip), %xmm1      # 0x5290
subsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm1
movsd 0x904(%rip), %xmm2      # 0x5288
subsd %xmm2, %xmm1
callq 0x46f0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x8c9(%rip), %xmm1      # 0x5268
divsd %xmm1, %xmm0
movsd 0x865(%rip), %xmm1      # 0x5210
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2070
movsd %xmm0, -0x40(%rbp)
movsd 0x8b5(%rip), %xmm0      # 0x5280
mulsd -0x40(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x880(%rip), %xmm1      # 0x5278
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x21a0
movsd %xmm0, -0x48(%rbp)
movsd 0x850(%rip), %xmm0      # 0x5268
mulsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
mulsd -0x48(%rbp), %xmm2
movsd 0x841(%rip), %xmm1      # 0x5270
divsd %xmm2, %xmm1
movsd 0x7d5(%rip), %xmm2      # 0x5210
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x818(%rip), %xmm0      # 0x5268
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x7fe(%rip), %xmm0      # 0x5260
divsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2390
movsd -0x58(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
mulsd %xmm2, %xmm1
movsd 0x781(%rip), %xmm2      # 0x5210
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x21a0
movsd %xmm0, -0x60(%rbp)
movsd 0x784(%rip), %xmm0      # 0x52b0
mulsd -0x30(%rbp), %xmm0
callq 0x2070
movsd -0x60(%rbp), %xmm1
movsd 0x775(%rip), %xmm2      # 0x52b8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x2050
movsd %xmm0, -0x58(%rbp)
movsd 0x744(%rip), %xmm0      # 0x52b0
mulsd -0x28(%rbp), %xmm0
callq 0x2390
movsd -0x58(%rbp), %xmm1
movsd 0x725(%rip), %xmm2      # 0x52a8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x2390
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x6e8(%rip), %xmm1      # 0x52a0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x2070
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x6ac(%rip), %xmm1      # 0x5298
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: suyash[P]chan/examples/tylertreat_chan/unbuffered.cc
// Function: main
int main() {
	chan::unbuffered_chan<std::string> c;

	std::thread t([&](){
		c << "ping";
	});

	std::string message;
	c >> message;

	printf("received: %s\n", message.c_str());

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
leaq -0x120(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x2b40
movq -0x168(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x128(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x25b0
jmp 0x24d1
leaq -0x160(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x2200
movq -0x170(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x2bc0
jmp 0x24f9
leaq -0x160(%rbp), %rdi
callq 0x2090
movq %rax, %rsi
leaq 0x1af5(%rip), %rdi      # 0x4004
xorl %eax, %eax
callq 0x2040
jmp 0x2518
leaq -0x128(%rbp), %rdi
callq 0x2260
jmp 0x2526
leaq -0x160(%rbp), %rdi
callq 0x20f0
leaq -0x128(%rbp), %rdi
callq 0x2bf0
leaq -0x120(%rbp), %rdi
callq 0x2c20
xorl %eax, %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x2593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x20f0
leaq -0x128(%rbp), %rdi
callq 0x2bf0
leaq -0x120(%rbp), %rdi
callq 0x2c20
movq -0x138(%rbp), %rdi
callq 0x2280
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1db70
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jg 0x7e7c
movss 0x2a32a(%rip), %xmm0    # 0x3204c
movss %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0xaf8(%rax), %rdi
movslq 0x34(%rsp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0xf0f0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf120
movl 0x8(%rax), %ecx
xorl %eax, %eax
cmpl 0x4c(%rsp), %ecx
movb %al, 0x23(%rsp)
je 0x7d7b
movss 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x7d85
jmp 0x7ddd
movq 0x50(%rsp), %rax
movq 0xb18(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf120
movq %rax, %rcx
movq 0x18(%rsp), %rax
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x34(%rsp), %rcx
movss 0x2a28f(%rip), %xmm0    # 0x3204c
subss (%rax,%rcx,4), %xmm0
mulss 0x38(%rsp), %xmm0
movss %xmm0, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf150
jmp 0x7d4a
movq 0x50(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x34(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x4c(%rsp), %rsi
callq 0xeb00
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
addq $0xb00, %rdi            # imm = 0xB00
movslq 0x4c(%rsp), %rsi
callq 0xeb00
movsd 0x8(%rsp), %xmm0
divsd (%rax), %xmm0
movss 0x38(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xf1a0
movss 0x14(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x7cfa
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movl %r8d, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x42c0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x8ab2
movq 0x38(%rsp), %rsi
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x2, %ecx
callq 0x4410
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4390
movq %rax, 0x28(%rsp)
jmp 0x89ac
movq 0x28(%rsp), %rdi
movq 0x385f8(%rip), %rsi     # 0x40fb0
callq 0x4430
jmp 0x89bf
leaq 0x50(%rsp), %rdi
callq 0x4260
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x74(%rsp), %eax
jg 0x8aa0
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
movl 0x70(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq 0x40(%rsp), %rsi
callq 0xeb00
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x4730
movq %rax, %rdi
leaq 0x2965b(%rip), %rsi     # 0x32086
callq 0x43f0
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
movl 0x70(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq 0x40(%rsp), %rsi
callq 0xeb00
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x4730
movq %rax, %rdi
movq 0x3853f(%rip), %rsi     # 0x40fb0
callq 0x4430
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x89d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4260
jmp 0x8aba
jmp 0x8aa2
movl 0x70(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x70(%rsp)
jmp 0x8946
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x4690
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdx, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xe2d0
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x38(%rsp)
callq 0xe2d0
movq 0x40(%rsp), %rax
movq 0x90(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x80(%rsp), %rdi
callq 0x126e0
testb $0x1, %al
jne 0xe478
jmp 0xe489
movq 0x40(%rsp), %rax
movl $0x0, 0x30(%rax)
jmp 0xe64b
movq 0x80(%rsp), %rdi
callq 0xe3d0
movq 0x40(%rsp), %rdi
movl %eax, 0x30(%rdi)
movl 0x30(%rdi), %eax
incl %eax
movslq %eax, %rsi
callq 0x12730
jmp 0xe4ad
movq 0x40(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rdi
callq 0x12920
movq %rax, 0x60(%rsp)
movq 0x80(%rsp), %rdi
callq 0x12950
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x128d0
movq %rax, 0x30(%rsp)
jmp 0xe4f5
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x12980
movq 0x40(%rsp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x12890
movq %rax, 0x20(%rsp)
jmp 0xe521
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
addl $0x3, %eax
movslq %eax, %rsi
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
leaq 0x54(%rsp), %rdx
callq 0x127d0
jmp 0xe547
movl $0x0, 0x50(%rsp)
movq 0x40(%rsp), %rcx
movl 0x50(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0xe608
movq 0x80(%rsp), %rdi
movslq 0x50(%rsp), %rsi
callq 0x12990
movq 0x40(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xe3b0
movl 0xc(%rsp), %edx
movq %rax, %rcx
movq 0x40(%rsp), %rax
movl %edx, (%rcx)
movl 0x50(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rsp)
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
movslq 0x50(%rsp), %rsi
callq 0x12990
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0xe54f
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0xe2e0
movq 0x40(%rsp), %rdi
callq 0xe2e0
jmp 0xe653
movq 0x40(%rsp), %rax
movl 0x30(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
movq %rax, 0x48(%rsp)
cmpq $0x1, 0x48(%rsp)
jb 0xe649
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x129b0
jmp 0xe637
jmp 0xe639
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0xe61f
jmp 0xe64b
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x4690
nopl (%rax)
// File: dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::pop()
int MappedHeap<CompareLess>::pop() {
	if (!empty()) {
		int top = heap[1];
		position[heap[1]] = 0;
		heap[1] = heap[n];
		position[heap[1]] = 1;
		n--;
		down_heap(1);
		return top;
	} else {
		cerr << "Error: Cannot pop from an empty heap!" << endl;
		return -1;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe660
testb $0x1, %al
jne 0xe75a
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, (%rsp)
movl $0x1, %esi
callq 0xe3b0
movq (%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movl $0x0, (%rax)
movslq 0x30(%rdi), %rsi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x1, %esi
callq 0xe3b0
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rdi
movl %ecx, (%rax)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movl $0x1, %esi
callq 0xe3b0
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movl $0x1, (%rax)
movl 0x30(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x30(%rdi)
movl $0x1, %esi
callq 0x129b0
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xe784
movq 0x3288f(%rip), %rdi     # 0x40ff0
leaq 0x23bd9(%rip), %rsi     # 0x32341
callq 0x43f0
movq %rax, %rdi
movq 0x32839(%rip), %rsi     # 0x40fb0
callq 0x4430
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movl 0x5c(%rsp), %eax
shll %eax
cmpl 0x30(%rcx), %eax
jg 0x12b3a
movq 0x48(%rsp), %rcx
movl 0x5c(%rsp), %eax
shll %eax
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x30(%rcx), %eax
jg 0x12a4d
movq 0x48(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x38(%rsp)
movslq 0x58(%rsp), %rsi
callq 0xe3b0
movq 0x48(%rsp), %rdi
movq %rax, 0x40(%rsp)
movslq 0x54(%rsp), %rsi
callq 0xe3b0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
callq 0x14250
testb $0x1, %al
jne 0x12a45
jmp 0x12a4d
movl 0x54(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x28(%rsp)
movslq 0x5c(%rsp), %rsi
callq 0xe3b0
movq 0x48(%rsp), %rdi
movq %rax, 0x30(%rsp)
movslq 0x58(%rsp), %rsi
callq 0xe3b0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x14250
testb $0x1, %al
jne 0x12a97
jmp 0x12b33
movq 0x48(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movslq 0x5c(%rsp), %rsi
callq 0xe3b0
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x48(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movslq 0x58(%rsp), %rsi
callq 0xe3b0
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x14290
movq 0x48(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xe3b0
movq 0x48(%rsp), %rdi
movq %rax, 0x20(%rsp)
movslq 0x58(%rsp), %rsi
callq 0xe3b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x14290
movl 0x58(%rsp), %eax
movl %eax, 0x5c(%rsp)
jmp 0x12b35
jmp 0x12b3a
jmp 0x129c7
movl 0x5c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x1, 0x3c(%rsp)
jle 0x14f39
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x38(%rsp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x20(%rsp)
movslq 0x38(%rsp), %rsi
callq 0xe3b0
movq 0x30(%rsp), %rdi
movq %rax, 0x28(%rsp)
movslq 0x3c(%rsp), %rsi
callq 0xe3b0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x14250
testb $0x1, %al
jne 0x14e9c
jmp 0x14f2c
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, (%rsp)
movslq 0x38(%rsp), %rsi
callq 0xe3b0
movq (%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x30(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movslq 0x3c(%rsp), %rsi
callq 0xe3b0
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0xe3b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x14290
movq 0x30(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xe3b0
movq 0x30(%rsp), %rdi
movq %rax, 0x18(%rsp)
movslq 0x3c(%rsp), %rsi
callq 0xe3b0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x14290
movl 0x38(%rsp), %eax
movl %eax, 0x3c(%rsp)
jmp 0x14e37
movl 0x3c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movsd %xmm1, 0x80(%rsp)
movsd %xmm2, 0x78(%rsp)
movsd %xmm3, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, (%rsp)
movsd 0x17dd8(%rip), %xmm0    # 0x324b0
movsd %xmm0, 0x60(%rsp)
movsd 0x78(%rsp), %xmm0
subsd 0x88(%rsp), %xmm0
callq 0x1a870
movq (%rsp), %rdi
movsd %xmm0, 0x58(%rsp)
movsd 0x70(%rsp), %xmm0
subsd 0x80(%rsp), %xmm0
callq 0x1a870
movsd %xmm0, 0x50(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x17904(%rip), %xmm1    # 0x32028
divsd %xmm1, %xmm0
callq 0x40e0
movsd %xmm0, 0x28(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x178e7(%rip), %xmm1    # 0x32028
divsd %xmm1, %xmm0
callq 0x40e0
movq (%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movsd 0x88(%rsp), %xmm0
callq 0x1a870
callq 0x4710
movq (%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movsd 0x78(%rsp), %xmm0
callq 0x1a870
callq 0x4710
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x17886(%rip), %xmm1    # 0x32028
divsd %xmm1, %xmm0
callq 0x40e0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x1785c(%rip), %xmm1    # 0x32028
divsd %xmm1, %xmm0
callq 0x40e0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x28(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
callq 0x4330
movsd %xmm0, 0x30(%rsp)
movsd 0x177f3(%rip), %xmm0    # 0x32008
subsd 0x48(%rsp), %xmm0
callq 0x4330
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
callq 0x4090
movaps %xmm0, %xmm1
movsd 0x177ef(%rip), %xmm0    # 0x32028
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: dtsaras[P]GCW/Utilities.cpp
// Function: Utilities::computeSimilarity(double, double, double, double, double)
double Utilities::computeSimilarity(double v_lat, double v_lon, double p_lat, double p_lon, double max_dist)
{
    double sim = 0;
    double dist = 0; 
    double alpha = 1;
    dist = computeMinimumDistance(v_lat, v_lon, p_lat, p_lon, 'K');

    // sim = max_dist * exp(- alpha * dist);
    sim = 1 - dist/(double)max_dist; 
    
    return sim;
 }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm4, 0x18(%rsp)
movq 0x40(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x17722(%rip), %xmm0    # 0x32008
movsd %xmm0, (%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movl $0x4b, %esi
callq 0x1a690
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
divsd 0x18(%rsp), %xmm1
movsd 0x176e1(%rip), %xmm0    # 0x32008
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movl %edx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1b060
leaq 0x38(%rsp), %rdi
callq 0xe2d0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x64(%rsp), %esi
callq 0x1aea0
jmp 0x1af49
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1b020
movq %rax, 0x8(%rsp)
jmp 0x1af5f
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xe840
jmp 0x1af70
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe3d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1afe6
movslq 0x28(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xe3b0
movl (%rax), %eax
cmpl 0x60(%rsp), %eax
jne 0x1afd7
movb $0x1, 0x77(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x1aff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe2e0
jmp 0x1b008
jmp 0x1afd9
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1af78
movb $0x0, 0x77(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe2e0
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4690
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x10(%rax)
movslq 0x10(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1c8a9
callq 0x1ce30
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movslq 0x18(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rax
movslq 0x18(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1c867
movq 0x8(%rsp), %rdi
movl 0x10(%rdi), %esi
subl $0x1, %esi
callq 0x1c8f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x1c8df
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1c910
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1c8bd
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x2c(%rsp), %esi
callq 0x1ca10
movq 0x18(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %esi
callq 0x1ca30
movq 0x18(%rsp), %rcx
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1c995
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x1ca50
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl 0x2c(%rsp), %esi
callq 0x1ca50
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1c995
movl 0x28(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1c9dc
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1ca50
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl 0x20(%rsp), %esi
callq 0x1ca50
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1c9dc
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x2c(%rsp), %eax
je 0x1ca06
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x1ca70
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x1c910
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::swap(int, int)
void BinaryHeap::swap(int idx1, int idx2){
	double tempDist = distances[idx1];
	int tempVert = vertices[idx1];
	distances[idx1] = distances[idx2];
	vertices[idx1] = vertices[idx2];
	distances[idx2] = tempDist;
	vertices[idx2] = tempVert;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movslq -0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x18(%rsp)
movq 0x8(%rax), %rcx
movslq -0xc(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rsp)
movq (%rax), %rcx
movslq -0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rcx
movslq -0xc(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movslq -0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x8(%rax), %rcx
movslq -0xc(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movsd -0x18(%rsp), %xmm0
movq (%rax), %rcx
movslq -0x10(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl -0x1c(%rsp), %edx
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %esi
callq 0x1c8f0
movl %eax, 0x24(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x28(%rsp)
movb %al, 0x17(%rsp)
jle 0x1cb6c
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1ca50
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl 0x28(%rsp), %esi
callq 0x1ca50
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1cb76
jmp 0x1cba4
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x1ca70
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0x1c8f0
movl %eax, 0x24(%rsp)
jmp 0x1cb2c
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movsd 0x153c2(%rip), %xmm0    # 0x32020
movsd %xmm0, (%rax)
movq 0x8(%rdi), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl 0x10(%rdi), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x1ca70
movq 0x8(%rsp), %rdi
movl 0x10(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rdi)
xorl %esi, %esi
callq 0x1c910
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x242a7(%rip), %rdi     # 0x40fc0
leaq 0x158c8(%rip), %rsi     # 0x325e8
callq 0x43f0
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1cda9
movq 0x2427f(%rip), %rdi     # 0x40fc0
leaq 0x15558(%rip), %rsi     # 0x322a0
callq 0x43f0
movq %rax, %rdi
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x4730
movq %rax, %rdi
leaq 0x1587b(%rip), %rsi     # 0x325eb
callq 0x43f0
movq %rax, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x4670
movq %rax, %rdi
leaq 0x15853(%rip), %rsi     # 0x325ea
callq 0x43f0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1cd2d
movq 0x24210(%rip), %rdi     # 0x40fc0
leaq 0x152f2(%rip), %rsi     # 0x320a9
callq 0x43f0
movq %rax, %rdi
movq 0x241ea(%rip), %rsi     # 0x40fb0
callq 0x4430
addq $0x18, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xad0(%rax), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x1e2fc
movq 0x50(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x38(%rsp)
imulq $0x30, -0x8(%rcx), %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x40(%rsp)
je 0x1e2f2
movq 0x40(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x30(%rsp)
callq 0x246b0
movq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x1e2cb
movq 0x38(%rsp), %rdi
callq 0x44c0
movq 0x48(%rsp), %rax
movq 0xad8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x1e36a
movq 0x28(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
imulq $0x30, -0x8(%rcx), %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x20(%rsp)
je 0x1e360
movq 0x20(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x10(%rsp)
callq 0x246b0
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x1e339
movq 0x18(%rsp), %rdi
callq 0x44c0
movl $0x0, 0x5c(%rsp)
movq 0x48(%rsp), %rcx
movl 0x5c(%rsp), %eax
cmpl 0x9d0(%rcx), %eax
jge 0x1e3bc
movq 0x48(%rsp), %rax
movq 0xb18(%rax), %rax
movslq 0x5c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e3ad
movq 0x8(%rsp), %rdi
callq 0x44c0
jmp 0x1e3af
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1e372
movq 0x48(%rsp), %rax
movq 0xb18(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1e3db
movq (%rsp), %rdi
callq 0x44c0
movq 0x48(%rsp), %rdi
addq $0xb00, %rdi            # imm = 0xB00
callq 0xf030
movq 0x48(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
callq 0x245f0
movq 0x48(%rsp), %rdi
addq $0xab8, %rdi            # imm = 0xAB8
callq 0xef10
movq 0x48(%rsp), %rdi
addq $0xaa0, %rdi            # imm = 0xAA0
callq 0x24650
movq 0x48(%rsp), %rdi
addq $0xa88, %rdi            # imm = 0xA88
callq 0x10200
movq 0x48(%rsp), %rdi
addq $0xa70, %rdi            # imm = 0xA70
callq 0xe2e0
movq 0x48(%rsp), %rdi
addq $0xa38, %rdi            # imm = 0xA38
callq 0xe3a0
movq 0x48(%rsp), %rdi
addq $0xa20, %rdi            # imm = 0xA20
callq 0xe2e0
movq 0x48(%rsp), %rdi
addq $0xa08, %rdi            # imm = 0xA08
callq 0x24650
movq 0x48(%rsp), %rdi
addq $0x9f0, %rdi            # imm = 0x9F0
callq 0x24650
movq 0x48(%rsp), %rdi
addq $0x9d8, %rdi            # imm = 0x9D8
callq 0x10200
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xad0(%rax), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, %rax
je 0x1e801
movq 0x58(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x40(%rsp)
imulq $0x30, -0x8(%rcx), %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x48(%rsp)
je 0x1e7f7
movq 0x48(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x38(%rsp)
callq 0x246b0
movq 0x58(%rsp), %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x48(%rsp)
jne 0x1e7d0
movq 0x40(%rsp), %rdi
callq 0x44c0
movq 0x50(%rsp), %rax
movq 0xad8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1e86f
movq 0x30(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x20(%rsp)
imulq $0x30, -0x8(%rcx), %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x1e865
movq 0x28(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x18(%rsp)
callq 0x246b0
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1e83e
movq 0x20(%rsp), %rdi
callq 0x44c0
movl $0x0, 0x64(%rsp)
movq 0x50(%rsp), %rcx
movl 0x64(%rsp), %eax
cmpl 0x9d0(%rcx), %eax
jge 0x1e8c1
movq 0x50(%rsp), %rax
movq 0xb18(%rax), %rax
movslq 0x64(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1e8b2
movq 0x10(%rsp), %rdi
callq 0x44c0
jmp 0x1e8b4
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x1e877
movq 0x50(%rsp), %rax
movq 0xb18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e8e2
movq 0x8(%rsp), %rdi
callq 0x44c0
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1e4c0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x9f0, %rdi            # imm = 0x9F0
movslq 0x1c(%rsp), %rsi
callq 0x24890
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0xf1a0
movq %rax, %rcx
movq (%rsp), %rax
movss (%rcx), %xmm0
movss %xmm0, 0xc(%rsp)
testb $0x1, 0xb20(%rax)
je 0x1eaa9
movq (%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x18(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x10(%rsp), %rsi
callq 0xeb00
movsd (%rax), %xmm1
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)