LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_cube.cpp
// Function: test_getCubeSize()
void test_getCubeSize() {
   std::cout << "Testing getCubeSize... ";

   Cube c1;
   assert(c1.getCubeSize() == 3);

   for (unsigned int i = 2; i < 10; i++) {
      Cube c(CubieColor::WHITE, i);
      assert(c.getCubeSize() == i);
   }

   std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq 0x725f(%rip), %rdi      # 0xcfd8
leaq 0x3576(%rip), %rsi      # 0x92f6
callq 0x2130
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3a84
movq %rbx, %rdi
callq 0x3e56
cmpl $0x3, %eax
jne 0x5e23
pushq $0x2
popq %rbx
leaq 0x78(%rsp), %r14
pushq $0x77
popq %rbp
cmpl $0xa, %ebx
je 0x5dd5
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3bf6
movq %r14, %rdi
callq 0x3e56
cmpl %eax, %ebx
jne 0x5e04
movq %r14, %rdi
callq 0x3e50
incl %ebx
jmp 0x5dac
movq 0x71fc(%rip), %rdi      # 0xcfd8
leaq 0x348a(%rip), %rsi      # 0x926d
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x3e50
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3531(%rip), %rdi      # 0x933c
leaq 0x3484(%rip), %rsi      # 0x9296
leaq 0x350b(%rip), %rcx      # 0x9324
movl $0xb2, %edx
callq 0x20d0
leaq 0x34e4(%rip), %rdi      # 0x930e
leaq 0x3465(%rip), %rsi      # 0x9296
leaq 0x34ec(%rip), %rcx      # 0x9324
movl $0xae, %edx
callq 0x20d0
jmp 0x5e44
movq %rax, %rbx
jmp 0x5e56
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3e50
movq %rsp, %rdi
callq 0x3e50
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_cube.cpp
// Function: verify_cube(Cube, std::vector<CubieColor, std::allocator<CubieColor>>)
void verify_cube(Cube cube, std::vector<CubieColor> expected) {
   std::vector<CubieColor> result = cube.getCube();
   assert(result.size() == expected.size());
   for (unsigned int i = 0; i < result.size(); i++)
      assert(result.at(i) == expected.at(i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3e5a
movq 0x8(%r14), %rax
subq (%r14), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
cmpq %rcx, %rax
jne 0x7048
xorl %r14d, %r14d
movq %rsp, %r15
movl %r14d, %r14d
movq 0x8(%rsp), %rax
subq (%rsp), %rax
cmpq %r14, %rax
jbe 0x7035
movq %r15, %rdi
movq %r14, %rsi
callq 0x85e0
movb (%rax), %bpl
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85e0
incl %r14d
cmpb (%rax), %bpl
je 0x6fe4
leaq 0x242b(%rip), %rdi      # 0x9448
leaq 0x2272(%rip), %rsi      # 0x9296
leaq 0x23ed(%rip), %rcx      # 0x9418
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x20d0
movq %rsp, %rdi
callq 0x48ec
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23a8(%rip), %rdi      # 0x93f7
leaq 0x2240(%rip), %rsi      # 0x9296
leaq 0x23bb(%rip), %rcx      # 0x9418
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x20d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x48ec
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_cube.cpp
// Function: getScrambled()
Cube getScrambled() {
   Cube c(CubieColor::RED, 3);
   c.turn({Layer::R, false});
   c.turn({Layer::B, true});
   c.turn({Layer::U, false});
   c.turn({Layer::L, true});
   c.turn({Layer::F, false});
   c.turn({Layer::U, true});
   c.turn({Layer::F, false});
   c.turn({Layer::D, true});
   return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x72
popq %rsi
pushq $0x3
popq %rdx
callq 0x3bf6
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x3fb2
movabsq $0x100000007, %rsi      # imm = 0x100000007
movq %rbx, %rdi
callq 0x3fb2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3fb2
movabsq $0x100000004, %rsi      # imm = 0x100000004
movq %rbx, %rdi
callq 0x3fb2
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x3fb2
movabsq $0x100000001, %rsi      # imm = 0x100000001
movq %rbx, %rdi
callq 0x3fb2
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x3fb2
movabsq $0x100000009, %rsi      # imm = 0x100000009
movq %rbx, %rdi
callq 0x3fb2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3e50
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: initializeGraph(Graph*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
void initializeGraph(Graph* myGraph, const string nodeFilePath, const string edgeFilePath, double delta, double sectionLength)
{
	printf("Initializing the road network...\n");
	myGraph->vertexsVector = new Vertex[VERTEX_SIZE];
	myGraph->edgesVector   = new Edge[EDGE_SIZE];
	readVertexs(myGraph, nodeFilePath);
	readEdges(myGraph, edgeFilePath);
	myGraph->delta = delta;
	myGraph->SECTION_LENGTH = sectionLength;
	printf("The road network is initialized!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x5ffc(%rip), %rdi      # 0xa255
callq 0x21a0
movl $0x1005908, %edi        # imm = 0x1005908
callq 0x2030
movq $0x249f0, (%rax)        # imm = 0x249F0
pushq $0x48
popq %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax,%rcx)
movups %xmm0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
addq $0x70, %rcx
cmpq $0x1005948, %rcx        # imm = 0x1005948
jne 0x4275
addq $0x8, %rax
movq %rax, 0x10(%rbx)
movl $0x493e00, %edi         # imm = 0x493E00
callq 0x2030
movq %rax, 0x8(%rbx)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5c94
leaq -0x70(%rbp), %rdi
callq 0x2090
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5d9f
leaq -0x50(%rbp), %rdi
callq 0x2090
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x5f6f(%rip), %rdi      # 0xa276
callq 0x21a0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x431b
movq %rax, %rbx
movq %r15, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setCurrPath(Graph*, std::vector<Edge, std::allocator<Edge>>*, CompletePath*, unsigned int)
void setCurrPath(Graph* myGraph, std::vector<Edge>* currentPath, CompletePath* completePath, const unsigned int pos)
{
	printf("Initializing the current path...\n");
	for (unsigned int i = 0; i < pos; i++)
	{
		Edge temEdge = completePath->edges[i];
		myGraph->vertexsVector[temEdge.firstVertexID].accessFlag = true;
		myGraph->vertexsVector[temEdge.firstVertexID].currFlag   = true;
		myGraph->vertexsVector[temEdge.secVertexID].accessFlag   = true;
		myGraph->vertexsVector[temEdge.secVertexID].currFlag     = true;
		currentPath->push_back(temEdge);
	}
	printf("The current path initialization is complete!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r12d
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5cc9(%rip), %rdi      # 0xa3f7
callq 0x21a0
movl %r12d, %r13d
shlq $0x5, %r13
xorl %r12d, %r12d
movw $0x101, %bx             # imm = 0x101
cmpq %r12, %r13
je 0x4791
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq 0x10(%r15), %rax
movslq -0x4c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
movw %bx, 0x12(%rax,%rcx)
movslq -0x48(%rbp), %rcx
imulq $0x70, %rcx, %rcx
movw %bx, 0x12(%rax,%rcx)
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x4066
addq $0x20, %r12
jmp 0x4741
leaq 0x5c80(%rip), %rdi      # 0xa418
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: initializeFirstPath(Graph*, TraversingPath*, int, std::vector<Edge, std::allocator<Edge>>&)
void initializeFirstPath(Graph* myGraph, TraversingPath* path, int currentVertex, std::vector<Edge>& currentPath)
{
	printf("Start initializing the first path...\n");
	path->finalVertexID = currentVertex;
	path->distToRefer   = 0;
	path->minPos        = 0;
	path->maxPos        = myGraph->vertexsVector[currentVertex].maxPos;
	for (unsigned int i = 0; i < currentPath.size(); i++)
	{
		const Vertex firstVertex = myGraph->vertexsVector[currentPath[i].firstVertexID];
		const Vertex secVertex   = myGraph->vertexsVector[currentPath[i].secVertexID];
		path->edges.push_back(currentPath[i].edgeID);
		path->distToRefer = std::max(path->distToRefer, firstVertex.distToRefer);
		path->distToRefer = std::max(path->distToRefer, secVertex.distToRefer);
		path->minPos      = std::max(path->minPos, firstVertex.minPos);
		path->minPos      = std::max(path->minPos, secVertex.minPos);
	}
	printf("The first path is initialized!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5c74(%rip), %rdi      # 0xa447
callq 0x21a0
movl %r12d, 0x8(%r14)
andq $0x0, 0x10(%r14)
andl $0x0, (%r14)
movq 0x10(%r15), %rax
movslq %r12d, %rcx
imulq $0x70, %rcx, %rcx
movl 0x8(%rax,%rcx), %eax
movl %eax, 0x4(%r14)
leaq 0x28(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r12, %rcx
jbe 0x48c1
movq %r12, %r13
shlq $0x5, %r13
movslq 0x4(%rax,%r13), %rax
imulq $0x70, %rax, %rsi
addq 0x10(%r15), %rsi
leaq -0x110(%rbp), %rdi
callq 0x5734
movq (%rbx), %rax
movslq 0x8(%rax,%r13), %rax
imulq $0x70, %rax, %rsi
addq 0x10(%r15), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x5734
addq (%rbx), %r13
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x57a4
movsd -0xe8(%rbp), %xmm0
maxsd 0x10(%r14), %xmm0
movsd -0x78(%rbp), %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x10(%r14)
movl (%r14), %eax
movl -0x10c(%rbp), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl -0x9c(%rbp), %eax
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, (%r14)
leaq -0xa0(%rbp), %rdi
callq 0x57ca
leaq -0x110(%rbp), %rdi
callq 0x57ca
incl %r12d
jmp 0x4803
leaq 0x5ba4(%rip), %rdi      # 0xa46c
callq 0x21a0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x57ca
jmp 0x48f3
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x57ca
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: realDistance(double, double, double)
double realDistance(const double lonDiff, const double latDiff, const double cosLongitude)
{
	const  double CONST_DISTANCE_ONE_DEGREE = 111111;
	double lonDistance = lonDiff * CONST_DISTANCE_ONE_DEGREE * cos(cosLongitude);
	double latDistance = latDiff * CONST_DISTANCE_ONE_DEGREE;
	double dist = sqrt(lonDistance * lonDistance + latDistance * latDistance);
	return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm1, -0x10(%rbp)
mulsd 0x582c(%rip), %xmm0     # 0xa148
movsd %xmm0, -0x8(%rbp)
movapd %xmm2, %xmm0
callq 0x2210
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd 0x580c(%rip), %xmm1     # 0xa148
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setReferPathLength(ReferencePath*)
void setReferPathLength(ReferencePath* temPath)
{
	temPath->referenceLength = 0.0;
	for (unsigned int i = 0; i < temPath->edges.size(); i++)
	{
		Edge temEdge = temPath->edges[i];
		temPath->referenceLength += (temEdge.realLength);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, 0x18(%rdi)
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x498d
movq %rdx, %rsi
shlq $0x5, %rsi
addsd 0x18(%rax,%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
incl %edx
jmp 0x4970
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: filterVertexIsSafeArea(Graph*, ReferencePath*)
void filterVertexIsSafeArea(Graph* myGraph, ReferencePath* temPath)
{
	printf("Start filtering the vertices in the safe area...\n");
	int count = 0;
	for (int i = 0; i < (myGraph->vertexPos); i++)
	{
		if (myGraph->vertexsVector[i].referFlag == true)
		{
			myGraph->vertexsVector[i].locationFlag = true;
			count++;
			continue;
		}
		for (unsigned int j = 0; j < temPath->edges.size(); j++)
		{
			double x = myGraph->vertexsVector[i].longitude;
			double y = myGraph->vertexsVector[i].latitude;
			double x1 = myGraph->vertexsVector[temPath->edges[j].firstVertexID].longitude;
			double y1 = myGraph->vertexsVector[temPath->edges[j].firstVertexID].latitude;
			double x2 = myGraph->vertexsVector[temPath->edges[j].secVertexID].longitude;
			double y2 = myGraph->vertexsVector[temPath->edges[j].secVertexID].latitude;
			double dist = pointToSegDist(x, y, x1, y1, x2, y2);
			if (dist <= (myGraph->delta))
			{
				myGraph->vertexsVector[i].locationFlag = true;
				count++;
				break;
			}
		}
	}
	printf("Finished filtering the vertices in the safe area!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq 0x5adf(%rip), %rdi      # 0xa48d
callq 0x21a0
movq %rbx, -0x30(%rbp)
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, -0x48(%rbp)
cmpq -0x48(%rbp), %rcx
je 0x4a86
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rbx
movq %rcx, -0x50(%rbp)
imulq $0x70, %rcx, %rax
leaq (%rbx,%rax), %r13
cmpb $0x0, 0x10(%rbx,%rax)
je 0x49f3
addq $0x11, %r13
jmp 0x4a75
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %r15
subq %r12, %r15
sarq $0x5, %r15
xorl %eax, %eax
movl %eax, %r14d
cmpq %r14, %r15
jbe 0x4a7a
movsd 0x18(%r13), %xmm0
movsd 0x20(%r13), %xmm1
movq %r14, %rax
shlq $0x5, %rax
movslq 0x4(%r12,%rax), %rcx
imulq $0x70, %rcx, %rcx
movsd 0x18(%rbx,%rcx), %xmm2
movsd 0x20(%rbx,%rcx), %xmm3
movslq 0x8(%r12,%rax), %rax
imulq $0x70, %rax, %rax
movsd 0x18(%rbx,%rax), %xmm4
movsd 0x20(%rbx,%rax), %xmm5
callq 0x4aa0
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm1
leal 0x1(%r14), %eax
ucomisd %xmm0, %xmm1
jb 0x4a0c
movq -0x40(%rbp), %rax
leaq (%rbx,%rax), %r13
addq $0x11, %r13
movb $0x1, (%r13)
movq -0x50(%rbp), %rcx
incq %rcx
jmp 0x49c5
leaq 0x5a31(%rip), %rdi      # 0xa4be
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: pointToSegDist(double, double, double, double, double, double)
double pointToSegDist(const double x, const double y, const double x1, const double y1, const double x2, const double y2)
{
	double cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
	if (cross <= 0)
	{
		return sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
	}
	double d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
	if (cross >= d2)
	{
		return sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
	}
	double r = cross / d2;
	double px = x1 + (x2 - x1) * r;
	double py = y1 + (y2 - y1) * r;
	return sqrt((x - px) * (x - px) + (py - y) * (py - y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movapd %xmm4, %xmm7
subsd %xmm2, %xmm7
movapd %xmm0, %xmm8
subsd %xmm2, %xmm8
movapd %xmm5, %xmm6
subsd %xmm3, %xmm6
movapd %xmm1, %xmm10
subsd %xmm3, %xmm10
movapd %xmm10, %xmm11
mulsd %xmm6, %xmm11
movapd %xmm7, %xmm9
mulsd %xmm8, %xmm9
addsd %xmm11, %xmm9
xorpd %xmm11, %xmm11
ucomisd %xmm9, %xmm11
jae 0x4b3a
movapd %xmm6, %xmm10
mulsd %xmm6, %xmm10
movapd %xmm7, %xmm8
mulsd %xmm7, %xmm8
addsd %xmm10, %xmm8
ucomisd %xmm8, %xmm9
jae 0x4b4b
divsd %xmm8, %xmm9
mulsd %xmm9, %xmm7
addsd %xmm2, %xmm7
mulsd %xmm9, %xmm6
addsd %xmm3, %xmm6
subsd %xmm7, %xmm0
subsd %xmm1, %xmm6
mulsd %xmm6, %xmm6
mulsd %xmm0, %xmm0
addsd %xmm6, %xmm0
jmp 0x4b5f
mulsd %xmm10, %xmm10
mulsd %xmm8, %xmm8
addsd %xmm10, %xmm8
jmp 0x4b64
subsd %xmm4, %xmm0
subsd %xmm5, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, %xmm8
sqrtsd %xmm8, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setMinPosAndMaxPos(Graph*, ReferencePath*)
void setMinPosAndMaxPos(Graph* myGraph, ReferencePath* temReferPath)
{
	printf("Start to set the minPos and maxPos of each vertex...\n");
	for (unsigned int i = 0; i < (myGraph->vertexPos); i++)
	{
		myGraph->vertexsVector[i].minPos = 0;
		myGraph->vertexsVector[i].maxPos = 0;
		if (myGraph->vertexsVector[i].locationFlag == true)
		{
			double x1 = myGraph->vertexsVector[i].longitude;
			double y1 = myGraph->vertexsVector[i].latitude;
			for (unsigned int j = 0; j < temReferPath->numOfReferPoint; j++)
			{
				double x2 = temReferPath->pointOfRefer[j].x;
				double y2 = temReferPath->pointOfRefer[j].y;
				double dist = euc(x1, y1, x2, y2);
				if (dist <= (myGraph->delta))
				{
					myGraph->vertexsVector[i].minPos = j;
					break;
				}
			}
			int numOfReferPoint = temReferPath->numOfReferPoint - 1;
			for (int j = numOfReferPoint; j >= 0; j--)
			{
				double x2 = temReferPath->pointOfRefer[j].x;
				double y2 = temReferPath->pointOfRefer[j].y;
				double dist = euc(x1, y1, x2, y2);
				if (dist <= (myGraph->delta))
				{
					myGraph->vertexsVector[i].maxPos = j;
					break;
				}
			}
		}
	}
	printf("The minPos and maxPos of each vertex are set...\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5973(%rip), %rdi      # 0xa4f2
callq 0x21a0
movl 0x4(%r14), %eax
xorl %ecx, %ecx
pushq $0x8
popq %rdx
cmpq %rax, %rcx
je 0x4c69
movq 0x10(%r14), %rdi
imulq $0x70, %rcx, %r8
andq $0x0, 0x4(%rdi,%r8)
cmpb $0x1, 0x11(%rdi,%r8)
jne 0x4c61
leaq (%rdi,%r8), %rsi
addq $0x4, %rsi
addq %r8, %rdi
movsd 0x18(%rdi), %xmm0
movsd 0x20(%rdi), %xmm1
movl 0x8(%rbx), %edi
movq %rdx, %r9
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x4c14
movq 0x10(%rbx), %r10
movapd %xmm0, %xmm2
subsd -0x8(%r10,%r9), %xmm2
movapd %xmm1, %xmm3
subsd (%r10,%r9), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
movsd 0x18(%r14), %xmm3
ucomisd %xmm2, %xmm3
jae 0x4c11
incq %r8
addq $0x10, %r9
jmp 0x4bce
movl %r8d, (%rsi)
movq %rdi, %r8
shlq $0x4, %r8
addq $-0x8, %r8
testl %edi, %edi
jle 0x4c61
movq 0x10(%rbx), %r9
movapd %xmm0, %xmm2
subsd -0x8(%r9,%r8), %xmm2
movapd %xmm1, %xmm3
subsd (%r9,%r8), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
movsd 0x18(%r14), %xmm3
decl %edi
addq $-0x10, %r8
ucomisd %xmm2, %xmm3
jb 0x4c1f
movl %edi, 0x4(%rsi)
incq %rcx
jmp 0x4b8d
leaq 0x58b7(%rip), %rdi      # 0xa527
popq %rbx
popq %r14
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setReferDFDFlag(Graph*, ReferencePath*)
void setReferDFDFlag(Graph* myGraph, ReferencePath* temPath)
{
	Vertex finalVertex = myGraph->vertexsVector[temPath->finalVertex];
	if (finalVertex.locationFlag == false)
	{
		temPath->referDFDFlag = false;
	}
	else
	{
		int flag = 0;
		for (int j = finalVertex.minPos; j <= finalVertex.maxPos; j++)
		{
			double x1 = finalVertex.longitude;
			double y1 = finalVertex.latitude;
			double x2 = temPath->pointOfRefer[j].x;
			double y2 = temPath->pointOfRefer[j].y;
			if (euc(x1, y1, x2, y2) > (myGraph->delta))
			{
				flag = 1;
				break;
			}
		}
		if (flag == 1)
		{
			temPath->referDFDFlag = false;
		}
		else
		{
			temPath->referDFDFlag = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x4(%rsi), %rax
imulq $0x70, %rax, %rsi
addq 0x10(%rdi), %rsi
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0x5734
cmpb $0x0, 0x11(%r15)
je 0x4d2a
movslq -0x84(%rbp), %rax
movslq -0x80(%rbp), %rcx
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movq %rax, %rdx
shlq $0x4, %rdx
orq $0x8, %rdx
decq %rax
incq %rax
cmpq %rcx, %rax
jg 0x4d2e
movq 0x10(%rbx), %rsi
movapd %xmm0, %xmm2
subsd -0x8(%rsi,%rdx), %xmm2
movapd %xmm1, %xmm3
subsd (%rsi,%rdx), %xmm3
addq $0x10, %rdx
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
ucomisd 0x18(%r14), %xmm2
jbe 0x4cef
xorl %eax, %eax
jmp 0x4d30
movb $0x1, %al
movb %al, 0xc(%rbx)
leaq -0x88(%rbp), %rdi
callq 0x57ca
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setDistToRefer(Graph*, ReferencePath*)
void setDistToRefer(Graph* myGraph, ReferencePath* temPath)
{
	printf("Start calculating the shortest distance from each vertex to the reference path...\n");
	for (unsigned int i = 0; i < myGraph->vertexPos; i++)
	{
		double temDist = std::numeric_limits<double>::max();
		if (myGraph->vertexsVector[i].referFlag == true)
		{
			myGraph->vertexsVector[i].distToRefer = 0;
			continue;
		}
		for (unsigned int j = 0; j < temPath->edges.size(); j++)
		{
			double x  = myGraph->vertexsVector[i].longitude;
			double y  = myGraph->vertexsVector[i].latitude;
			double x1 = myGraph->vertexsVector[temPath->edges[j].firstVertexID].longitude;
			double y1 = myGraph->vertexsVector[temPath->edges[j].firstVertexID].latitude;
			double x2 = myGraph->vertexsVector[temPath->edges[j].secVertexID].longitude;
			double y2 = myGraph->vertexsVector[temPath->edges[j].secVertexID].latitude;
			double dist = pointToSegDist(x, y, x1, y1, x2, y2);
			temDist = dist < temDist ? dist : temDist;
		}
		myGraph->vertexsVector[i].distToRefer = temDist;
	}
	printf("The shortest distance from each vertex to the reference path is calculated!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rbx
leaq 0x57ee(%rip), %rdi      # 0xa557
callq 0x21a0
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
movq %rbx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
cmpq %rax, %rcx
je 0x4e42
movq 0x10(%rbx), %r13
imulq $0x70, %rcx, %rdx
leaq (%rdx,%r13), %r14
cmpb $0x0, 0x10(%r13,%rdx)
je 0x4da2
andq $0x0, 0x28(%r14)
jmp 0x4e3a
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq 0x20(%rax), %r15
movq 0x28(%rax), %r12
subq %r15, %r12
sarq $0x5, %r12
xorl %eax, %eax
movsd 0x5389(%rip), %xmm0     # 0xa150
movl %eax, %ebx
cmpq %rbx, %r12
jbe 0x4e23
movsd %xmm0, -0x58(%rbp)
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rax
shlq $0x5, %rax
movslq 0x4(%r15,%rax), %rcx
imulq $0x70, %rcx, %rcx
movsd 0x18(%r13,%rcx), %xmm2
movsd 0x20(%r13,%rcx), %xmm3
movslq 0x8(%r15,%rax), %rax
imulq $0x70, %rax, %rax
movsd 0x18(%r13,%rax), %xmm4
movsd 0x20(%r13,%rax), %xmm5
callq 0x4aa0
minsd -0x58(%rbp), %xmm0
leal 0x1(%rbx), %eax
jmp 0x4dc7
movq -0x48(%rbp), %rax
movsd %xmm0, 0x28(%r13,%rax)
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
incq %rcx
jmp 0x4d7b
leaq 0x5760(%rip), %rdi      # 0xa5a9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setTraversalOrderWeights(Graph*, ReferencePath*)
void setTraversalOrderWeights(Graph* myGraph, ReferencePath* temPath)
{
	const double x1 = myGraph->vertexsVector[temPath->finalVertex].longitude;
	const double y1 = myGraph->vertexsVector[temPath->finalVertex].latitude;
	double maxEuc = 0.0;
	for (unsigned int i = 0; i < myGraph->vertexPos; i++)
	{
		if (myGraph->vertexsVector[i].locationFlag == true)
		{
			const double x2 = myGraph->vertexsVector[i].longitude;
			const double y2 = myGraph->vertexsVector[i].latitude;
			double eucLength = euc(x1, y1, x2, y2);
			myGraph->vertexsVector[i].eucLengthToFinalVertex = eucLength;
			maxEuc = (std::max)(maxEuc, eucLength);
		}
	}
	for (unsigned int i = 0; i < myGraph->vertexPos; i++)
	{
		if (myGraph->vertexsVector[i].locationFlag == true)
		{
			double firstHalf = (myGraph->vertexsVector[i].distToRefer);
			double secHalf   = (myGraph->vertexsVector[i].eucLengthToFinalVertex) / (maxEuc / (myGraph->delta));
			double temWeights = (0.5) * firstHalf+ (0.5) * secHalf;
			myGraph->vertexsVector[i].traversalOrderWeights = temWeights;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
movslq 0x4(%rsi), %rcx
imulq $0x70, %rcx, %rcx
movsd 0x18(%rax,%rcx), %xmm1
movsd 0x20(%rax,%rcx), %xmm2
movl 0x4(%rdi), %ecx
imulq $0x70, %rcx, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4ec9
cmpb $0x1, 0x11(%rax,%rdx)
jne 0x4ec3
movapd %xmm1, %xmm3
subsd 0x18(%rax,%rdx), %xmm3
movapd %xmm2, %xmm4
subsd 0x20(%rax,%rdx), %xmm4
mulsd %xmm4, %xmm4
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
sqrtsd %xmm3, %xmm3
movsd %xmm3, 0x30(%rax,%rdx)
maxsd %xmm0, %xmm3
movapd %xmm3, %xmm0
addq $0x70, %rdx
jmp 0x4e85
xorl %edx, %edx
movsd 0x5285(%rip), %xmm1     # 0xa158
cmpq %rdx, %rcx
je 0x4f10
cmpb $0x1, 0x11(%rax,%rdx)
jne 0x4f0a
movsd 0x30(%rax,%rdx), %xmm2
movapd %xmm0, %xmm3
divsd 0x18(%rdi), %xmm3
divsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
movsd 0x28(%rax,%rdx), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x38(%rax,%rdx)
addq $0x70, %rdx
jmp 0x4ed3
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: setEdgeLength(Graph*, Edge*)
void setEdgeLength(Graph* myGraph, Edge* temEdge)
{
	double px = myGraph->vertexsVector[temEdge->firstVertexID].longitude;
	double py = myGraph->vertexsVector[temEdge->firstVertexID].latitude;
	double qx = myGraph->vertexsVector[temEdge->secVertexID].longitude;
	double qy = myGraph->vertexsVector[temEdge->secVertexID].latitude;
	double x = px - qx;
	double y = py - qy;
	temEdge->length = sqrt(x * x + y * y);
	temEdge->realLength = realDistance(x, y, py);
	// printf("%lf %lf %lf\n", x, y, py);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %rax
movslq 0x4(%rsi), %rcx
imulq $0x70, %rcx, %rcx
movsd 0x18(%rax,%rcx), %xmm3
movsd 0x20(%rax,%rcx), %xmm0
movslq 0x8(%rsi), %rcx
imulq $0x70, %rcx, %rcx
subsd 0x18(%rax,%rcx), %xmm3
movapd %xmm0, %xmm1
subsd 0x20(%rax,%rcx), %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd %xmm1, %xmm1
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
sqrtsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsi)
mulsd 0x51d4(%rip), %xmm3     # 0xa148
movsd %xmm3, -0x10(%rbp)
callq 0x2210
mulsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd 0x51b8(%rip), %xmm1     # 0xa148
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: writeContinuousRecordToFile(Record*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
void writeContinuousRecordToFile(Record record[], const unsigned int recordPos, const string filePath, double totalRunTime)
{
	FILE* fp = fopen(filePath.c_str(), "w");
	if (!fp)
	{
		printf("Error writing record infomation!!!\n");
	}
	else
	{
		int i = 0;
		while (i < recordPos)
		{
			fprintf(fp, "%lf\t", record[i].ratioNumEdge);
			fprintf(fp, "%lf\t", totalRunTime);
			fprintf(fp, "%d\t",  i + 1);
			fprintf(fp, "%d\t",  record[i].comPathSize);
			fprintf(fp, "%d\t",  record[i].numOfOutPriQueue);
			fprintf(fp, "%lf\t", record[i].referPathLength);
			fprintf(fp, "%lf\t", record[i].ratioPathLength);
			fprintf(fp, "%lf\t", record[i].currPathLength);
			fprintf(fp, "%lf\n", record[i].comPathLength);
			i++;
		}
	}
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x38(%rbp)
movl %esi, %r15d
movq %rdi, %r14
movq (%rdx), %rdi
leaq 0x4ff7(%rip), %rsi      # 0xa182
callq 0x2130
movq %rax, %rbx
testq %rax, %rax
je 0x5291
movl %r15d, %eax
imulq $0x50, %rax, %rax
movq %rax, -0x40(%rbp)
pushq $0x1
popq %rax
movl %eax, -0x2c(%rbp)
xorl %r13d, %r13d
cmpq %r13, -0x40(%rbp)
je 0x529d
movsd 0x38(%r14,%r13), %xmm0
movq %rbx, %rdi
leaq 0x4fb9(%rip), %r15      # 0xa184
movq %r15, %rsi
movb $0x1, %al
callq 0x2170
movq %rbx, %rdi
movq %r15, %rsi
movsd -0x38(%rbp), %xmm0
movb $0x1, %al
callq 0x2170
movq %rbx, %rdi
leaq 0x4f98(%rip), %r12      # 0xa189
movq %r12, %rsi
movl -0x2c(%rbp), %r15d
movl %r15d, %edx
xorl %eax, %eax
callq 0x2170
movl 0x14(%r14,%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2170
movl 0x10(%r14,%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2170
movsd 0x48(%r14,%r13), %xmm0
movq %rbx, %rdi
leaq 0x4f4d(%rip), %r12      # 0xa184
movq %r12, %rsi
movb $0x1, %al
callq 0x2170
movsd 0x40(%r14,%r13), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x2170
movsd 0x28(%r14,%r13), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x2170
movsd 0x30(%r14,%r13), %xmm0
movq %rbx, %rdi
leaq 0x4f17(%rip), %rsi      # 0xa191
movb $0x1, %al
callq 0x2170
addq $0x50, %r13
incl %r15d
movl %r15d, -0x2c(%rbp)
jmp 0x51b0
leaq 0x5397(%rip), %rdi      # 0xa62f
callq 0x21a0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: handleNewPath(Graph*, TraversingPath*, TraversingPath*, int)
void handleNewPath(Graph* myGraph, TraversingPath* oldPath, TraversingPath* newPath, const int newVertexID)
{
	printf("Start processing new Traversingpath...\n");
	(*newPath) = (*oldPath);
	const Vertex finalVertex = myGraph->vertexsVector[oldPath->finalVertexID];
	const Vertex newVertex   = myGraph->vertexsVector[newVertexID];
	newPath->edges.push_back(findEdge(myGraph, newVertex, finalVertex).edgeID);
	newPath->finalVertexID = newVertexID;
	newPath->distToRefer   = std::max(newPath->distToRefer, newVertex.distToRefer);
	if (newPath->minPos < newVertex.minPos)
	{
		newPath->minPos = newVertex.minPos;
	}
	newPath->maxPos = newVertex.maxPos;
	printf("Processing the new Traversingpath is complete!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x5328(%rip), %rdi      # 0xa652
callq 0x21a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x57ee
movslq 0x8(%r12), %rax
imulq $0x70, %rax, %rsi
addq 0x10(%r15), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x5734
movslq %r14d, %rax
imulq $0x70, %rax, %rsi
addq 0x10(%r15), %rsi
leaq -0x98(%rbp), %rdi
callq 0x5734
leaq -0x178(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x5734
leaq -0x108(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x5734
leaq 0x28(%rbx), %r12
leaq -0x208(%rbp), %r13
leaq -0x178(%rbp), %rdx
leaq -0x108(%rbp), %rcx
movq %r13, %rdi
movq %r15, %rsi
callq 0x52b3
movq %r12, %rdi
movq %r13, %rsi
callq 0x5baa
leaq -0x108(%rbp), %rdi
callq 0x57ca
leaq -0x178(%rbp), %rdi
callq 0x57ca
movl %r14d, 0x8(%rbx)
movsd -0x70(%rbp), %xmm0
maxsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x10(%rbx)
movl -0x94(%rbp), %eax
cmpl %eax, (%rbx)
jge 0x53f6
movl %eax, (%rbx)
leaq -0x98(%rbp), %r14
movl 0x8(%r14), %eax
movl %eax, 0x4(%rbx)
leaq 0x526e(%rip), %rdi      # 0xa679
callq 0x21a0
movq %r14, %rdi
callq 0x57ca
leaq -0x1e8(%rbp), %rdi
callq 0x57ca
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x57ca
jmp 0x544a
movq %rax, %rbx
leaq -0x178(%rbp), %rdi
callq 0x57ca
jmp 0x545b
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x57ca
jmp 0x546c
movq %rax, %rbx
leaq -0x1e8(%rbp), %rdi
callq 0x57ca
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: checkIfAccess(Graph*, TraversingPath*, int)
bool checkIfAccess(Graph* myGraph, TraversingPath* temPath, const int vertexID)
{
	for (unsigned int i = 0; i < temPath->edges.size(); i++)
	{
		int firstVertexID = myGraph->edgesVector[temPath->edges[i]].firstVertexID;
		int secVertexID   = myGraph->edgesVector[temPath->edges[i]].secVertexID;
		if ((firstVertexID == vertexID) || (secVertexID == vertexID))
		{
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rsi), %rcx
movq 0x30(%rsi), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %r10d, %r10d
movl %r10d, %esi
cmpq %rsi, %rax
jbe 0x54bc
movq 0x8(%rdi), %r8
movslq (%rcx,%rsi,4), %r9
shlq $0x5, %r9
cmpl %edx, 0x4(%r8,%r9)
je 0x54bc
leal 0x1(%rsi), %r10d
cmpl %edx, 0x8(%r8,%r9)
jne 0x5496
cmpq %rsi, %rax
setbe %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: replacePath(std::vector<Edge, std::allocator<Edge>>&, std::vector<Edge, std::allocator<Edge>>&, int, int)
void replacePath(std::vector<Edge>& lastPath, std::vector<Edge>& localPath, const int startPos, const int stopPos)
{

	std::vector<Edge> temPath;
	for (unsigned int i = 0; i < startPos; i++)
	{
		temPath.push_back(lastPath[i]);
	}
	for (unsigned int i = 0; i < localPath.size(); i++)
	{
		temPath.push_back(localPath[i]);
	}
	for (unsigned int i = stopPos; i < lastPath.size(); i++)
	{
		temPath.push_back(lastPath[i]);
	}
	lastPath.clear();
	for (unsigned int i = 0; i < temPath.size(); i++)
	{
		lastPath.push_back(temPath[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
movl %edx, %r13d
shlq $0x5, %r13
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x5511
movq (%rbx), %rsi
addq %r12, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4066
addq $0x20, %r12
jmp 0x54f7
xorl %r13d, %r13d
leaq -0x40(%rbp), %r12
movl %r13d, %r13d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x5545
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r12, %rdi
callq 0x4066
incl %r13d
jmp 0x5518
leaq -0x40(%rbp), %r15
movl %r14d, %r14d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
jbe 0x5579
movq %r14, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x4066
incl %r14d
jmp 0x5549
cmpq %rsi, %rax
je 0x5582
movq %rsi, 0x8(%rbx)
xorl %r14d, %r14d
movl %r14d, %r14d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x55b3
movq %r14, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x4066
incl %r14d
jmp 0x5585
leaq -0x40(%rbp), %rdi
callq 0x4092
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55d1
jmp 0x55d1
jmp 0x55d1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4092
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: updateLastPath(std::vector<Edge, std::allocator<Edge>>&, std::vector<Edge, std::allocator<Edge>>&, double*, double*)
void updateLastPath(std::vector<Edge>& lastPath, std::vector<Edge>& temLastPath, double* boundDistance, double* temBoundDistance)
{
	lastPath.clear();
	for (unsigned int j = 0; j < temLastPath.size(); j++)
	{
		lastPath.push_back(temLastPath[j]);
	}
	(*boundDistance) = (*temBoundDistance);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x560d
movq %rax, 0x8(%r12)
xorl %eax, %eax
movl %eax, %r13d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x563d
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r12, %rdi
callq 0x4066
leal 0x1(%r13), %eax
jmp 0x560f
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: (anonymous namespace)::getPathLength(std::vector<Edge, std::allocator<Edge>> const&)
double getPathLength(const std::vector<Edge>& temPath)
{
	double temLength = 0.0;
	for (unsigned int i = 0; i < temPath.size(); i++)
	{
		temLength += temPath[i].realLength;
	}
	return temLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x56d1
movq %rdx, %rsi
shlq $0x5, %rsi
addsd 0x18(%rax,%rsi), %xmm0
incl %edx
jmp 0x56b9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Construct.cpp
// Function: readVertexs(Graph*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void readVertexs(Graph* myGraph, const std::string nodeFilePath)
{
	printf("Reading vertex information from file...\n");
	int   count = 0;
	char  line[100];
	FILE* fp;
	char* p;
	fp = fopen(nodeFilePath.c_str(), "r");
	if (!fp)
	{
		printf("Error when reading vertex file...\n");
	}
	else
	{
		myGraph->vertexPos = 0;
		while (fgets(line, 100, fp) != NULL)
		{
			p = strtok(line, " |\t");
			int ID = atoi(p);
			p = strtok(NULL, " |\t");
			double latitude = atof(p);
			p = strtok(NULL, " |\t");
			double longitude = atof(p);
			myGraph->vertexsVector[myGraph->vertexPos].vertexID  = ID;
			myGraph->vertexsVector[myGraph->vertexPos].longitude = longitude;
			myGraph->vertexsVector[myGraph->vertexPos].latitude  = latitude;
			myGraph->vertexPos += 1;
			count++;
		}
	}
	fclose(fp);
	printf("Finish reading vertex information from file---A total of %d vertex are read!!!\n", count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4b69(%rip), %rdi      # 0xa81b
callq 0x21a0
movq (%rbx), %rdi
leaq 0x4ab8(%rip), %rsi      # 0xa779
callq 0x2130
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x5d67
andl $0x0, 0x4(%r14)
xorl %r15d, %r15d
leaq -0xa0(%rbp), %r12
leaq 0x4a92(%rip), %r13      # 0xa77b
movq %r12, %rdi
pushq $0x64
popq %rsi
movq -0x30(%rbp), %rdx
callq 0x21d0
testq %rax, %rax
je 0x5d76
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x21b0
movl %eax, %ebx
xorl %edi, %edi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2140
movsd %xmm0, -0x38(%rbp)
xorl %edi, %edi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2140
movq 0x10(%r14), %rax
movslq 0x4(%r14), %rcx
imulq $0x70, %rcx, %rdx
movl %ebx, (%rax,%rdx)
movsd %xmm0, 0x18(%rax,%rdx)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x20(%rax,%rdx)
leal 0x1(%rcx), %eax
movl %eax, 0x4(%r14)
incl %r15d
jmp 0x5ce9
leaq 0x4ad5(%rip), %rdi      # 0xa843
callq 0x21a0
xorl %r15d, %r15d
movq -0x30(%rbp), %rdi
callq 0x2100
leaq 0x49f9(%rip), %rdi      # 0xa77f
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Construct.cpp
// Function: readReferencePath(Graph*, ReferencePath*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void readReferencePath(Graph* myGraph, ReferencePath* referencePath, const std::string referFilePath)
{
	printf("Reading reference path information from file...\n");
	int   count = 0;
	char  line[200];
	FILE* fp;
	char* p;
	fp = fopen(referFilePath.c_str(), "r");
	if (!fp)
	{
		printf("Error when reading reference path file...\n");
	}
	else
	{
		while (fgets(line, 200, fp) != NULL)
		{
			p = strtok(line, " |\t");
			int pos = atoi(p);
			referencePath->edges.push_back(myGraph->edgesVector[pos]);
			myGraph->vertexsVector[myGraph->edgesVector[pos].firstVertexID].referFlag = true;
			myGraph->vertexsVector[myGraph->edgesVector[pos].secVertexID].referFlag   = true;
			count++;
		}
	}
	fclose(fp);
	printf("Finish reading reference path information from file!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4962(%rip), %rdi      # 0xa8ab
callq 0x21a0
movq (%r15), %rdi
leaq 0x4821(%rip), %rsi      # 0xa779
callq 0x2130
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x5fe0
addq $0x20, %rbx
movq %rbx, %r15
leaq -0x100(%rbp), %r12
movb $0x1, %r13b
movq %r12, %rdi
movl $0xc8, %esi
movq -0x30(%rbp), %rdx
callq 0x21d0
testq %rax, %rax
je 0x5fec
movq %r12, %rdi
leaq 0x47e4(%rip), %rsi      # 0xa77b
callq 0x21c0
movq %rax, %rdi
callq 0x21b0
movslq %eax, %rbx
shlq $0x5, %rbx
movq 0x8(%r14), %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x4066
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movslq 0x4(%rax,%rbx), %rdx
imulq $0x70, %rdx, %rdx
movb %r13b, 0x10(%rcx,%rdx)
movslq 0x8(%rax,%rbx), %rax
imulq $0x70, %rax, %rax
movb %r13b, 0x10(%rcx,%rax)
jmp 0x5f77
leaq 0x48f4(%rip), %rdi      # 0xa8db
callq 0x21a0
movq -0x30(%rbp), %rdi
callq 0x2100
leaq 0x4909(%rip), %rdi      # 0xa905
callq 0x21a0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Construct.cpp
// Function: readCompletePath(Graph*, CompletePath*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void readCompletePath(Graph* myGraph, CompletePath* completePath, const std::string comFilePath)
{
	int   count = 0;
	char  line[200];
	FILE* fp;
	char* p;
	fp = fopen(comFilePath.c_str(), "r");
	if (!fp)
	{
		printf("Error when reading complete path file...\n");
	}
	else
	{
		while (fgets(line, 200, fp) != NULL)
		{
			p = strtok(line, " |\t");
			int pos = atoi(p);
			completePath->edges.push_back(myGraph->edgesVector[pos]);
			count++;
		}
	}
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
leaq 0x4742(%rip), %rsi      # 0xa779
callq 0x2130
movq %rax, %rbx
testq %rax, %rax
je 0x6093
addq $0x10, %r14
leaq -0xf0(%rbp), %r12
leaq 0x4725(%rip), %r13      # 0xa77b
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
callq 0x21d0
testq %rax, %rax
je 0x609f
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x21b0
movslq %eax, %rsi
shlq $0x5, %rsi
addq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x4066
jmp 0x6056
leaq 0x48a2(%rip), %rdi      # 0xa93c
callq 0x21a0
movq %rbx, %rdi
callq 0x2100
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Discrete.cpp
// Function: discreteReferPath(Graph*, ReferencePath*)
void discreteReferPath(Graph* myGraph, ReferencePath* temPath)
{
	// printf("Start discretizing the reference path...\n");
	temPath->numOfReferPoint = 0;
	std::vector<Point> pointList;
	pointList = creatTrajPoint(myGraph, temPath->edges, temPath->initialVertex);
	for (unsigned int i = 0; i < pointList.size(); i++)
	{
		temPath->pointOfRefer[i].x = pointList[i].x;
		temPath->pointOfRefer[i].y = pointList[i].y;
		temPath->numOfReferPoint += 1;
	}
	// printf("Discretization of the reference path completed!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
andl $0x0, 0x8(%rsi)
movq %rdi, %rsi
andq $0x0, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
leaq 0x20(%rbx), %rdx
movl (%rbx), %ecx
leaq -0x48(%rbp), %rdi
callq 0x6170
leaq -0x30(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x63ca
movq %r15, %rdi
callq 0x63b6
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x6148
movq %rdx, %rsi
shlq $0x4, %rsi
movsd (%rax,%rsi), %xmm0
movq 0x10(%rbx), %rdi
movsd %xmm0, (%rdi,%rsi)
movsd 0x8(%rax,%rsi), %xmm0
movsd %xmm0, 0x8(%rdi,%rsi)
incl 0x8(%rbx)
incl %edx
jmp 0x6119
leaq -0x30(%rbp), %rdi
callq 0x63b6
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x63b6
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Frechet.cpp
// Function: DFD(Graph*, std::vector<Edge, std::allocator<Edge>>, ReferencePath*)
double DFD(Graph* myGraph, std::vector<Edge> finalPath, ReferencePath* referencePath)
{
	std::vector<Point> temPointList;
	temPointList = creatTrajPoint(myGraph, finalPath, referencePath->initialVertex);
	Point p[temPointList.size()];
	for (unsigned int i = 0; i < temPointList.size(); i++)
	{
		p[i].x = temPointList[i].x;
		p[i].y = temPointList[i].y;
	}
	double temDist = dfdDist(temPointList.size(), referencePath->numOfReferPoint, p, referencePath->pointOfRefer);
	return temDist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movl (%rbx), %ecx
leaq -0x58(%rbp), %rdi
callq 0x6170
leaq -0x40(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x63ca
movq %r15, %rdi
callq 0x63b6
movq %rsp, %r15
movq (%r14), %rax
subq 0x8(%r14), %rax
movq %rsp, %rdx
addq %rax, %rdx
movq %rdx, %rsp
movq (%r14), %rax
movq 0x8(%r14), %rdi
subq %rax, %rdi
sarq $0x4, %rdi
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rdi
jbe 0x6ad3
movq %rcx, %rsi
shlq $0x4, %rsi
movsd (%rax,%rsi), %xmm0
movsd %xmm0, (%rdx,%rsi)
movsd 0x8(%rax,%rsi), %xmm0
movsd %xmm0, 0x8(%rdx,%rsi)
incl %ecx
jmp 0x6aab
movl 0x8(%rbx), %esi
movq 0x10(%rbx), %rcx
callq 0x658c
movsd %xmm0, -0x20(%rbp)
movq %r15, %rsp
leaq -0x40(%rbp), %rdi
callq 0x63b6
movsd -0x20(%rbp), %xmm0
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b02
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x63b6
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Proudc[P]CTSS/src/ContinuousQuery/Frechet.cpp
// Function: dfdBetweenTwoLocalPaths(Graph*, std::vector<Edge, std::allocator<Edge>>&, std::vector<Edge, std::allocator<Edge>>&, int)
double dfdBetweenTwoLocalPaths(Graph* myGraph, std::vector<Edge>& firstPath, std::vector<Edge>& secPath, int initialVertex)
{
	std::vector<Point> firstPointList;
	std::vector<Point> secPointList;
	firstPointList = creatTrajPoint(myGraph, firstPath, initialVertex);
	secPointList   = creatTrajPoint(myGraph, secPath, initialVertex);
	Point p[firstPointList.size()];
	Point q[secPointList.size()];
	for (unsigned int i = 0; i < firstPointList.size(); i++)
	{
		p[i].x = firstPointList[i].x;
		p[i].y = firstPointList[i].y;
	}
	for (unsigned int i = 0; i < secPointList.size(); i++)
	{
		q[i].x = secPointList[i].x;
		q[i].y = secPointList[i].y;
	}
	return dfdDist(firstPointList.size(), secPointList.size(), p, q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movaps %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x6170
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %r12
movq %r12, %rsi
callq 0x63ca
movq %r12, %rdi
callq 0x63b6
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x6170
leaq -0x60(%rbp), %rbx
leaq -0x78(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63ca
movq %r14, %rdi
callq 0x63b6
movq %rsp, %r14
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rsp, %rdx
addq %rax, %rdx
movq %rdx, %rsp
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rsi
movq %rsp, %rcx
subq %rsi, %rcx
sarq $0x4, %rsi
movq %rcx, %rsp
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %rdi
subq %r8, %rdi
sarq $0x4, %rdi
xorl %r9d, %r9d
movl %r9d, %r9d
cmpq %r9, %rdi
jbe 0x6c00
movq %r9, %r10
shlq $0x4, %r10
movsd (%r8,%r10), %xmm0
movsd %xmm0, (%rdx,%r10)
movsd 0x8(%r8,%r10), %xmm0
movsd %xmm0, 0x8(%rdx,%r10)
incl %r9d
jmp 0x6bd2
xorl %r8d, %r8d
movl %r8d, %r8d
cmpq %r8, %rsi
jbe 0x6c31
movq %r8, %r9
shlq $0x4, %r9
movsd (%rax,%r9), %xmm0
movsd %xmm0, (%rcx,%r9)
movsd 0x8(%rax,%r9), %xmm0
movsd %xmm0, 0x8(%rcx,%r9)
incl %r8d
jmp 0x6c03
callq 0x658c
movsd %xmm0, -0x48(%rbp)
movq %r14, %rsp
leaq -0x60(%rbp), %rdi
callq 0x63b6
leaq -0x40(%rbp), %rdi
callq 0x63b6
movsd -0x48(%rbp), %xmm0
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c66
jmp 0x6c66
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x63b6
leaq -0x40(%rbp), %rdi
callq 0x63b6
movq %rbx, %rdi
callq 0x2200
nop