LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildytrees(BinaryRangeNode*, BinaryRangeTree*)
void BinaryRangeTree::buildytrees(BinaryRangeNode *r, BinaryRangeTree* temp_tree) {
	int i;
	if (r != NULL)
             {
		for (i=0; i<r->data2.size(); i++)
			 temp_tree->insert(r->data2[i], r->data, r->lines[i]);
                 buildytrees(r->left, temp_tree);
                 buildytrees(r->right, temp_tree);
             }
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x774f
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x7725
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x37a0
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq (%rax), %rcx
callq 0x6b40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x76ae
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7680
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7680
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::findSplitNode(BinaryRangeNode*, int, int)
BinaryRangeNode* BinaryRangeTree::findSplitNode(BinaryRangeNode* tree, int x1, int x2) {
	BinaryRangeNode *r = root;
	while (!isLeaf(r) & (r->data > x2 || r->data < x1)) {
		if  (r->data >= x1)
			r = r->left;
		else
			r = r->right;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7870
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movb $0x1, %al
cmpl -0x18(%rbp), %ecx
movb %al, -0x29(%rbp)
jg 0x781d
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x29(%rbp)
movl -0x30(%rbp), %eax
movb -0x29(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7858
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jl 0x784a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7856
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x77e5
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::isLeaf(BinaryRangeNode*)
bool BinaryRangeTree::isLeaf(BinaryRangeNode* r) {
	if (r == NULL)
		return 1;
	if (r->left == NULL & r->right == NULL)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7889
movb $0x1, -0x1(%rbp)
jmp 0x78bd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0x28(%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x78b9
movb $0x1, -0x1(%rbp)
jmp 0x78bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::findSplitNodeYtree(BinaryRangeNode*, int, int)
BinaryRangeNode* BinaryRangeTree::findSplitNodeYtree(BinaryRangeNode* tree, int x1, int x2) {
	BinaryRangeNode *r = tree;
	while (!isLeaf(r) & (r->data > x2 || r->data < x1)) {
		if  (r->data >= x1) {
			r = r->left;
			if (r == NULL)
				return NULL;
		}
		else {
			r = r->right;
			if (r == NULL)
				return NULL;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7870
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movb $0x1, %al
cmpl -0x20(%rbp), %ecx
movb %al, -0x31(%rbp)
jg 0x792e
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movl -0x38(%rbp), %eax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7990
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
jl 0x796c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x796a
movq $0x0, -0x8(%rbp)
jmp 0x7998
jmp 0x798b
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7989
movq $0x0, -0x8(%rbp)
jmp 0x7998
jmp 0x798b
jmp 0x78f6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::reportPoint(BinaryRangeNode*)
void BinaryRangeTree::reportPoint(BinaryRangeNode *r) {
	int i;	
	for (i=0; i< r->data2.size(); i++) {
		if (r->lines[i]->reported != 1) {
			r->lines[i]->reported = 1;
			cout << " OP4 { (" << r->lines[i]->x1 << " " << r->lines[i]->y1 << ") -- (" << r->lines[i]->x2 << " " << r->lines[i]->y2 << ") } " << endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x7b66
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq (%rax), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7b56
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq (%rax), %rax
movb $0x1, 0x10(%rax)
movq 0x6568(%rip), %rdi      # 0xdfd8
leaq 0x25e1(%rip), %rsi      # 0xa058
callq 0x2100
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2565(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2570(%rip), %rsi      # 0xa04c
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x24ff(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2511(%rip), %rsi      # 0xa053
callq 0x2100
movq %rax, %rdi
movq 0x6477(%rip), %rsi      # 0xdfc8
callq 0x2120
jmp 0x7b58
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a07
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::reportPointYtree(BinaryRangeNode*)
void BinaryRangeTree::reportPointYtree(BinaryRangeNode *r) {
	int i;	
	for (i=0; i< r->data2.size(); i++)	 {
		if (r->lines[i]->reported != 1) {
			cout << " OP2 { (" << r->lines[i]->x1 << " " << r->lines[i]->y1 << ") -- (" << r->lines[i]->x2 << " " << r->lines[i]->y2 << ") } " << endl;
			r->lines[i]->reported = 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x7ce6
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq (%rax), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7cd6
movq 0x6400(%rip), %rdi      # 0xdfd8
leaq 0x2482(%rip), %rsi      # 0xa061
callq 0x2100
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x23fd(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2408(%rip), %rsi      # 0xa04c
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2397(%rip), %rsi      # 0xa00e
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x23a9(%rip), %rsi      # 0xa053
callq 0x2100
movq %rax, %rdi
movq 0x630f(%rip), %rsi      # 0xdfc8
callq 0x2120
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x34d0
movq (%rax), %rax
movb $0x1, 0x10(%rax)
jmp 0x7cd8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7b87
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildRangeTree(std::vector<Line, std::allocator<Line>>, BinaryRangeTree*)
BinaryRangeTree* BinaryRangeTree::buildRangeTree(vector<Line> lines, BinaryRangeTree* sbbst) {
	int i;
	for (i=0; i < lines.size() ; i++) {
		sbbst->insert(lines[i].x1, lines[i].y1, &lines[i]);
		sbbst->insert(lines[i].x2, lines[i].y2, &lines[i]);
	}
	sbbst->buildytrees();
	cout << "\n query " << endl;
	sbbst->twodquery(0, 4, 0, 4);
	return sbbst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x88c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x8587
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x28(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movq %rax, %rcx
callq 0x6b40
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x28(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x28(%rbp), %rdi
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x88f0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq %rax, %rcx
callq 0x6b40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x84bf
movq -0x18(%rbp), %rdi
callq 0x75b0
movq 0x5a41(%rip), %rdi      # 0xdfd8
leaq 0x1ad5(%rip), %rsi      # 0xa073
callq 0x2100
movq %rax, %rdi
movq 0x5a1b(%rip), %rsi      # 0xdfc8
callq 0x2120
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl $0x4, %r8d
movl %ecx, %esi
movl %r8d, %edx
callq 0x82d0
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildRangeTreeEndPoints(BinaryRangeTree*, std::vector<Line*, std::allocator<Line*>>)
BinaryRangeTree* BinaryRangeTree::buildRangeTreeEndPoints(BinaryRangeTree *sbbst, vector<Line*> lines) {
	int i;
	for (i=0; i < lines.size() ; i++) {
		sbbst->insert(lines[i]->x1, lines[i]->y1, lines[i]);
		sbbst->insert(lines[i]->x2, lines[i]->y2, lines[i]);
	}
	sbbst->buildytrees();
	return sbbst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3440
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x86d3
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movq (%rax), %rcx
callq 0x6b40
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq (%rax), %rcx
callq 0x6b40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x85ff
movq -0x10(%rbp), %rdi
callq 0x75b0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildRangeTree2(BinaryRangeTree*, std::vector<Line*, std::allocator<Line*>>)
BinaryRangeTree* BinaryRangeTree::buildRangeTree2(BinaryRangeTree *sbbst, vector<Line*> lines) {
	int i;
	for (i=0; i < lines.size() ; i++) {
		sbbst->insert(lines[i]->x1, lines[i]->y1, lines[i]);
		sbbst->insert(lines[i]->x2, lines[i]->y2, lines[i]);
	}
	sbbst->buildytrees();
	return sbbst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3440
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x87e3
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movq (%rax), %rcx
callq 0x6b40
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x34d0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq (%rax), %rcx
callq 0x6b40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x870f
movq -0x10(%rbp), %rdi
callq 0x75b0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: meghanamreddy[P]Range-trees-and-Interval-Trees/./binaryRangeTree.h
// Function: BinaryRangeNode::BinaryRangeNode(int, int, Line*)
BinaryRangeNode(int n, int m, Line *l)
         {
             left = NULL;
             right = NULL;
             data = n;
			 ytree = NULL;
			 data2.push_back(m);
             height = 0;
			 lines.push_back(l);
         }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3420
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x40(%rbp)
callq 0x37e0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq $0x0, 0x30(%rax)
leaq -0x10(%rbp), %rsi
callq 0x3460
jmp 0x886d
movq -0x38(%rbp), %rdi
movl $0x0, (%rdi)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3800
jmp 0x8886
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x36f0
movq -0x30(%rbp), %rdi
callq 0x35a0
movq -0x20(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Se6[P]CmdLineArgs/test.cpp
// Function: main
int main(int argc, char**argv) {

    int nbFails = 0;

    // test 1
    const char* argv1[] = {"test", "-hv", "--nb", "12", "--name",  "hello me", "--ratio", "0.25", "--num", "3,4", "remain", "-v" };
    int argc1 = nelem(argv1);
    fixTest(1, argc1, argv1, nbFails);
        
    // test 2
    const char* argv2[] = {"test", "remain", "-vhv", "--nb", "0xC", "--name=hello me", "--ratio=0.250", "--num", "3,", "4"};
    int argc2 = nelem(argv2);
    fixTest(2, argc2, argv2, nbFails);
    
    // Test getParams in more depth
    getParamsTest(3, nbFails);
        
    if( nbFails ) {
        cout << nbFails << " test failed!\n";
        return 1;
    } else {
        cout << "All tests passed.\n";
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x119e5(%rip), %rsi     # 0x17cc0
movl $0x60, %edx
callq 0x3290
movl $0xc, -0x84(%rbp)
movl -0x84(%rbp), %esi
leaq -0x80(%rbp), %rdx
movl $0x1, %edi
leaq -0x14(%rbp), %rcx
callq 0x63b0
leaq -0xe0(%rbp), %rdi
leaq 0x11a0b(%rip), %rsi     # 0x17d20
movl $0x50, %edx
callq 0x3290
movl $0xa, -0xe4(%rbp)
movl -0xe4(%rbp), %esi
leaq -0xe0(%rbp), %rdx
movl $0x2, %edi
leaq -0x14(%rbp), %rcx
callq 0x63b0
movl $0x3, %edi
leaq -0x14(%rbp), %rsi
callq 0x77b0
cmpl $0x0, -0x14(%rbp)
je 0x637f
movl -0x14(%rbp), %esi
movq 0x11c66(%rip), %rdi     # 0x17fc8
callq 0x34e0
movq %rax, %rdi
leaq 0xadc6(%rip), %rsi      # 0x11137
callq 0x32e0
movl $0x1, -0x4(%rbp)
jmp 0x6399
movq 0x11c42(%rip), %rdi     # 0x17fc8
leaq 0xadb9(%rip), %rsi      # 0x11146
callq 0x32e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahnafraihan[P]BestFirstSearch/main.cpp
// Function: bound(int, int*, int*, int, node)
float bound(int n, int p[], int w[], int W, node u) {
    int j, k;
    int tw; //integer to hold total weight
    float bound; // upper bound return value
    
    if(u.weight >= W) //over maximum weight
        return 0;
    else {
        bound = (float)u.profit;
        j = u.level;
        tw = u.weight;
        while(j <= n && tw + w[j] <= W) { //add items
            tw = tw + w[j];
            bound = bound + p[j];
            ++j;
        }
        k = j;
        if(k < n) // take fraction of item
            bound = bound + (W - tw) * p[k]/w[k];
        return bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %r8, -0x40(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl 0x8(%r8), %eax
cmpl -0x1c(%rbp), %eax
jl 0x33a0
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3465
movq -0x40(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
movl (%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x41(%rbp)
jg 0x33dd
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
cmpl -0x1c(%rbp), %eax
setle %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x33e6
jmp 0x341d
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x34(%rbp)
movss -0x38(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cvtsi2ssl (%rax,%rcx,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x33b9
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x345b
movss -0x38(%rbp), %xmm0
movl -0x1c(%rbp), %eax
subl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x30(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x30(%rbp), %rsi
cltd
idivl (%rcx,%rsi,4)
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/test_cube.cpp
// Function: main
int main() {
   test_constructors();
   test_operators();
   test_getCubeSize();
   test_turns();

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x9f80
callq 0xa630
callq 0xb8c0
callq 0xba50
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq 0xa706(%rip), %rdi      # 0x15fd8
leaq 0x4ac9(%rip), %rsi      # 0x103a2
callq 0x2160
leaq -0x78(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x7a90
movq -0x110(%rbp), %rdi
callq 0x8240
movl %eax, -0x104(%rbp)
jmp 0xb902
movl -0x104(%rbp), %eax
cmpl $0x3, %eax
jne 0xb90f
jmp 0xb942
leaq 0x4aa4(%rip), %rdi      # 0x103ba
leaq 0x4a25(%rip), %rsi      # 0x10342
movl $0xae, %edx
leaq 0x4aa7(%rip), %rcx      # 0x103d0
callq 0x20e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xba35
movl $0x2, -0x88(%rbp)
cmpl $0xa, -0x88(%rbp)
jae 0xb9f2
movl -0x88(%rbp), %edx
leaq -0x100(%rbp), %rdi
movl $0x77, %esi
callq 0x7ce0
jmp 0xb972
leaq -0x100(%rbp), %rdi
callq 0x8240
movl %eax, -0x114(%rbp)
jmp 0xb986
movl -0x114(%rbp), %eax
cmpl -0x88(%rbp), %eax
jne 0xb996
jmp 0xb9d2
leaq 0x4a4b(%rip), %rdi      # 0x103e8
leaq 0x499e(%rip), %rsi      # 0x10342
movl $0xb2, %edx
leaq 0x4a20(%rip), %rcx      # 0x103d0
callq 0x20e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x8210
jmp 0xba35
leaq -0x100(%rbp), %rdi
callq 0x8210
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xb94c
movq 0xa5df(%rip), %rdi      # 0x15fd8
leaq 0x4919(%rip), %rsi      # 0x10319
callq 0x2160
movq %rax, -0x120(%rbp)
jmp 0xba0e
movq -0x120(%rbp), %rdi
movq 0xa5ac(%rip), %rsi      # 0x15fc8
callq 0x2190
jmp 0xba23
leaq -0x78(%rbp), %rdi
callq 0x8210
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x8210
movq -0x80(%rbp), %rdi
callq 0x2250
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8260
leaq -0x28(%rbp), %rdi
callq 0x9cb0
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x9cb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0xd327
jmp 0xd346
leaq 0x3175(%rip), %rdi      # 0x104a3
leaq 0x300d(%rip), %rsi      # 0x10342
movl $0x1c3, %edx            # imm = 0x1C3
leaq 0x3183(%rip), %rcx      # 0x104c4
callq 0x20e0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9cb0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0xd3f5
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xf3f0
movq %rax, -0x60(%rbp)
jmp 0xd381
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xf3f0
movq %rax, -0x68(%rbp)
jmp 0xd39f
movl -0x6c(%rbp), %eax
movq -0x68(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xd3af
jmp 0xd3e5
leaq 0x313e(%rip), %rdi      # 0x104f4
leaq 0x2f85(%rip), %rsi      # 0x10342
movl $0x1c5, %edx            # imm = 0x1C5
leaq 0x30fb(%rip), %rcx      # 0x104c4
callq 0x20e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x95e0
jmp 0xd404
jmp 0xd3e7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd34d
leaq -0x28(%rbp), %rdi
callq 0x95e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2250
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x72, %esi
movl $0x3, %edx
callq 0x7ce0
movq -0x68(%rbp), %rdi
movl $0x6, -0x14(%rbp)
movb $0x0, -0x10(%rbp)
movq -0x14(%rbp), %rsi
callq 0x85a0
jmp 0xe844
movq -0x68(%rbp), %rdi
movl $0x7, -0x2c(%rbp)
movb $0x1, -0x28(%rbp)
movq -0x2c(%rbp), %rsi
callq 0x85a0
jmp 0xe85e
movq -0x68(%rbp), %rdi
movl $0x1, -0x34(%rbp)
movb $0x0, -0x30(%rbp)
movq -0x34(%rbp), %rsi
callq 0x85a0
jmp 0xe878
movq -0x68(%rbp), %rdi
movl $0x4, -0x3c(%rbp)
movb $0x1, -0x38(%rbp)
movq -0x3c(%rbp), %rsi
callq 0x85a0
jmp 0xe892
movq -0x68(%rbp), %rdi
movl $0x5, -0x44(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x44(%rbp), %rsi
callq 0x85a0
jmp 0xe8ac
movq -0x68(%rbp), %rdi
movl $0x1, -0x4c(%rbp)
movb $0x1, -0x48(%rbp)
movq -0x4c(%rbp), %rsi
callq 0x85a0
jmp 0xe8c6
movq -0x68(%rbp), %rdi
movl $0x5, -0x54(%rbp)
movb $0x0, -0x50(%rbp)
movq -0x54(%rbp), %rsi
callq 0x85a0
jmp 0xe8e0
movq -0x68(%rbp), %rdi
movl $0x9, -0x5c(%rbp)
movb $0x1, -0x58(%rbp)
movq -0x5c(%rbp), %rsi
callq 0x85a0
jmp 0xe8fa
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xe926
jmp 0xe91d
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8210
jmp 0xe930
movq -0x68(%rbp), %rdi
callq 0x8210
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2250
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
leaq 0x12c32(%rip), %rdi     # 0x19138
movb $0x0, %al
callq 0x2040
movl $0x1005908, %edi        # imm = 0x1005908
callq 0x2030
movq $0x249f0, (%rax)        # imm = 0x249F0
addq $0x8, %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x1005900, %rcx        # imm = 0x1005900
movq %rcx, -0x88(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x8dd0
movq -0xa8(%rbp), %rax
movq -0x88(%rbp), %rcx
addq $0x70, %rax
cmpq %rcx, %rax
movq %rax, -0x80(%rbp)
jne 0x653e
movq -0x90(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x493e00, %edi         # imm = 0x493E00
callq 0x2030
movq -0xa0(%rbp), %rsi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2090
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xac60
jmp 0x65c4
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2090
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0xae30
jmp 0x6604
leaq -0x78(%rbp), %rdi
callq 0x20d0
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
leaq 0x12b2a(%rip), %rdi     # 0x1915a
movb $0x0, %al
callq 0x2040
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0x666c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: (anonymous namespace)::resetVertexFlag(Graph*)
void resetVertexFlag(Graph* myGraph)
{
	printf("Reset the flag of the vertex of the road network...\n");
	for (unsigned int i = 0; i < (myGraph->vertexPos); i++)
	{
		myGraph->vertexsVector[i].referFlag    = false;
		myGraph->vertexsVector[i].locationFlag = false;
		myGraph->vertexsVector[i].accessFlag   = false;
		myGraph->vertexsVector[i].currFlag     = false;
	}
	printf("The flag of the vertex of the road network is set!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x12b9c(%rip), %rdi     # 0x1955f
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x6a40
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x11(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x12(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x13(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x69d1
leaq 0x12b4d(%rip), %rdi     # 0x19594
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: (anonymous namespace)::initializeReferencePath(Graph*, ReferencePath*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void initializeReferencePath(Graph* myGraph, ReferencePath* temReferPath, const string referFilePath)
{
	printf("Initializing reference path...\n");
	temReferPath->pointOfRefer = new Point[POINT_OF_REFERPATH];
	readReferencePath(myGraph, temReferPath, referFilePath);
	setReferInitialAndFinal(temReferPath);
	discreteReferPath(myGraph, temReferPath);
	setReferDFDFlag(myGraph, temReferPath);
	temReferPath->referenceLength = getPathLength(temReferPath->edges);
	filterVertexIsSafeArea(myGraph, temReferPath);
	setMinPosAndMaxPos(myGraph, temReferPath);
	setDistToRefer(myGraph, temReferPath);
	setTraversalOrderWeights(myGraph, temReferPath);
	printf("The reference path is initialized!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x12b4b(%rip), %rdi     # 0x195ca
xorl %eax, %eax
callq 0x2040
movl $0x186a00, %edi         # imm = 0x186A00
callq 0x2030
movq -0x68(%rbp), %rsi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2090
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xb090
jmp 0x6acf
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x8a00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb310
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x77f0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8bb0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x70f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7530
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7940
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7bd0
leaq 0x12a9e(%rip), %rdi     # 0x195ea
movb $0x0, %al
callq 0x2040
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x40(%rbp), %rdi
callq 0x2240
nopw (%rax,%rax)
// File: Proudc[P]CTSS/src/ContinuousQuery/Base.cpp
// Function: (anonymous namespace)::initializeCompletePath(Graph*, CompletePath*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void initializeCompletePath(Graph* myGraph, CompletePath* temComPath, const string comFilePath)
{
	printf("Initialzing complete path...\n");
	readCompletePath(myGraph, temComPath, comFilePath);
	setComInitialAndFinal(temComPath);
	temComPath->completeLength = getPathLength(temComPath->edges);
	printf("The complete path is initialized...\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x12ad1(%rip), %rdi     # 0x19670
xorl %eax, %eax
callq 0x2040
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2090
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xb210
jmp 0x6bda
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x8c20
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8bb0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
leaq 0x12a85(%rip), %rdi     # 0x1968e
movb $0x0, %al
callq 0x2040
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x40(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x125b4(%rip), %rdi     # 0x19212
movb $0x0, %al
callq 0x2040
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x6d20
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5380
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x12(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x13(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x12(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x13(%rax)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x55f0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6c6c
leaq 0x1250d(%rip), %rdi     # 0x19234
movb $0x0, %al
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd 0x12151(%rip), %xmm0    # 0x19120
movsd %xmm0, -0x20(%rbp)
movsd 0x12144(%rip), %xmm0    # 0x19120
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2260
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x12117(%rip), %xmm0    # 0x19120
mulsd -0x10(%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 0x2120
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x5360
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x70de
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x5380
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x706f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm3
subsd -0x28(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x40(%rbp), %xmm0
jb 0x740c
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm3
subsd -0x28(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2120
movsd %xmm0, -0x8(%rbp)
jmp 0x7523
movsd -0x30(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movsd -0x38(%rbp), %xmm3
subsd -0x28(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jb 0x7494
movsd -0x10(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd -0x30(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
subsd -0x38(%rbp), %xmm1
movsd -0x18(%rbp), %xmm3
subsd -0x38(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2120
movsd %xmm0, -0x8(%rbp)
jmp 0x7523
movsd -0x40(%rbp), %xmm0
divsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x58(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
movsd -0x60(%rbp), %xmm3
subsd -0x18(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2120
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x8f20
movb -0x6f(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x783d
movq -0x10(%rbp), %rax
movb $0x0, 0xc(%rax)
jmp 0x792d
movl $0x0, -0x84(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x78(%rbp), %eax
jg 0x7910
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x88(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x88(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0x90(%rbp), %xmm0
movsd -0x98(%rbp), %xmm1
movsd -0xa0(%rbp), %xmm2
movsd -0xa8(%rbp), %xmm3
callq 0x7780
movq -0x8(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jbe 0x78fa
movl $0x1, -0x84(%rbp)
jmp 0x7910
jmp 0x78fc
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x7850
cmpl $0x1, -0x84(%rbp)
jne 0x7923
movq -0x10(%rbp), %rax
movb $0x0, 0xc(%rax)
jmp 0x792b
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
jmp 0x792d
leaq -0x80(%rbp), %rdi
callq 0x90a0
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2120
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
callq 0x6fb0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x90e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x872e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x9100
movq %rax, %rcx
movq -0x40(%rbp), %rax
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x9100
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x8718
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x871e
movb $0x0, -0x1(%rbp)
jmp 0x8732
jmp 0x8720
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x867a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)