LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x220(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x4640
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x200(%rbp,%rax)
jne 0x4ecf
movq (%rbx), %r14
leaq -0x220(%rbp), %r15
leaq 0x1f617(%rip), %r12     # 0x24486
cmpq 0x8(%rbx), %r14
je 0x4ea7
movss 0x20(%r14), %xmm0
movq %r15, %rdi
callq 0x42a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4340
movq %rax, %rdi
movq %r14, %rsi
callq 0x4300
movq %rax, %rdi
callq 0x4180
addq $0x28, %r14
jmp 0x4e6f
leaq -0x220(%rbp), %rdi
callq 0x4470
leaq -0x220(%rbp), %rdi
callq 0x44c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x31112(%rip), %rdi     # 0x35fe8
leaq 0x1f172(%rip), %rsi     # 0x2404f
callq 0x4340
movq %rax, %rdi
callq 0x4180
pushq $0x1
popq %rdi
callq 0x43c0
jmp 0x4ef4
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x44c0
movq %rbx, %rdi
callq 0x45e0
// File: /workspace/github_cpp_makefile_star2_O2/keyan[P]ev_routing_engine/main.cpp
// Function: main
int main(int argc, char **argv) {
  if (argc != 3) {
    std::cout << "Error: requires initial and final supercharger names" << std::endl;
    return -1;
  }

  std::string initial_charger_name = argv[1];
  std::string goal_charger_name = argv[2];

  if (initial_charger_name == goal_charger_name) {
    std::cout << "Error: initial and final superchargers cannot be identical" << std::endl;
    return -1;
  }

  Router routing_engine = Router(network);
  std::string result = routing_engine.route(initial_charger_name, goal_charger_name);
  std::cout << result << std::endl;

  return 0;
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
cmpl $0x3, %edi
jne 0x7d4e
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x2080
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x2080
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7e90
testb %al, %al
je 0x7d71
movq 0x92a6(%rip), %rdi      # 0x10fd8
leaq 0x430c(%rip), %rsi      # 0xc045
callq 0x2170
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rbx
jmp 0x7e0e
movq 0x9283(%rip), %rdi      # 0x10fd8
leaq 0x42b4(%rip), %rsi      # 0xc010
callq 0x2170
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rbx
jmp 0x7e22
leaq 0x9408(%rip), %rsi      # 0x11180
leaq 0xa8(%rsp), %rdi
callq 0x7eb4
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21c0
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21c0
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x8c58
leaq 0x48(%rsp), %rdi
callq 0x20c0
leaq 0x68(%rsp), %rdi
callq 0x20c0
movq 0x91fb(%rip), %rdi      # 0x10fd8
leaq 0x88(%rsp), %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20d0
leaq 0x88(%rsp), %rdi
callq 0x20c0
leaq 0xa8(%rsp), %rdi
callq 0x80b8
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20c0
jmp 0x7e3f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x7e58
movq %rax, %rbx
jmp 0x7e5d
jmp 0x7e6c
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20c0
leaq 0xa8(%rsp), %rdi
callq 0x80b8
jmp 0x7e6f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x7e7e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/keyan[P]ev_routing_engine/./utils.h
// Function: haversine_dist(double, double, double, double)
inline Kilometers haversine_dist(double lat1, double lng1, double lat2, double lng2) {
  double lat_rad1 = degree_to_radian(lat1);
  double lng_rad1 = degree_to_radian(lng1);
  double lat_rad2 = degree_to_radian(lat2);
  double lng_rad2 = degree_to_radian(lng2);

  double diff_lat = lat_rad2 - lat_rad1;
  double diff_lng = lng_rad2 - lng_rad1;

  double u = sin(diff_lat / 2.0);
  double v = sin(diff_lng / 2.0);

  double computation = asin(sqrt(u * u + cos(lat_rad1) * cos(lat_rad2) * v * v));

  return 2.0 * EARTH_RADIUS_KM * computation;
}

// Assembly:
subq $0x28, %rsp
movsd 0x372d(%rip), %xmm5     # 0xd058
mulsd %xmm5, %xmm0
movsd 0x3729(%rip), %xmm4     # 0xd060
divsd %xmm4, %xmm0
movapd %xmm0, %xmm6
movsd %xmm0, 0x10(%rsp)
mulsd %xmm5, %xmm1
divsd %xmm4, %xmm1
mulsd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd %xmm2, 0x18(%rsp)
mulsd %xmm3, %xmm5
divsd %xmm4, %xmm5
subsd %xmm1, %xmm5
movsd %xmm5, 0x8(%rsp)
movapd %xmm2, %xmm0
subsd %xmm6, %xmm0
mulsd 0x36d3(%rip), %xmm0     # 0xd050
callq 0x2050
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x36ba(%rip), %xmm0     # 0xd050
callq 0x2050
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2280
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2280
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x99f3
sqrtsd %xmm0, %xmm0
jmp 0x99f8
callq 0x2120
callq 0x2250
mulsd 0x3663(%rip), %xmm0     # 0xd068
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x136d
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x1c4e
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x1c4e
incq %r15
jmp 0x1336
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x6f(%rip), %rdx       # 0x130c
callq 0x2088
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1390
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dd0
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x13fd
movq (%rax,%r15,8), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1c4e
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
addq $0xc, %rsi
movq %rbx, %rdi
callq 0x1c4e
incq %r15
jmp 0x13c2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0xff(%rip), %rdx       # 0x130c
callq 0x2088
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1420
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dd0
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b7a(%rip), %r15      # 0x6fd8
leaq 0x2ba8(%rip), %r12      # 0x400d
leaq 0x2be9(%rip), %r14      # 0x4055
testq %rbx, %rbx
je 0x1518
movq %r15, %rdi
leaq 0x2b85(%rip), %rsi      # 0x4004
callq 0x10f0
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
sarq $0x3, %rax
movq %r15, %rdi
cmpq %r13, %rax
jbe 0x14e8
leaq 0x2b68(%rip), %rsi      # 0x400a
callq 0x10f0
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
incq %r13
jmp 0x1487
leaq 0x2b21(%rip), %rsi      # 0x4010
callq 0x10f0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1502
callq 0x2b14
movq 0x20(%rbx), %rsi
movq -0x30(%rbp), %rdi
callq 0x1442
movq 0x28(%rbx), %rbx
jmp 0x146c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b54
movq 0x30(%r13), %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x3460
movq 0x20(%r13), %r13
jmp 0x1b6f
movq 0x30(%r13), %rdi
movl %r15d, %esi
jge 0x1b83
movl -0x2c(%rbp), %edx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x3460
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x1b33
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 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c01
movq 0x30(%r13), %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x3460
movq 0x20(%r13), %r13
jmp 0x1c1c
movq 0x30(%r13), %rdi
jge 0x1c30
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl -0x2c(%rbp), %r8d
callq 0x3460
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x1be0
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 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::insert(int, int, BinaryRangeNode*, Line*)
BinaryRangeNode* BinaryRangeTree::insert(int x, int y, BinaryRangeNode *t, Line *line)
{	
     if (t == NULL) 
         t = new BinaryRangeNode(x,y, line);
     else if (x < t->data)
     {
         t->left = insert(x, y, t->left, line);
         if (height(t->left) - height(t->right) == 2)
             if (x < t->left->data)
                 t = rotateWithLeftChild(t);
             else
                 t = doubleWithLeftChild(t);
     }
     else if (x > t->data)
     {
         t->right = insert(x, y, t->right, line);
         if (height(t->right) - height(t->left) == 2)
             if (x > t->right->data)
                 t = rotateWithRightChild(t);
             else
                 t = doubleWithRightChild(t);
     }
	else if (x == t->data) {
		t->data2.push_back(y);
		t->lines.push_back(line);			
	}
     t->height = max(height(t->left), height(t->right)) + 1;
     return t;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movl %edx, %r13d
movl %esi, %r14d
movl %edx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
testq %rcx, %rcx
je 0x27a0
movq %rcx, %rbx
movq %rdi, %r15
movl 0x4(%rcx), %eax
cmpl %r14d, %eax
jle 0x27be
movq 0x20(%rbx), %rcx
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %r12, %r8
callq 0x271a
movq %rax, 0x20(%rbx)
pushq $-0x1
popq %rcx
movl %ecx, %edx
testq %rax, %rax
je 0x2773
movl (%rax), %edx
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x277e
movl (%rsi), %ecx
subl %ecx, %edx
cmpl $0x2, %edx
jne 0x283d
cmpl %r14d, 0x4(%rax)
jle 0x2825
movq %rbx, %rsi
callq 0x28a8
jmp 0x283a
pushq $0x50
popq %rdi
callq 0x1100
movq %rax, %rbx
movq %rax, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %r12, %rcx
callq 0x374a
jmp 0x283d
jge 0x2807
movq 0x28(%rbx), %rcx
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %r12, %r8
callq 0x271a
pushq $-0x1
popq %rsi
movq %rax, 0x28(%rbx)
movl %esi, %ecx
testq %rax, %rax
je 0x27e5
movl (%rax), %ecx
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x27f0
movl (%rdx), %esi
subl %esi, %ecx
cmpl $0x2, %ecx
jne 0x283d
cmpl %r14d, 0x4(%rax)
jge 0x2832
movq %rbx, %rsi
callq 0x291c
jmp 0x283a
jne 0x283d
leaq 0x8(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1c4e
leaq 0x38(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1ccc
jmp 0x283d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28f8
jmp 0x283a
movq %rbx, %rsi
callq 0x296e
movq %rax, %rbx
movq 0x20(%rbx), %rdx
pushq $-0x1
popq %rax
movl %eax, %ecx
testq %rdx, %rdx
je 0x284d
movl (%rdx), %ecx
movq 0x28(%rbx), %rdx
testq %rdx, %rdx
je 0x2858
movl (%rdx), %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
movq %rdx, 0x20(%rsi)
movq %rsi, 0x28(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %edi
testq %rdx, %rdx
je 0x28ca
movl (%rdx), %edi
movq 0x28(%rsi), %r8
movl %ecx, %edx
testq %r8, %r8
je 0x28d8
movl (%r8), %edx
cmpl %edx, %edi
cmovgl %edi, %edx
incl %edx
movl %edx, (%rsi)
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x28ec
movl (%rsi), %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
incl %edx
movl %edx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
movq %rdi, 0x28(%rsi)
movq %rsi, 0x20(%rax)
movq 0x20(%rsi), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %r8d
testq %rdx, %rdx
je 0x2944
movl (%rdx), %r8d
movl %ecx, %edx
testq %rdi, %rdi
je 0x294d
movl (%rdi), %edx
cmpl %edx, %r8d
cmovgl %r8d, %edx
incl %edx
movl %edx, (%rsi)
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x2963
movl (%rsi), %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
incl %edx
movl %edx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
pushq $0x20
popq %r12
pushq $0x28
popq %r13
testq %r14, %r14
je 0x2a3a
testb $0x1, %al
jne 0x2a3a
movq %r12, %rax
cmpl %ebx, 0x4(%r14)
jg 0x2a25
movq %r13, %rax
jge 0x2a38
movq (%r14,%rax), %r14
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x29ee
jmp 0x2a0e
movb $0x1, %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4563(%rip), %r15      # 0x6fd8
leaq 0x1591(%rip), %r12      # 0x400d
testq %rbx, %rbx
je 0x2b05
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x2a5a
movq %r15, %rdi
leaq 0x1595(%rip), %rsi      # 0x4030
callq 0x10f0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
leaq 0x157f(%rip), %rsi      # 0x4034
callq 0x10f0
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x2aed
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
incq %r13
jmp 0x2abd
movq %r15, %rdi
leaq 0x155e(%rip), %rsi      # 0x4055
callq 0x10f0
movq 0x28(%rbx), %rbx
jmp 0x2a7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x14a8(%rip), %r13      # 0x400e
leaq 0x14df(%rip), %r14      # 0x404c
leaq 0x14df(%rip), %r15      # 0x4053
testq %rbx, %rbx
je 0x2c56
xorl %r12d, %r12d
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x2c40
movq (%rax,%r12,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2c38
movq 0x442b(%rip), %rdi      # 0x6fd8
leaq 0x148f(%rip), %rsi      # 0x4043
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r13, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r13, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r15, %rsi
callq 0x10f0
movq %rax, %rdi
callq 0x1080
incq %r12
jmp 0x2b80
movq 0x20(%rbx), %rsi
movq -0x30(%rbp), %rdi
callq 0x2b4a
movq 0x28(%rbx), %rbx
jmp 0x2b74
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d28
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x2c74
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2c74
movq 0x432e(%rip), %r14      # 0x6fd8
leaq 0x137f(%rip), %rsi      # 0x4030
movq %r14, %rdi
callq 0x10f0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x1150
leaq 0x1369(%rip), %rsi      # 0x4034
movq %rax, %rdi
callq 0x10f0
xorl %r12d, %r12d
leaq 0x1330(%rip), %r15      # 0x400d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x2d0d
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x1150
movq %rax, %rdi
movq %r15, %rsi
callq 0x10f0
incq %r12
jmp 0x2cdd
movq 0x42c4(%rip), %rdi      # 0x6fd8
leaq 0x133a(%rip), %rsi      # 0x4055
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r15
testq %rbx, %rbx
je 0x2d85
movq %r15, %rdi
callq 0x1100
movq %rax, %r12
andq $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d8e
movq %r12, 0x30(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x2d38
movq 0x28(%rbx), %rbx
jmp 0x2d4d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2df0
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x2ddb
movl (%rax,%r12,4), %esi
movl 0x4(%r14), %edx
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %rbx, %rdi
callq 0x26fc
incq %r12
jmp 0x2daa
movq 0x20(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2d8e
movq 0x28(%r14), %r14
jmp 0x2da2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e5a
movq 0x20(%rax), %rsi
orq 0x28(%rax), %rsi
sete %dil
jmp 0x2e5d
movb $0x1, %dil
movl 0x4(%rax), %esi
cmpl %ecx, %esi
setle %r8b
cmpl %edx, %esi
setge %r9b
testb %dil, %dil
jne 0x2e88
andb %r9b, %r8b
jne 0x2e88
xorl %edi, %edi
cmpl %edx, %esi
setl %dil
leaq (%rax,%rdi,8), %rdi
addq $0x20, %rdi
jmp 0x2e44
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ebe
movq 0x20(%rax), %rsi
orq 0x28(%rax), %rsi
sete %dil
jmp 0x2ec1
movb $0x1, %dil
movl 0x4(%rax), %esi
cmpl %ecx, %esi
setle %r8b
cmpl %edx, %esi
setge %r9b
testb %dil, %dil
jne 0x2eef
andb %r9b, %r8b
jne 0x2eef
cmpl %edx, %esi
jge 0x2ee4
movq 0x28(%rax), %rax
jmp 0x2ee8
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x2eab
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r15d, %r15d
leaq 0x10ef(%rip), %r12      # 0x400e
leaq 0x1126(%rip), %r13      # 0x404c
leaq 0x1126(%rip), %r14      # 0x4053
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
sarq $0x2, %rax
cmpq %r15, %rax
jbe 0x2ff2
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2fea
movb $0x1, 0x10(%rax)
movq 0x4079(%rip), %rdi      # 0x6fd8
leaq 0x10f2(%rip), %rsi      # 0x4058
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r13, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
movq %rax, %rdi
callq 0x1080
incq %r15
jmp 0x2f2d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r15d, %r15d
leaq 0xff1(%rip), %r12       # 0x400e
leaq 0x1028(%rip), %r13      # 0x404c
leaq 0x1028(%rip), %r14      # 0x4053
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
sarq $0x2, %rax
cmpq %r15, %rax
jbe 0x30f8
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x30f0
movq 0x3f7f(%rip), %rdi      # 0x6fd8
leaq 0x1001(%rip), %rsi      # 0x4061
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r13, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
movq %rax, %rdi
callq 0x1080
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rax
movb $0x1, 0x10(%rax)
incq %r15
jmp 0x302b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %edx
movl %ebx, %ecx
callq 0x2e40
movq %rax, %r12
movl 0x4(%rax), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3144
movq %r12, %rsi
callq 0x2f04
movq 0x20(%r12), %rax
movq 0x28(%r12), %rcx
orq %rax, %rcx
je 0x320a
addq $0x28, %r12
testq %rax, %rax
je 0x31da
movq %rax, %r13
movq 0x28(%rax), %rax
movq 0x20(%r13), %rcx
orq %rax, %rcx
movl 0x4(%r13), %ecx
je 0x3193
cmpl %r14d, %ecx
jl 0x315b
movq %r13, %rsi
callq 0x2f04
movq 0x28(%r13), %rsi
movq %r15, %rdi
callq 0x2ef2
movq 0x20(%r13), %rax
jmp 0x315b
cmpl %r14d, %ecx
setl %al
cmpl %ebx, %ecx
setg %cl
orb %al, %cl
jne 0x31da
movq %r13, %rsi
callq 0x2f04
jmp 0x31da
movq 0x20(%r13), %rax
orq 0x28(%r13), %rax
movl 0x4(%r13), %eax
je 0x31e5
leaq 0x20(%r13), %r12
cmpl %ebx, %eax
jg 0x31da
leaq 0x28(%r13), %r12
movq %r13, %rsi
callq 0x2f04
movq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x2ef2
movq (%r12), %r13
testq %r13, %r13
jne 0x31ac
jmp 0x320a
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x320a
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ea4
testq %rax, %rax
je 0x3324
movq %rax, %r12
movl 0x4(%rax), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x325e
movq %r12, %rsi
callq 0x3002
movq 0x20(%r12), %rax
movq 0x28(%r12), %rcx
orq %rax, %rcx
je 0x3324
addq $0x28, %r12
testq %rax, %rax
je 0x32f4
movq %rax, %r13
movq 0x28(%rax), %rax
movq 0x20(%r13), %rcx
orq %rax, %rcx
movl 0x4(%r13), %ecx
je 0x32ad
cmpl %r14d, %ecx
jl 0x3275
movq %r13, %rsi
callq 0x3002
movq 0x28(%r13), %rsi
movq %r15, %rdi
callq 0x2ef2
movq 0x20(%r13), %rax
jmp 0x3275
cmpl %r14d, %ecx
setl %al
cmpl %ebx, %ecx
setg %cl
orb %al, %cl
jne 0x32f4
movq %r13, %rsi
callq 0x3002
jmp 0x32f4
movq 0x20(%r13), %rax
orq 0x28(%r13), %rax
movl 0x4(%r13), %eax
je 0x32ff
leaq 0x20(%r13), %r12
cmpl %ebx, %eax
jg 0x32f4
leaq 0x28(%r13), %r12
movq %r13, %rsi
callq 0x3002
movq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x2ef2
movq (%r12), %r13
testq %r13, %r13
jne 0x32c6
jmp 0x3324
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3324
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3002
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x345f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %r14d
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0xca4(%rip), %r12       # 0x400e
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x3451
movl (%rax,%r13,4), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x3449
movq 0x38(%r15), %rax
movq (%rax,%r13,8), %rax
cmpb $0x0, 0x10(%rax)
jne 0x3449
movb $0x1, 0x10(%rax)
movq 0x3c22(%rip), %rdi      # 0x6fd8
leaq 0xcad(%rip), %rsi       # 0x406a
callq 0x10f0
movq 0x38(%r15), %rcx
movq (%rcx,%r13,8), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%r15), %rcx
movq (%rcx,%r13,8), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
leaq 0xc50(%rip), %rsi       # 0x404c
callq 0x10f0
movq 0x38(%r15), %rcx
movq (%rcx,%r13,8), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x38(%r15), %rcx
movq (%rcx,%r13,8), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x1150
movq %rax, %rdi
leaq 0xc17(%rip), %rsi       # 0x4053
callq 0x10f0
movq %rax, %rdi
callq 0x1080
incq %r13
jmp 0x336a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/meghanamreddy[P]Range-trees-and-Interval-Trees/binaryRangeTree.cpp
// Function: BinaryRangeTree::twodquery(int, int, int, int)
void BinaryRangeTree::twodquery(int x1, int x2, int y1, int y2) {
	BinaryRangeNode* splitnode = findSplitNode(root, x1, x2);
	BinaryRangeNode* v;
	int i;
	isPointInRange(splitnode, x1, x2, y1, y2);
	if (!isLeaf(splitnode)) {
		// go to left
		v = splitnode->left;
		while (!isLeaf(v)) { // is not a leaf
			if (x1 <= v->data) {
				isPointInRange(v, x1, x2, y1, y2); //report the point itself
				if (v->right != NULL )
					onedqueryYtree(v->right->ytree, y1, y2);
				v = v->left;
			}
			else
				v = v->right;
		}
		if (v != NULL) {
			isPointInRange(v, x1, x2, y1, y2); 
		}

		v = splitnode->right;
		while (!isLeaf(v)) { // is not a leaf
			if (x2 >= v->data) {
				isPointInRange(v, x1, x2, y1, y2); 
				if (v->left != NULL) {
					onedqueryYtree(v->left->ytree, y1, y2);
				}
				v = v->right;
			}
			else
				v = v->left;
		}
		if (v != NULL) {
			isPointInRange(v, x1, x2, y1, y2); 
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, -0x40(%rbp)
movl %esi, %edx
movl %r15d, %ecx
callq 0x2e40
movq %rax, %r13
movq %rax, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebx, -0x2c(%rbp)
movl %ebx, %r9d
callq 0x3334
testq %r13, %r13
je 0x34b7
movq 0x20(%r13), %rax
movq 0x28(%r13), %rcx
orq %rax, %rcx
jne 0x34c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, -0x30(%rbp)
addq $0x28, %r13
movl -0x2c(%rbp), %r14d
movl %r12d, -0x34(%rbp)
testq %rax, %rax
je 0x354b
movq %rax, %rbx
movq 0x28(%rax), %rax
movq 0x20(%rbx), %rcx
orq %rax, %rcx
je 0x3535
cmpl %r12d, 0x4(%rbx)
jl 0x34d6
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %r12d
movl %r15d, %ecx
movl -0x30(%rbp), %r15d
movl %r15d, %r8d
movl %r14d, %r9d
callq 0x3334
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x3528
movq 0x30(%rax), %rsi
movq -0x40(%rbp), %rdi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x321a
movq 0x20(%rbx), %rax
movl %r12d, %r15d
movl -0x34(%rbp), %r12d
jmp 0x34d6
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl -0x30(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq 0x3334
movl -0x30(%rbp), %r14d
movq (%r13), %rbx
testq %rbx, %rbx
je 0x34b7
movq 0x20(%rbx), %rax
orq 0x28(%rbx), %rax
je 0x35a7
leaq 0x20(%rbx), %r13
cmpl %r15d, 0x4(%rbx)
jg 0x354f
leaq 0x28(%rbx), %r13
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl -0x2c(%rbp), %r9d
callq 0x3334
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x354f
movq 0x30(%rax), %rsi
movq -0x40(%rbp), %rdi
movl %r14d, %edx
movl -0x2c(%rbp), %ecx
callq 0x321a
jmp 0x354f
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl -0x2c(%rbp), %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3334
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
xorl %r15d, %r15d
pushq $0x14
popq %r12
xorl %r13d, %r13d
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x3633
leaq (%rdi,%r15), %rcx
movl (%rdi,%r15), %esi
movl 0x8(%rdi,%r15), %edx
movq %rbx, %rdi
callq 0x26fc
movq (%r14), %rax
leaq (%rax,%r15), %rcx
movl 0x4(%rax,%r15), %esi
movl 0xc(%rax,%r15), %edx
movq %rbx, %rdi
callq 0x26fc
incq %r13
addq $0x14, %r15
jmp 0x35e8
movq %rbx, %rdi
callq 0x2d2a
movq 0x3996(%rip), %rdi      # 0x6fd8
leaq 0xa2a(%rip), %rsi       # 0x4073
callq 0x10f0
movq %rax, %rdi
callq 0x1080
pushq $0x4
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x3460
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %rbx
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x36cb
movq (%rax,%r15,8), %rcx
movl (%rcx), %esi
movl 0x8(%rcx), %edx
movq %rbx, %rdi
callq 0x26fc
movq (%r14), %rax
movq (%rax,%r15,8), %rcx
movl 0x4(%rcx), %esi
movl 0xc(%rcx), %edx
movq %rbx, %rdi
callq 0x26fc
incq %r15
jmp 0x368d
movq %rbx, %rdi
callq 0x2d2a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x24(%rbp), %rax
movl %edx, (%rax)
movq %rcx, -0x20(%rbp)
leaq 0x8(%rdi), %rbx
leaq 0x38(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movl %esi, 0x4(%rdi)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c4e
andl $0x0, (%r15)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x1ccc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x1dbc
movq %rbx, %rdi
callq 0x1dd0
movq %r15, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%r14)
leaq 0x7274(%rip), %rdx      # 0xbcd0
pushq $0x1
popq %rbx
pushq $0xc
popq %rsi
movl %ebx, %edi
movq %r14, %rcx
callq 0x4ac8
leaq 0x72bd(%rip), %rdx      # 0xbd30
pushq $0x2
popq %rdi
pushq $0xa
popq %rsi
movq %r14, %rcx
callq 0x4ac8
pushq $0x3
popq %rdi
movq %r14, %rsi
callq 0x541a
movl (%r14), %esi
movq 0x753a(%rip), %rdi      # 0xbfd0
testl %esi, %esi
je 0x4ab0
callq 0x3380
leaq 0x36bd(%rip), %rsi      # 0x8163
movq %rax, %rdi
callq 0x3210
jmp 0x4abe
leaq 0x36bb(%rip), %rsi      # 0x8172
callq 0x3210
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rcx
movl 0x8(%r8), %edx
xorps %xmm0, %xmm0
cmpl %eax, %edx
jge 0x2c20
cvtsi2ssl 0x4(%r8), %xmm0
movslq (%r8), %r9
movslq %edi, %r10
leaq 0x1(%r10), %r8
cmpq %r9, %r8
cmovleq %r9, %r8
cmpq %r10, %r9
jg 0x2c01
movl (%rcx,%r9,4), %r11d
addl %edx, %r11d
cmpl %eax, %r11d
jg 0x2bfe
cvtsi2ssl (%rsi,%r9,4), %xmm1
addss %xmm1, %xmm0
incq %r9
movl %r11d, %edx
jmp 0x2bdb
movq %r9, %r8
cmpl %edi, %r8d
jge 0x2c20
pushq %rbp
movq %rsp, %rbp
subl %edx, %eax
movslq %r8d, %rdi
imull (%rsi,%rdi,4), %eax
cltd
idivl (%rcx,%rdi,4)
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a55
callq 0x4efa
callq 0x5d67
callq 0x5e66
xorl %eax, %eax
popq %rcx
retq