LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/substrings.cc
// Function: write_substrings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float>>>&)
void write_substrings(const string &outfname,
                      vector<pair<string, float> > &sorted_substrs)
{
    ofstream outfile(outfname);
    if (!outfile) {
        cerr << "Something went wrong opening the output file." << endl;
        exit(1);
    }

    for (auto it = sorted_substrs.cbegin(); it != sorted_substrs.cend(); ++it)
        outfile << it->second << "\t" << it->first << endl;

    outfile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x228(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x46b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x208(%rbp,%rax)
jne 0x5690
movq (%rbx), %r13
cmpq 0x8(%rbx), %r13
je 0x563c
leaq 0x22f22(%rip), %r15     # 0x284f6
xorps %xmm0, %xmm0
cvtss2sd 0x20(%r13), %xmm0
movq %r14, %rdi
callq 0x4590
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4400
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x4400
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4260
addq $0x28, %r13
cmpq 0x8(%rbx), %r13
jne 0x55d4
leaq -0x228(%rbp), %rdi
callq 0x44c0
movq 0x30961(%rip), %rax     # 0x35fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x4310
leaq -0x130(%rbp), %rdi
callq 0x4110
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30951(%rip), %rdi     # 0x35fe8
leaq 0x229af(%rip), %rsi     # 0x2804d
movl $0x2d, %edx
callq 0x4400
movq 0x30939(%rip), %rdi     # 0x35fe8
callq 0x4180
movl $0x1, %edi
callq 0x4420
jmp 0x56c0
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x4510
movq %rbx, %rdi
callq 0x4640
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::getSortedEndPointsX(std::vector<Line*, std::allocator<Line*>>)
vector<int> IntervalTree::getSortedEndPointsX(vector<Line*> lines) {
	vector<int> endpoints;
	int i;
	for (i=0; i<lines.size(); i++) {
		endpoints.push_back(lines[i]->x1);
		endpoints.push_back(lines[i]->x2);
	}
	sort (endpoints.begin(), endpoints.end(), myfunction);
	return endpoints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x1427
movq %rdx, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x13de
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x13e6
movq %rbx, %rdi
callq 0x2056
movq (%r14), %rax
movq (%rax,%r15,8), %rdx
addq $0x4, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1409
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1411
movq %rbx, %rdi
callq 0x2056
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x13c2
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x146e
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0xc5(%rip), %rcx       # 0x138c
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c8
leaq -0xd7(%rip), %rdx       # 0x138c
movq %r14, %rdi
movq %r15, %rsi
callq 0x23f1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x147e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x148e
callq 0x10d0
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::getSortedEndPointsY(std::vector<Line*, std::allocator<Line*>>)
vector<int> IntervalTree::getSortedEndPointsY(vector<Line*> lines) {
	vector<int> endpoints;
	int i;
	for (i=0; i<lines.size(); i++) {
		endpoints.push_back(lines[i]->y1);
		endpoints.push_back(lines[i]->y2);
	}
	sort (endpoints.begin(), endpoints.end(), myfunction);
	return endpoints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x1529
movq %rdx, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdx
addq $0x8, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x14e0
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x14e8
movq %rbx, %rdi
callq 0x2056
movq (%r14), %rax
movq (%rax,%r15,8), %rdx
addq $0xc, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x150b
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1513
movq %rbx, %rdi
callq 0x2056
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x14c0
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x1570
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x1c7(%rip), %rcx      # 0x138c
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c8
leaq -0x1d9(%rip), %rdx      # 0x138c
movq %r14, %rdi
movq %r15, %rsi
callq 0x23f1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1580
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1590
callq 0x10d0
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::preorder(IntervalNode*)
void IntervalTree::preorder(IntervalNode *r)
{
	int i;
        if (r != NULL)
        {
	       	cout<< " [[[ ";
		for (i=0; i<r->I_mid.size(); i++)
			cout << " {" << r->I_mid[i]->y1 << "  " << r->I_mid[i]->y2 << "} " ;
		cout << " ]]] ";
		if (r->rangetree != NULL)
			r->rangetree->preorder();
                preorder(r->left);
                preorder(r->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq 0x6a16(%rip), %r14      # 0x7fd8
leaq 0x3a41(%rip), %r12      # 0x500a
leaq 0x3a85(%rip), %r15      # 0x5055
testq %rbx, %rbx
je 0x16be
movl $0x5, %edx
movq %r14, %rdi
leaq 0x3a1c(%rip), %rsi      # 0x5004
callq 0x1110
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x1686
xorl %r13d, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1110
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x1160
movq %r14, %r15
movq %r12, %r14
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0x39d4(%rip), %rsi      # 0x500d
callq 0x1110
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movl 0xc(%rax), %esi
movq %r12, %rdi
movq %r14, %r12
movq %r15, %r14
leaq 0x39fc(%rip), %r15      # 0x5055
callq 0x1160
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1110
incq %r13
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
sarq $0x3, %rax
cmpq %r13, %rax
ja 0x15fe
movl $0x5, %edx
movq %r14, %rdi
leaq 0x397b(%rip), %rsi      # 0x5010
callq 0x1110
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x16a8
callq 0x2c26
movq 0x20(%rbx), %rsi
movq -0x30(%rbp), %rdi
callq 0x15a6
movq 0x28(%rbx), %rbx
jmp 0x15d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::queryX(int, int, int, int, int, IntervalNode*)
void IntervalTree::queryX(int maxX, int minX, int x, int y1, int y2, IntervalNode* node) {
	if (x < node->x_mid) {
		node->rangetree->twodquery(minX, x, y1, y2);
		if (node->left != NULL)
			queryX(maxX, minX, x, y1, y2, node->left);
	}
	else if (x > node->x_mid) {
		node->rangetree->twodquery(x, maxX, y1, y2);
		if (node->right != NULL)
			queryX(maxX, minX, x, y1, y2, node->right);
	}
	else {
		node->rangetree->twodquery(x, x, y1, y2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, -0x2c(%rbp)
movq 0x10(%rbp), %r13
cmpl %r15d, (%r13)
jle 0x1e04
movq 0x30(%r13), %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x37d2
movq 0x20(%r13), %r13
jmp 0x1e1f
movq 0x30(%r13), %rdi
movl %r15d, %esi
jge 0x1e33
movl -0x2c(%rbp), %edx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x37d2
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x1de3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37d2
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/interval_tree.cpp
// Function: IntervalTree::queryY(int, int, int, int, int, IntervalNode*)
void IntervalTree::queryY(int maxY, int minY, int y, int x1, int x2, IntervalNode* node) {
	if (y < node->x_mid) {
		node->rangetree->twodquery(x1, x2, minY, y);
		if (node->left != NULL)
			queryY(maxY, minY, y, x1, x2, node->left);
	}
	else if (y > node->x_mid) {
		node->rangetree->twodquery(x1, x2, y, maxY);
		if (node->right != NULL)
			queryY(maxY, minY, y, x1, x2, node->right);
	}
	else {
		node->rangetree->twodquery(x1, x2, y, y);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %r15d
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, -0x2c(%rbp)
movq 0x10(%rbp), %r13
cmpl %ebx, (%r13)
jle 0x1eb1
movq 0x30(%r13), %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x37d2
movq 0x20(%r13), %r13
jmp 0x1ecc
movq 0x30(%r13), %rdi
jge 0x1ee0
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl -0x2c(%rbp), %r8d
callq 0x37d2
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x1e90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37d2
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::rotateWithLeftChild(BinaryRangeNode*)
BinaryRangeNode* BinaryRangeTree::rotateWithLeftChild(BinaryRangeNode* k2)
 {
     BinaryRangeNode *k1 = k2->left;
     k2->left = k1->right;
     k1->right = k2;
     k2->height = max(height(k2->left), height(k2->right)) + 1;
     k1->height = max(height(k1->left), k2->height) + 1;
     return k1;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rsi), %rax
movq 0x28(%rax), %rdi
movq %rdi, 0x20(%rsi)
movq %rsi, 0x28(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x29b9
movl (%rdi), %edx
movq 0x28(%rsi), %rdi
testq %rdi, %rdi
je 0x29c4
movl (%rdi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, (%rsi)
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x29da
movl (%rdx), %edx
jmp 0x29df
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::rotateWithRightChild(BinaryRangeNode*)
BinaryRangeNode* BinaryRangeTree::rotateWithRightChild(BinaryRangeNode *k1)
 {
     BinaryRangeNode *k2 = k1->right;
     k1->right = k2->left;
     k2->left = k1;
     k1->height = max(height(k1->left), height(k1->right)) + 1;
     k2->height = max(height(k2->right), k1->height) + 1;
     return k2;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rsi), %rax
movq 0x20(%rax), %rdx
movq %rdx, 0x28(%rsi)
movq %rsi, 0x20(%rax)
movq 0x20(%rsi), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
testq %r8, %r8
je 0x2a38
movl (%r8), %edi
testq %rdx, %rdx
je 0x2a3f
movl (%rdx), %ecx
cmpl %ecx, %edi
cmovgl %edi, %ecx
incl %ecx
movl %ecx, (%rsi)
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x2a55
movl (%rdx), %edx
jmp 0x2a5a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::search(BinaryRangeNode*, int)
bool BinaryRangeTree::search(BinaryRangeNode *r, int val)
 {
     bool found = false;
     while ((r != NULL) && !found)
     {
         int rval = r->data;
         if (val < rval)
             r = r->left;
         else if (val > rval)
             r = r->right;
         else
         {
             found = true;
             break;
         }
         found = search(r, val);
     }
     return found;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
testq %r14, %r14
je 0x2b34
testb $0x1, %al
jne 0x2b34
movl 0x4(%r14), %ecx
movl $0x20, %eax
cmpl %ebx, %ecx
jg 0x2b17
movl $0x28, %eax
jge 0x2b2c
movq (%r14,%rax), %r14
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2ae6
movb $0x1, %cl
jmp 0x2b30
movb $0x1, %al
xorl %ecx, %ecx
testb %cl, %cl
jne 0x2afa
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::inorder(BinaryRangeNode*)
void BinaryRangeTree::inorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
         inorder(r->left);
         cout<< " { " << r->data<<" : ";
		for (i=0; i<r->data2.size(); i++)
			cout << r->data2[i] << "  ";
	cout << "} ";
         inorder(r->right);
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x546d(%rip), %r15      # 0x7fd8
leaq 0x249b(%rip), %r13      # 0x500d
testq %rbx, %rbx
je 0x2c17
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x2b50
movl $0x3, %edx
movq %r15, %rdi
leaq 0x249a(%rip), %rsi      # 0x5030
callq 0x1110
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x1160
movl $0x3, %edx
movq %rax, %rdi
leaq 0x247f(%rip), %rsi      # 0x5034
callq 0x1110
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x2bfa
xorl %r12d, %r12d
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x1160
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1110
incq %r12
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2bc7
movl $0x2, %edx
movq %r15, %rdi
leaq 0x244c(%rip), %rsi      # 0x5055
callq 0x1110
movq 0x28(%rbx), %rbx
jmp 0x2b72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::preorder(BinaryRangeNode*)
void BinaryRangeTree::preorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
	for (i=0; i<r->lines.size(); i++) {
			if (r->lines[i]->reported != 1)	{
				cout << " OP1 { (" << r->lines[i]->x1 << " " << r->lines[i]->y1 << ") -- (" << r->lines[i]->x2 << " " << r->lines[i]->y2 << ") } " << endl;
			}
	}
         preorder(r->left);
         preorder(r->right);
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq 0x533a(%rip), %r15      # 0x7fd8
leaq 0x2369(%rip), %r13      # 0x500e
testq %rbx, %rbx
je 0x2dd8
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x2dc2
xorl %r12d, %r12d
movq (%rax,%r12,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2da7
movl $0x8, %edx
movq %r15, %rdi
leaq 0x2367(%rip), %rsi      # 0x5043
callq 0x1110
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x1160
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1110
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
movl $0x6, %edx
movq %rax, %rdi
leaq 0x2321(%rip), %rsi      # 0x504c
callq 0x1110
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movl 0x4(%rax), %esi
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1110
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
movl $0x4, %edx
movq %rax, %rdi
leaq 0x22d8(%rip), %rsi      # 0x5053
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
incq %r12
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x2cbf
movq 0x20(%rbx), %rsi
movq -0x30(%rbp), %rdi
callq 0x2c82
movq 0x28(%rbx), %rbx
jmp 0x2ca5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::postorder(BinaryRangeNode*)
void BinaryRangeTree::postorder(BinaryRangeNode *r)
 {
	int i;
     if (r != NULL)
     {
         postorder(r->left);
         postorder(r->right);
         cout<< " { " << r->data<<" : ";
		for (i=0; i<r->data2.size(); i++)
			cout << r->data2[i] << "  ";
	cout << "} ";
     }
 }

// Assembly:
testq %rsi, %rsi
je 0x2ecd
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x2df6
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2df6
movq 0x51ac(%rip), %r14      # 0x7fd8
leaq 0x21fd(%rip), %rsi      # 0x5030
movl $0x3, %edx
movq %r14, %rdi
callq 0x1110
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x1160
leaq 0x21e2(%rip), %rsi      # 0x5034
movl $0x3, %edx
movq %rax, %rdi
callq 0x1110
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x2ead
xorl %r12d, %r12d
movq 0x5165(%rip), %r14      # 0x7fd8
leaq 0x2193(%rip), %r15      # 0x500d
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x1160
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1110
incq %r12
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2e7a
movq 0x5124(%rip), %rdi      # 0x7fd8
leaq 0x219a(%rip), %rsi      # 0x5055
movl $0x2, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1110
retq
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::buildytrees(BinaryRangeNode*)
void BinaryRangeTree::buildytrees(BinaryRangeNode *r) {
	if (r != NULL) {
		BinaryRangeTree* temp_tree = new BinaryRangeTree();
		buildytrees(r, temp_tree);
		r->ytree = temp_tree;
		buildytrees(r->left);	
		buildytrees(r->right);	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x2f29
movl $0x8, %edi
callq 0x10f0
movq %rax, %r15
movq $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2f34
movq %r15, 0x30(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x2edc
movq 0x28(%rbx), %rbx
jmp 0x2eec
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r14, %r14
je 0x2fa4
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x2f8f
xorl %r12d, %r12d
movl (%rax,%r12,4), %esi
movl 0x4(%r14), %edx
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %r8
movq (%rbx), %rcx
movq %rbx, %rdi
callq 0x27d6
movq %rax, (%rbx)
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2f5a
movq 0x20(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2f34
movq 0x28(%r14), %r14
jmp 0x2f48
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rdi), %rax
testq %rax, %rax
je 0x3034
movq 0x20(%rax), %rsi
orq 0x28(%rax), %rsi
sete %dil
jmp 0x3037
movb $0x1, %dil
movl 0x4(%rax), %esi
cmpl %ecx, %esi
setle %r8b
cmpl %edx, %esi
setge %r9b
testb %dil, %dil
jne 0x3062
andb %r9b, %r8b
jne 0x3062
xorl %edi, %edi
cmpl %edx, %esi
setl %dil
leaq (%rax,%rdi,8), %rdi
addq $0x20, %rdi
jmp 0x301e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rax
testq %rax, %rax
je 0x3098
movq 0x20(%rax), %rsi
orq 0x28(%rax), %rsi
sete %dil
jmp 0x309b
movb $0x1, %dil
movl 0x4(%rax), %esi
cmpl %ecx, %esi
setle %r8b
cmpl %edx, %esi
setge %r9b
testb %dil, %dil
jne 0x30c9
andb %r9b, %r8b
jne 0x30c9
cmpl %edx, %esi
jge 0x30be
movq 0x28(%rax), %rax
jmp 0x30c2
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x3085
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::onedquery(int, int)
void BinaryRangeTree::onedquery(int x1, int x2) {
	BinaryRangeNode* splitnode = findSplitNode(root, x1, x2);
	BinaryRangeNode* v;
	int i;
	if ((splitnode->data >= x1) & (splitnode->data <= x2)) {
		reportPoint(splitnode);
	}
	if (!isLeaf(splitnode)) {
		// go to left
		v = splitnode->left;
		while (!isLeaf(v)) { // is not a leaf
			if (x1 <= v->data) {
				reportPoint(v); //report the point itself
				reportSubtree(v->right);
				v = v->left;
			}
			else
				v = v->right;
		}
		if (v != NULL) {
			if ((v->data >= x1) & (v->data <= x2))
				reportPoint(v);	// Report the point itself
		}

		// go to right
		v = splitnode->right;
		while (!isLeaf(v)) { // is not a leaf
			if (x2 >= v->data) {
				reportPoint(v);
				reportSubtree(v->left);
				v = v->right;
			}
			else
				v = v->left;
		}
		if (v != NULL) {
			if ((v->data >= x1) & (v->data <= x2))
				reportPoint(v);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq %rdi, %rax
movq (%rax), %r12
testq %r12, %r12
je 0x33a6
movq 0x20(%r12), %rax
orq 0x28(%r12), %rax
sete %cl
jmp 0x33a8
movb $0x1, %cl
movl 0x4(%r12), %eax
cmpl %ebx, %eax
setle %sil
cmpl %r14d, %eax
setge %dl
andb %sil, %dl
testb %cl, %cl
jne 0x33d6
testb %dl, %dl
jne 0x33d6
xorl %ecx, %ecx
cmpl %r14d, %eax
setl %cl
leaq (%r12,%rcx,8), %rax
addq $0x20, %rax
jmp 0x338f
testb %dl, %dl
je 0x33e2
movq %r12, %rsi
callq 0x30de
testq %r12, %r12
je 0x34ee
movq 0x20(%r12), %rax
orq 0x28(%r12), %rax
je 0x34ee
movq %r15, -0x30(%rbp)
movq 0x20(%r12), %r13
testq %r13, %r13
sete %al
je 0x3468
movq 0x20(%r13), %rcx
orq 0x28(%r13), %rcx
je 0x3449
movl $0x28, %r15d
cmpl %r14d, 0x4(%r13)
jl 0x3442
movq %r13, %rsi
callq 0x30de
movq 0x28(%r13), %rsi
movl $0x20, %r15d
testq %rsi, %rsi
je 0x3442
movq -0x30(%rbp), %rdi
callq 0x2c82
movq (%r13,%r15), %r13
jmp 0x3404
testb %al, %al
jne 0x3468
movl 0x4(%r13), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3468
movq %r13, %rsi
callq 0x30de
movq 0x28(%r12), %r12
testq %r12, %r12
sete %al
movq -0x30(%rbp), %r13
je 0x34ee
movq 0x20(%r12), %rcx
orq 0x28(%r12), %rcx
je 0x34c0
movl $0x20, %r15d
cmpl %ebx, 0x4(%r12)
jg 0x34b2
movq %r12, %rsi
callq 0x30de
movq 0x20(%r12), %rsi
movl $0x28, %r15d
testq %rsi, %rsi
je 0x34b2
movq %r13, %rdi
callq 0x2c82
movq (%r12,%r15), %r12
testq %r12, %r12
sete %al
jne 0x3479
jmp 0x34ee
testb %al, %al
jne 0x34ee
movl 0x4(%r12), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x34ee
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::onedqueryYtree(BinaryRangeTree*, int, int)
void BinaryRangeTree::onedqueryYtree(BinaryRangeTree *r, int x1, int x2) {
	BinaryRangeNode* splitnode = findSplitNodeYtree(r->root, x1, x2);
	if (splitnode == NULL)
		return;
	BinaryRangeNode* v;
	if ((splitnode->data >= x1) & (splitnode->data <= x2))
			reportPointYtree(splitnode);			
	if (!isLeaf(splitnode)) {
		// go to left
		v = splitnode->left;
		while (!isLeaf(v)) { // is not a leaf
			if (x1 <= v->data) {
				reportPointYtree(v);
				reportSubtree(v->right);
				v = v->left;
			}
			else
				v = v->right;
		}
		if (v != NULL) {
			if ((v->data >= x1) & (v->data <= x2))
				reportPointYtree(v);
		}

		// go to right
		v = splitnode->right;
		while (!isLeaf(v)) { // is not a leaf
			if (x2 >= v->data) {
				reportPointYtree(v);	
				reportSubtree(v->left);
				v = v->right;
			}
			else
				v = v->left;
		}
		if (v != NULL) {
			if ((v->data >= x1) & (v->data <= x2))
				reportPointYtree(v);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, %r15
movq (%rsi), %rsi
callq 0x307e
testq %rax, %rax
je 0x3645
movq %rax, %r12
movl 0x4(%rax), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3542
movq %r12, %rsi
callq 0x3226
movq 0x20(%r12), %rax
orq 0x28(%r12), %rax
je 0x3645
movq %r15, -0x30(%rbp)
movq 0x20(%r12), %r13
testq %r13, %r13
sete %al
je 0x35bf
movq 0x20(%r13), %rcx
orq 0x28(%r13), %rcx
je 0x35a0
movl $0x28, %r15d
cmpl %r14d, 0x4(%r13)
jl 0x3599
movq %r13, %rsi
callq 0x3226
movq 0x28(%r13), %rsi
movl $0x20, %r15d
testq %rsi, %rsi
je 0x3599
movq -0x30(%rbp), %rdi
callq 0x2c82
movq (%r13,%r15), %r13
jmp 0x355b
testb %al, %al
jne 0x35bf
movl 0x4(%r13), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x35bf
movq %r13, %rsi
callq 0x3226
movq 0x28(%r12), %r12
testq %r12, %r12
sete %al
movq -0x30(%rbp), %r13
je 0x3645
movq 0x20(%r12), %rcx
orq 0x28(%r12), %rcx
je 0x3617
movl $0x20, %r15d
cmpl %ebx, 0x4(%r12)
jg 0x3609
movq %r12, %rsi
callq 0x3226
movq 0x20(%r12), %rsi
movl $0x28, %r15d
testq %rsi, %rsi
je 0x3609
movq %r13, %rdi
callq 0x2c82
movq (%r12,%r15), %r12
testq %r12, %r12
sete %al
jne 0x35d0
jmp 0x3645
testb %al, %al
jne 0x3645
movl 0x4(%r12), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3645
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3226
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::isPointInRange(BinaryRangeNode*, int, int, int, int)
void BinaryRangeTree::isPointInRange(BinaryRangeNode* r, int x1, int x2, int y1, int y2) {
	int i;
	if ((r->data >= x1) & (r->data <= x2)) { // in x range
		for (i=0; i< r->data2.size(); i++) {
			if  ((r->data2[i] >= y1) & (r->data2[i] <= y2) ) {
				if (r->lines[i]->reported != 1) {
					r->lines[i]->reported = 1;
					cout << " OP5 { (" << r->lines[i]->x1 << " " << r->lines[i]->y1 << ") -- (" << r->lines[i]->x2 << " " << r->lines[i]->y2 << ") } " << endl;
				}
			}
		}
	}
}

// Assembly:
movl 0x4(%rsi), %eax
cmpl %edx, %eax
setl %dl
cmpl %ecx, %eax
setg %al
orb %dl, %al
jne 0x37d1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq 0x8(%rsi), %rax
cmpq %rax, 0x10(%rsi)
je 0x37c3
movl %r9d, %ebx
movl %r8d, %r14d
xorl %r13d, %r13d
movl (%rax,%r13,4), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x37a8
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x37a8
movb $0x1, 0x10(%rax)
movl $0x8, %edx
movq 0x490e(%rip), %r12      # 0x7fd8
movq %r12, %rdi
leaq 0x1996(%rip), %rsi      # 0x506a
callq 0x1110
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
movl (%rax), %esi
movq %r12, %rdi
callq 0x1160
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1911(%rip), %rsi      # 0x500e
callq 0x1110
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
movl 0x8(%rax), %esi
movq %r12, %rdi
callq 0x1160
movq %rax, %r12
movl $0x6, %edx
movq %rax, %rdi
leaq 0x1925(%rip), %rsi      # 0x504c
callq 0x1110
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
movl 0x4(%rax), %esi
movq %r12, %rdi
callq 0x1160
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x18bd(%rip), %rsi      # 0x500e
callq 0x1110
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
movl 0xc(%rax), %esi
movq %r12, %rdi
callq 0x1160
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
leaq 0x18d8(%rip), %rsi      # 0x5053
callq 0x1110
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
incq %r13
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x3691
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x3a13
movq %rsi, %r14
xorl %r15d, %r15d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r13d, %r13d
leaq (%rax,%r15), %r8
movl (%rax,%r15), %esi
movl 0x8(%rax,%r15), %edx
movq (%rbx), %rcx
movq %rbx, %rdi
callq 0x27d6
movq %rax, (%rbx)
movq (%r14), %rcx
leaq (%rcx,%r15), %r8
movl 0x4(%rcx,%r15), %esi
movl 0xc(%rcx,%r15), %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x27d6
movq %rax, (%rbx)
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
imulq %r12, %rcx
addq $0x14, %r15
cmpq %r13, %rcx
ja 0x39bb
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2edc
movq 0x45b3(%rip), %r14      # 0x7fd8
leaq 0x1647(%rip), %rsi      # 0x5073
movl $0x8, %edx
movq %r14, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
callq 0x37d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x3af2
movq %rdx, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %r8
movl (%r8), %esi
movl 0x8(%r8), %edx
movq (%rbx), %rcx
movq %rbx, %rdi
callq 0x27d6
movq %rax, (%rbx)
movq (%r14), %rcx
movq (%rcx,%r15,8), %r8
movl 0x4(%r8), %esi
movl 0xc(%r8), %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x27d6
movq %rax, (%rbx)
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x3aa6
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2edc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x3b74
movq %rdx, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %r8
movl (%r8), %esi
movl 0x8(%r8), %edx
movq (%rbx), %rcx
movq %rbx, %rdi
callq 0x27d6
movq %rax, (%rbx)
movq (%r14), %rcx
movq (%rcx,%r15,8), %r8
movl 0x4(%r8), %esi
movl 0xc(%r8), %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x27d6
movq %rax, (%rbx)
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x3b28
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2edc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x8(%rdi), %rbx
leaq 0x38(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movl %esi, 0x4(%rdi)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x3be1
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%r15)
jmp 0x3bed
leaq -0x1c(%rbp), %rdx
movq %rbx, %rdi
callq 0x2056
movl $0x0, (%r15)
movq 0x40(%r15), %rsi
cmpq 0x48(%r15), %rsi
je 0x3c0c
movq -0x28(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%r15)
jmp 0x3c18
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0x218e
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3c33
callq 0x10d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c40
callq 0x10d0
movq %r15, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
leaq 0x88b3(%rip), %rdx      # 0xdcb0
movl $0x1, %ebx
movl $0x1, %edi
movl $0xc, %esi
movq %r14, %rcx
callq 0x5480
leaq 0x88f5(%rip), %rdx      # 0xdd10
movl $0x2, %edi
movl $0xa, %esi
movq %r14, %rcx
callq 0x5480
movl $0x3, %edi
movq %r14, %rsi
callq 0x61ec
movl (%r14), %esi
movq 0x8b84(%rip), %rdi      # 0xdfc8
testl %esi, %esi
je 0x5463
callq 0x3360
leaq 0x4d0f(%rip), %rsi      # 0xa163
movl $0xe, %edx
movq %rax, %rdi
callq 0x3230
jmp 0x5476
leaq 0x4d08(%rip), %rsi      # 0xa172
movl $0x12, %edx
callq 0x3230
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %ecx, %eax
movl 0x8(%r8), %r9d
xorps %xmm0, %xmm0
cmpl %ecx, %r9d
jge 0x2ffe
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rcx
xorps %xmm0, %xmm0
cvtsi2ssl 0x4(%r8), %xmm0
movl (%r8), %edx
cmpl %edi, %edx
jg 0x2fd9
movslq %edx, %r11
leal 0x1(%rdi), %r8d
leaq (%rcx,%r11,4), %r10
leaq (%rsi,%r11,4), %r11
movl %edi, %r14d
notl %r14d
addq %rdx, %r14
xorl %ebx, %ebx
movl (%r10,%rbx,4), %r15d
addl %r9d, %r15d
cmpl %eax, %r15d
jg 0x2fd5
xorps %xmm1, %xmm1
cvtsi2ssl (%r11,%rbx,4), %xmm1
addss %xmm1, %xmm0
incq %rbx
movl %r14d, %r12d
movl %r15d, %r9d
addl %ebx, %r12d
jne 0x2fa6
movl %r8d, %edx
movl %r15d, %r9d
jmp 0x2fd9
addl %edx, %ebx
movl %ebx, %edx
cmpl %edi, %edx
jge 0x2ff6
subl %r9d, %eax
movslq %edx, %rdi
imull (%rsi,%rdi,4), %eax
cltd
idivl (%rcx,%rdi,4)
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/test_cube.cpp
// Function: main
int main() {
   test_constructors();
   test_operators();
   test_getCubeSize();
   test_turns();

   return 0;
}

// Assembly:
pushq %rax
callq 0x3c15
callq 0x41d5
callq 0x52f9
callq 0x5432
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2e3e
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
jne 0x677a
cmpq %rdi, %rsi
je 0x6733
movl $0x1, %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x676c
movb (%rdi,%rsi), %r9b
cmpb (%rcx,%rsi), %r9b
jne 0x674d
movl %r8d, %esi
incl %r8d
cmpq %rsi, %rax
ja 0x6719
testq %rdi, %rdi
je 0x6745
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1120
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x2d84(%rip), %rdi      # 0x94d8
leaq 0x2bcb(%rip), %rsi      # 0x9326
leaq 0x2d46(%rip), %rcx      # 0x94a8
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x1090
leaq 0x2a97(%rip), %rdi      # 0x920a
xorl %eax, %eax
callq 0x1160
leaq 0x2d06(%rip), %rdi      # 0x9487
leaq 0x2b9e(%rip), %rsi      # 0x9326
leaq 0x2d19(%rip), %rcx      # 0x94a8
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x1090
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x67b2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1120
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x72, %esi
movl $0x3, %edx
callq 0x2b5a
movl $0x6, %esi
movq %rbx, %rdi
callq 0x2fe2
movabsq $0x100000007, %rsi      # imm = 0x100000007
movq %rbx, %rdi
callq 0x2fe2
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2fe2
movabsq $0x100000004, %rsi      # imm = 0x100000004
movq %rbx, %rdi
callq 0x2fe2
movl $0x5, %esi
movq %rbx, %rdi
callq 0x2fe2
movabsq $0x100000001, %rsi      # imm = 0x100000001
movq %rbx, %rdi
callq 0x2fe2
movl $0x5, %esi
movq %rbx, %rdi
callq 0x2fe2
movabsq $0x100000009, %rsi      # imm = 0x100000009
movq %rbx, %rdi
callq 0x2fe2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e34
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq 0x742c(%rip), %rdi      # 0xc285
callq 0x21c0
movl $0x1005908, %edi        # imm = 0x1005908
callq 0x2030
movq $0x249f0, (%rax)        # imm = 0x249F0
movl $0x48, %ecx
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 0x4e77
addq $0x8, %rax
movq %rax, 0x10(%rbx)
movl $0x493e00, %edi         # imm = 0x493E00
callq 0x2030
movq %rax, 0x8(%rbx)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x4c3e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70a4
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4ee0
callq 0x2130
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4c3e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71d3
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4f17
callq 0x2130
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x7374(%rip), %rdi      # 0xc2a6
callq 0x21c0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x4f5e
jmp 0x4f63
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4f63
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rsi, %r14
movq %rdi, %r13
leaq 0x6dbc(%rip), %rdi      # 0xc427
callq 0x21c0
testl %r12d, %r12d
je 0x5702
movq %rbx, %rdx
movl %r12d, %ebx
shlq $0x5, %rbx
xorl %r12d, %r12d
movw $0x101, %r8w            # imm = 0x101
movq 0x10(%rdx), %rax
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq 0x10(%r13), %rax
movslq -0x4c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
movw %r8w, 0x12(%rax,%rcx)
movslq -0x48(%rbp), %rcx
imulq $0x70, %rcx, %rcx
movw %r8w, 0x12(%rax,%rcx)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x56e2
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%r14)
jmp 0x56f9
movq %r14, %rdi
movq %rdx, %r15
leaq -0x50(%rbp), %rdx
callq 0x4cf6
movw $0x101, %r8w            # imm = 0x101
movq %r15, %rdx
addq $0x20, %r12
cmpq %r12, %rbx
jne 0x568b
leaq 0x6d3f(%rip), %rdi      # 0xc448
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67ba(%rip), %xmm0     # 0xc170
movsd %xmm0, -0x8(%rbp)
movapd %xmm2, %xmm0
callq 0x2240
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd 0x679a(%rip), %xmm1     # 0xc170
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x59f6
sqrtsd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
addq $0x10, %rsp
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq $0x0, 0x18(%rdi)
subq %rax, %rcx
je 0x5a42
pushq %rbp
movq %rsp, %rbp
sarq $0x5, %rcx
movsd 0x18(%rdi), %xmm0
addq $0x18, %rax
movl $0x1, %edx
addsd (%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
movl %edx, %esi
addq $0x20, %rax
incl %edx
cmpq %rsi, %rcx
ja 0x5a2b
popq %rbp
retq