// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: get_extra_points(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int*, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, vectorc*, vectorc*, int*)
void get_extra_points(vector< vector<double> >& objects, int* num_points, vector< vector<double> >& remote_objects, vectorc* remote_PrIDs, vectorc* remote_Indices, int* remote_number)
{

#ifdef _DEBUG_GP
	MPI_Barrier(MPI_COMM_WORLD);
	double end, start = MPI_Wtime();
#endif

	int k, rank, nproc, i, j;
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	MPI_Comm_size(MPI_COMM_WORLD, &nproc);

#ifdef _DEBUG
	if(rank == proc_of_interest) cout << "extra point time part 0 strating " << endl;
#endif

	interval* local_box = new interval[DIMENSION];
	compute_local_bounding_box(objects, num_points, local_box);
	double eps = EPS;

	for(i = 0; i < DIMENSION; i++)
	{
		local_box[i].upper += eps;
		local_box[i].lower -= eps; 
	}

	interval* gather_local_box = new interval[DIMENSION * nproc];

	MPI_Allgather(local_box, sizeof(interval) * DIMENSION, MPI_BYTE, gather_local_box,
			sizeof(interval) * DIMENSION, MPI_BYTE, MPI_COMM_WORLD);

	bool if_inside, overlap;
	int count = 0, gcount;

	vector <double> empty;
	vector <vector <double> > send_buf;
	vector <vector <double> > recv_buf;
	send_buf.resize(nproc, empty);
	recv_buf.resize(nproc, empty);

	vector <int> empty_i;
	vector <vector <int> > send_buf_ind;
	vector <vector <int> > recv_buf_ind;
	send_buf_ind.resize(nproc, empty_i);
	recv_buf_ind.resize(nproc, empty_i);

#ifdef _DEBUG_GP
	MPI_Barrier(MPI_COMM_WORLD);
	end = MPI_Wtime();
#ifdef _DEBUG
	if(rank == proc_of_interest) cout << "extra point time part 1: " << end - start << endl;	
#endif
	start = end;
#endif

	for(k = 0; k < nproc; k++)
	{
		if (k == rank) // self
			continue;

		overlap = true;
		for(j = 0; j < DIMENSION; j++)
		{
			if(gather_local_box[rank * DIMENSION + j].lower < gather_local_box[k * DIMENSION +j].lower)
			{
				if(gather_local_box[rank * DIMENSION + j].upper - gather_local_box[k * DIMENSION + j].lower < eps)	
				{
					overlap = false;
					break;
				}
			}
			else
			{
				if(gather_local_box[k * DIMENSION + j].upper - gather_local_box[rank * DIMENSION + j].lower < eps)
				{
					overlap = false;
					break;
				}
			}
		}

		if(overlap == false)
			continue;

		// printf("EXTRA POINTS \t %d\n", send_buf[0].size());
		for(i = 0; i < *num_points; i++)
		{
			if_inside = true;
			for(j = 0; j < DIMENSION; j++)
			{
				if(objects[i][j] < gather_local_box[k * DIMENSION + j].lower || 
						objects[i][j] > gather_local_box[k * DIMENSION + j].upper)
				{
					if_inside = false;
					break;
				}
			}

			if(if_inside == true)
			{

				for(j = 0; j < DIMENSION; j++)
				{
					// printf("%lf ", objects[i][j]);
					send_buf[k].push_back(objects[i][j]);
				}

				// printf("\t%d\n", rank);
				send_buf_ind[k].push_back(i);
				count++;
			}
		}
	}

#ifdef _DEBUG_GP
	MPI_Barrier(MPI_COMM_WORLD);
	end = MPI_Wtime();
#ifdef _DEBUG
	if(rank == proc_of_interest) cout << "extra point time part 2: " << end - start << endl;        
#endif
	start = end;
#endif

	vector <int> send_buf_size, recv_buf_size;
	send_buf_size.resize(nproc, 0);
	recv_buf_size.resize(nproc, 0);

	for(i = 0; i < nproc; i++)
		send_buf_size[i] = send_buf[i].size();

	MPI_Alltoall(&send_buf_size[0], 1, MPI_INT, &recv_buf_size[0], 1, MPI_INT, MPI_COMM_WORLD);

	int tag = 200, send_count, recv_count;
	MPI_Request req_send[2 * nproc], req_recv[2 * nproc];
	MPI_Status stat_send[2 * nproc], stat_recv;

	recv_count = 0;
	for(i = 0; i < nproc; i++)
	{
		if(recv_buf_size[i] > 0)
		{
			recv_buf[i].resize(recv_buf_size[i], 0);
			recv_buf_ind[i].resize(recv_buf_size[i] / DIMENSION, -1);

			MPI_Irecv(&recv_buf[i][0], recv_buf_size[i], MPI_DOUBLE, i, tag, MPI_COMM_WORLD, &req_recv[recv_count++]);
			MPI_Irecv(&recv_buf_ind[i][0], recv_buf_size[i] / DIMENSION, MPI_INT, i, tag + 1, MPI_COMM_WORLD, &req_recv[recv_count++]);
		}
	}

	send_count = 0;

	for(i = 0; i < nproc; i++)
	{
		if(send_buf_size[i] > 0)
		{
			MPI_Isend(&send_buf[i][0], send_buf_size[i], MPI_DOUBLE, i, tag, MPI_COMM_WORLD, &req_send[send_count++]);
			MPI_Isend(&send_buf_ind[i][0], send_buf_size[i] / DIMENSION, MPI_INT, i, tag + 1, MPI_COMM_WORLD, &req_send[send_count++]);
		}
	}

	int rtag, rsource, rpos;


	for(i = 0; i < recv_count; i++)
	{
		MPI_Waitany(recv_count, &req_recv[0], &rpos, &stat_recv);

		rtag = stat_recv.MPI_TAG;
		rsource = stat_recv.MPI_SOURCE;

		if(rtag == tag)
		{
			// #if _GET_EXTRA_POINT_STAT == 0  // WHY THIS IS HERE??????????????????????????????????????????????????????????????
			addPoints(rsource, recv_buf_size[rsource], DIMENSION, recv_buf[rsource], remote_objects, remote_PrIDs, remote_number);
			// #endif
			recv_buf[rsource].clear();
		}
		else if(rtag == tag + 1)
		{
			// postpond this computation and call update points later
			// processing immediately might lead to invalid computation
		}
	}	

	if(send_count > 0)
		MPI_Waitall(send_count, &req_send[0], &stat_send[0]);

#ifdef _DEBUG_GP
	MPI_Barrier(MPI_COMM_WORLD);
	end = MPI_Wtime();
#ifdef _DEBUG
	if(rank == proc_of_interest) cout << "extra point time part 3: " << end - start << endl;        
#endif
	start = end;
#endif

	updatePoints(recv_buf_ind, remote_Indices, remote_PrIDs, *remote_number);

	MPI_Reduce(&count, &gcount, 1, MPI_INT, MPI_SUM, proc_of_interest, MPI_COMM_WORLD);

#ifdef _DEBUG
	if(rank == proc_of_interest)
	{
		cout << "Total extra point " << gcount << endl;
		cout << "Extra point per processor " << gcount/nproc << endl;
	}
#endif

#ifdef _DEBUG_GP
	MPI_Barrier(MPI_COMM_WORLD);
	end = MPI_Wtime();
#ifdef _DEBUG

	if(rank == proc_of_interest) cout << "extra point time part 4: " << end - start << endl;        
#endif
	start = end;
#endif


	empty.clear();
	send_buf.clear();
	recv_buf.clear();
	send_buf_size.clear();
	recv_buf_size.clear();
	send_buf_ind.clear();
	recv_buf_ind.clear();

	delete [] gather_local_box;
	delete [] local_box;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, -0xc0(%rbp)
movq %r8, -0x138(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0x140(%rbp)
movq %rsi, %r13
movq %rdi, %r15
movq 0xb56e(%rip), %rbx      # 0x13fb0
leaq -0x74(%rbp), %rsi
movq %rbx, %rdi
callq 0x2370
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
leaq 0xb8d3(%rip), %r12      # 0x14334
movslq (%r12), %rax
movq %rax, %rdi
shlq $0x4, %rdi
testq %rax, %rax
pushq $-0x1
popq %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %rbx
movq %r15, %rdi
movq %r13, -0x40(%rbp)
movq %r13, %rsi
movq %rax, %rdx
callq 0x7ab2
movq %rbx, %r13
leaq 0xb88d(%rip), %rax      # 0x14328
movsd (%rax), %xmm1
movslq (%r12), %rbx
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
movq %rax, %rdx
shlq $0x4, %rdx
cmpq %rcx, %rdx
je 0x8ae5
movsd 0x8(%r13,%rcx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%r13,%rcx)
movsd (%r13,%rcx), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r13,%rcx)
addq $0x10, %rcx
jmp 0x8ab6
movsd %xmm1, -0x38(%rbp)
movl %eax, -0x2c(%rbp)
movslq -0x30(%rbp), %rax
imulq %rbx, %rax
movq %rax, %rdi
shlq $0x4, %rdi
testl %eax, %eax
cmovsq %r14, %rdi
callq 0x2030
shll $0x4, %ebx
subq $0x8, %rsp
movq 0xb48b(%rip), %rdx      # 0x13fa0
movq %r13, -0x130(%rbp)
movq %r13, %rdi
movl %ebx, %esi
movq %rax, -0xb8(%rbp)
movq %rax, %rcx
movl %ebx, %r8d
movq %rdx, %r9
pushq 0xb479(%rip)            # 0x13fb0
callq 0x2050
popq %rcx
popq %rdx
andl $0x0, -0x44(%rbp)
leaq -0x120(%rbp), %rdx
andq $0x0, 0x10(%rdx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdx)
leaq -0x100(%rbp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movapd %xmm0, -0xb0(%rbp)
andq $0x0, -0xa0(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x955a
movslq -0x30(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x120(%rbp), %rdx
callq 0x955a
leaq -0x190(%rbp), %rdx
andq $0x0, 0x10(%rdx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdx)
leaq -0x160(%rbp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movapd %xmm0, -0xe0(%rbp)
andq $0x0, -0xd0(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x95a2
movslq -0x30(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
leaq -0x190(%rbp), %rdx
callq 0x95a2
movq -0xb8(%rbp), %r11
addq $0x8, %r11
xorl %r12d, %r12d
xorl %r13d, %r13d
movq -0x40(%rbp), %r10
movsd -0x38(%rbp), %xmm2
movq %r11, -0x68(%rbp)
movslq -0x30(%rbp), %rsi
cmpq %rsi, %r13
jge 0x8d68
movl -0x74(%rbp), %eax
cmpq %rax, %r13
jne 0x8c22
incq %r13
jmp 0x8c08
leaq 0xb70b(%rip), %rcx      # 0x14334
movl (%rcx), %edx
imull %edx, %eax
cltq
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
imull %r13d, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %r11, %rdx
shlq $0x4, %rax
addq %r11, %rax
shlq $0x4, %rcx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x8c92
movsd -0x8(%rax,%rsi), %xmm0
movsd -0x8(%rdx,%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8c7d
movsd (%rax,%rsi), %xmm0
subsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x8c8c
jmp 0x8c1d
movsd (%rdx,%rsi), %xmm1
subsd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
ja 0x8c1d
addq $0x10, %rsi
jmp 0x8c55
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cmpl (%r10), %eax
jge 0x8c1d
leaq 0xb691(%rip), %rcx      # 0x14334
movl (%rcx), %ecx
movslq %eax, %rdx
imulq $0x18, %rdx, %rdx
addq (%r15), %rdx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
shlq $0x3, %rsi
movl %r13d, %edi
imull %ecx, %edi
movslq %edi, %rdi
shlq $0x4, %rdi
addq %r11, %rdi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x8cf9
movq (%rdx), %r9
movsd (%r9,%r8), %xmm0
movsd -0x8(%rdi,%r8,2), %xmm1
ucomisd %xmm0, %xmm1
ja 0x8d61
ucomisd (%rdi,%r8,2), %xmm0
leaq 0x8(%r8), %r8
jbe 0x8cd0
jmp 0x8d61
xorl %r14d, %r14d
xorl %ebx, %ebx
movslq %ecx, %rax
imulq $0x18, %r13, %rdi
cmpq %rax, %rbx
jge 0x8d3a
addq -0x100(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq (%r15), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rsi
addq %r14, %rsi
callq 0x94f6
incq %rbx
leaq 0xb602(%rip), %rax      # 0x14334
movl (%rax), %ecx
addq $0x8, %r14
jmp 0x8cfe
addq -0x160(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3b0a
incl %r12d
movl %r12d, -0x44(%rbp)
movl -0x2c(%rbp), %eax
movq -0x40(%rbp), %r10
movsd -0x38(%rbp), %xmm2
movq -0x68(%rbp), %r11
incl %eax
jmp 0x8c94
xorpd %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movapd %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
leaq -0x178(%rbp), %rdx
andl $0x0, (%rdx)
callq 0x94bc
movslq -0x30(%rbp), %rsi
leaq -0x178(%rbp), %rdx
andl $0x0, (%rdx)
leaq -0x60(%rbp), %rdi
callq 0x94bc
movq -0x100(%rbp), %rax
xorl %edx, %edx
movq -0x90(%rbp), %rcx
movl %edx, -0x2c(%rbp)
cmpl -0x30(%rbp), %edx
jge 0x8de2
movslq %edx, %rdx
imulq $0x18, %rdx, %rsi
movq 0x8(%rax,%rsi), %rdi
subq (%rax,%rsi), %rdi
shrq $0x3, %rdi
movl %edi, (%rcx,%rdx,4)
movl -0x2c(%rbp), %edx
incl %edx
jmp 0x8dbc
movq -0x90(%rbp), %rdi
movq -0x60(%rbp), %rcx
subq $0x8, %rsp
movq 0xb1d8(%rip), %rdx      # 0x13fd0
pushq $0x1
popq %rsi
movl %esi, %r8d
movq %rdx, %r9
pushq 0xb1a9(%rip)            # 0x13fb0
callq 0x2150
popq %rcx
popq %rdx
movq %rsp, -0x68(%rbp)
movl -0x30(%rbp), %eax
addl %eax, %eax
movq %rsp, %rcx
shlq $0x3, %rax
subq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movl -0x30(%rbp), %eax
leal (%rax,%rax), %ecx
movq %rsp, %rsi
leaq (,%rcx,8), %rdx
subq %rdx, %rsi
movq %rsi, -0x40(%rbp)
movq %rsi, %rsp
movq %rsp, %rdx
imulq $0x18, %rcx, %rcx
subq %rcx, %rdx
movq %rdx, -0x128(%rbp)
movq %rdx, %rsp
xorl %ecx, %ecx
leaq -0x70(%rbp), %r15
movq 0xb15c(%rip), %r12      # 0x13fc0
movq 0xb145(%rip), %rbx      # 0x13fb0
xorl %r14d, %r14d
movl %ecx, -0x2c(%rbp)
cmpl %eax, %ecx
jge 0x8f6a
movslq %ecx, %rdx
movq -0x60(%rbp), %rsi
movslq (%rsi,%rdx,4), %rsi
testq %rsi, %rsi
jle 0x8f63
imulq $0x18, %rdx, %rdi
addq -0xb0(%rbp), %rdi
andq $0x0, -0x70(%rbp)
movq %r15, %rdx
callq 0x9520
movslq -0x2c(%rbp), %rax
imulq $0x18, %rax, %rdi
addq -0xe0(%rbp), %rdi
movq -0x60(%rbp), %rcx
movl (%rcx,%rax,4), %eax
cltd
leaq 0xb471(%rip), %rcx      # 0x14334
idivl (%rcx)
movslq %eax, %rsi
orl $-0x1, -0x70(%rbp)
movq %r15, %rdx
callq 0x94bc
movslq -0x2c(%rbp), %rcx
movq -0xb0(%rbp), %rax
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rdi
movq -0x60(%rbp), %rax
movl (%rax,%rcx,4), %esi
movslq %r14d, %rax
movq -0x40(%rbp), %rdx
leaq (%rdx,%rax,8), %r13
subq $0x8, %rsp
movq %r12, %rdx
movl $0xc8, %r8d
movq %rbx, %r9
pushq %r13
callq 0x2340
popq %rcx
popq %rdx
movslq -0x2c(%rbp), %rcx
movq -0xe0(%rbp), %rax
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rdi
movq -0x60(%rbp), %rax
movl (%rax,%rcx,4), %eax
cltd
leaq 0xb400(%rip), %rsi      # 0x14334
idivl (%rsi)
addq $0x8, %r13
subq $0x8, %rsp
movl %eax, %esi
movq 0xb089(%rip), %rdx      # 0x13fd0
movl $0xc9, %r8d
movq %rbx, %r9
pushq %r13
callq 0x2340
popq %rcx
popq %rdx
addl $0x2, %r14d
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %eax
incl %ecx
jmp 0x8e6e
xorl %ecx, %ecx
movq 0xb04d(%rip), %r13      # 0x13fc0
movq 0xb036(%rip), %r12      # 0x13fb0
xorl %r15d, %r15d
movl %ecx, -0x2c(%rbp)
cmpl %eax, %ecx
jge 0x9029
movslq %ecx, %rdx
movq -0x90(%rbp), %rsi
movl (%rsi,%rdx,4), %esi
testl %esi, %esi
jle 0x9022
movq -0x100(%rbp), %rax
imulq $0x18, %rdx, %rdx
movq (%rax,%rdx), %rdi
movslq %r15d, %rax
movq -0x38(%rbp), %rdx
leaq (%rdx,%rax,8), %rbx
subq $0x8, %rsp
movq %r13, %rdx
movl $0xc8, %r8d
movq %r12, %r9
pushq %rbx
callq 0x2120
popq %rcx
popq %rdx
movslq -0x2c(%rbp), %rcx
movq -0x160(%rbp), %rax
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rdi
movq -0x90(%rbp), %rax
movl (%rax,%rcx,4), %eax
cltd
leaq 0xb340(%rip), %rsi      # 0x14334
idivl (%rsi)
addq $0x8, %rbx
subq $0x8, %rsp
movl %eax, %esi
movq 0xafc9(%rip), %rdx      # 0x13fd0
movl $0xc9, %r8d
movq %r12, %r9
pushq %rbx
callq 0x2120
popq %rcx
popq %rdx
addl $0x2, %r15d
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %eax
incl %ecx
jmp 0x8f7d
xorl %eax, %eax
leaq -0x178(%rbp), %rbx
movl %eax, -0x2c(%rbp)
cmpl %r14d, %eax
jge 0x90c6
movl %r14d, %edi
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rcx
callq 0x2310
cmpl $0xc8, -0x174(%rbp)
jne 0x90bc
movl -0x178(%rbp), %eax
movslq %eax, %rdi
movq -0x60(%rbp), %rax
movl (%rax,%rdi,4), %esi
leaq 0xb2c0(%rip), %rax      # 0x14334
movl (%rax), %edx
imulq $0x18, %rdi, %r13
movq -0xb0(%rbp), %rcx
addq %r13, %rcx
subq $0x8, %rsp
movq -0x140(%rbp), %r8
movq -0xc8(%rbp), %r9
pushq -0xc0(%rbp)
callq 0x885d
popq %rcx
popq %rdx
movq -0xb0(%rbp), %rax
movq (%rax,%r13), %rcx
cmpq %rcx, 0x8(%rax,%r13)
je 0x90bc
addq %r13, %rax
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x9032
testl %r15d, %r15d
jle 0x90de
movl %r15d, %edi
movq -0x38(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x2290
movq -0xc0(%rbp), %rax
movl (%rax), %ecx
leaq -0xe0(%rbp), %rdi
movq -0x138(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x8987
subq $0x8, %rsp
movq 0xaec4(%rip), %rcx      # 0x13fd0
movq 0xae85(%rip), %r8       # 0x13f98
leaq -0x44(%rbp), %rdi
leaq -0x144(%rbp), %rsi
pushq $0x1
popq %rdx
xorl %r9d, %r9d
pushq %r12
callq 0x2300
popq %rcx
popq %rdx
movq -0x120(%rbp), %rax
cmpq %rax, -0x118(%rbp)
je 0x9144
movq %rax, -0x118(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x95ea
leaq -0xb0(%rbp), %rdi
callq 0x95ea
movq -0x90(%rbp), %rax
cmpq %rax, -0x88(%rbp)
je 0x9173
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
cmpq %rax, -0x58(%rbp)
je 0x9181
movq %rax, -0x58(%rbp)
leaq -0x160(%rbp), %rbx
movq %rbx, %rdi
callq 0x95f8
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
callq 0x95f8
movq -0xb8(%rbp), %rdi
callq 0x22e0
movq -0x130(%rbp), %rdi
callq 0x22e0
movq -0x68(%rbp), %rsp
leaq -0x60(%rbp), %rdi
callq 0x9d22
leaq -0x90(%rbp), %rdi
callq 0x9d22
movq %r14, %rdi
callq 0x9606
movq %rbx, %rdi
callq 0x9606
leaq -0x190(%rbp), %rdi
callq 0x9d22
leaq -0xb0(%rbp), %rdi
callq 0x2ea4
leaq -0x100(%rbp), %rdi
callq 0x2ea4
leaq -0x120(%rbp), %rdi
callq 0x2ede
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9236
jmp 0x9236
jmp 0x9236
jmp 0x9252
movq %rax, %rbx
jmp 0x9279
jmp 0x9236
jmp 0x9236
jmp 0x9236
jmp 0x9236
jmp 0x9236
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9d22
leaq -0x90(%rbp), %rdi
callq 0x9d22
jmp 0x9255
jmp 0x9252
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x9606
leaq -0x160(%rbp), %rdi
callq 0x9606
leaq -0x190(%rbp), %rdi
callq 0x9d22
leaq -0xb0(%rbp), %rdi
callq 0x2ea4
leaq -0x100(%rbp), %rdi
callq 0x2ea4
leaq -0x120(%rbp), %rdi
callq 0x2ede
movq %rbx, %rdi
callq 0x2460
nop