LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_map<int, int>(ezSTL::map<int, int, ezSTL::less<ezSTL::pair<int, int>>, ezSTL::allocator<ezSTL::__rbtree_node<ezSTL::pair<int, int>>>>&)
void test::print_map(map<K, V>& m) {
		std::cout << "size: " << m.size();
		std::cout << " ; empty: " << m.empty();
		std::cout << std::endl << "map: ";
		for (auto ite = m.begin(); ite != m.end(); ++ite)
			std::cout << (*ite).first << ":" << (*ite).second << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xccd5(%rip), %rbx      # 0x15fd8
leaq 0x761d(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x757e(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x75c2(%rip), %rsi      # 0x10938
movl $0x5, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rax
movq %rax, (%rsp)
cmpq %rcx, %rax
je 0x93fb
movq 0xcc3d(%rip), %r15      # 0x15fd8
leaq 0x6d07(%rip), %r12      # 0x100a9
leaq 0x7117(%rip), %r13      # 0x104c0
movq %rsp, %rbp
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rsp), %rax
movl 0x24(%rax), %esi
movq %rbx, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbp, %rdi
callq 0xab02
movq (%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x93ac
movq 0xcbd6(%rip), %rbx      # 0x15fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_unordered_map<int, int>(ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>&)
void test::print_unordered_map(unordered_map<Key, Value>& um) {
		std::cout << "size: " << um.size();
		std::cout << " ; bucket size: " << um.bucket_size();
		std::cout << " ; empty: " << um.empty();
		std::cout << std::endl << "unordered_map: ";
		for (auto ite = um.begin(); ite != um.end(); ++ite)
			std::cout << ite.get_key() << ":" << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0xcb88(%rip), %rbx      # 0x15fd8
leaq 0x74d0(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x74a6(%rip), %rsi      # 0x1091d
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7407(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x18(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x7440(%rip), %rsi      # 0x1092e
movl $0xf, %edx
movq %rax, %rdi
callq 0x2220
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb0ba
leaq 0x6b97(%rip), %r12      # 0x100a9
leaq 0x6fa7(%rip), %r13      # 0x104c0
movq 0x20(%r14), %rcx
movl 0x38(%r14), %eax
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
shrq $0x3, %rdi
cmpl %edi, %edx
jb 0x954c
movq 0x30(%r14), %rsi
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
shrq $0x3, %rdi
cmpl %edi, %eax
jae 0x95ad
cmpq %rcx, 0x8(%rsp)
setne %cl
cmpl %eax, %edx
setne %al
orb %cl, %al
je 0x95ad
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq 0x8(%rsp), %rax
movl 0x14(%rax), %esi
movq %rbp, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq %r15, %rdi
callq 0xb138
jmp 0x9519
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::find(int const&)
typename unordered_map<Key, Value, Hash, KeyEqual>::iterator
	unordered_map<Key, Value, Hash, KeyEqual>::find(const Key& key) {
		// finding index
		size_type index = Hash()(key) % buckets.size();
		if (!buckets[index]) return end();
		// searching the list and find key
		for(auto ite = buckets[index]->begin(); ite != buckets[index]->end(); ++ite)
			if (KeyEqual()(ite->first, key)) return iterator(ite, buckets[index], this, index);
		return end();
	}

// Assembly:
movq %rdx, %rcx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %edx, %edx
movzbl (%rcx,%rdx), %r8d
xorl %eax, %r8d
imull $0x1000193, %r8d, %eax  # imm = 0x1000193
incq %rdx
cmpq $0x4, %rdx
jne 0x98ca
movq (%rsi), %r8
movq 0x8(%rsi), %r9
subq %r8, %r9
shrq $0x3, %r9
xorl %edx, %edx
divl %r9d
movq (%r8,%rdx,8), %rax
testq %rax, %rax
je 0x9926
movq (%rax), %r8
movl (%rcx), %r9d
movq %r8, %rcx
movq 0x8(%rcx), %rcx
cmpq %r8, %rcx
je 0x9926
cmpl %r9d, 0x10(%rcx)
jne 0x9907
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movl %edx, 0x18(%rdi)
jmp 0x993b
movups 0x20(%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x10(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x18(%rdi)
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::erase(ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>)
void unordered_map<Key, Value, Hash, KeyEqual>::erase(const iterator ite) {
		ite.list_pointer->erase(ite.list_iterator);
		// if the list is empty, then remove the list
		if (ite.list_pointer->empty()) {
			delete ite.um_pointer->buckets[ite.bucket];
			ite.um_pointer->buckets[ite.bucket] = nullptr;
		}
		--__size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %r15
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x21c0
decl 0x8(%r15)
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x99ae
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
movq (%rax), %rax
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x999b
movq %r15, %rdi
callq 0xb238
movq %r15, %rdi
callq 0x21c0
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
movq (%rax), %rax
movq $0x0, (%rax,%rcx,8)
decl 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::operator=(ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>> const&)
unordered_map<Key, Value, Hash, KeyEqual>& operator= (const unordered_map<Key, Value, Hash, KeyEqual>& um) {
				if (this != &um) {
					clear();
					buckets.resize(um.bucket_size());
					for (size_type i = 0; i < bucket_size(); ++i) {
						if (um.buckets[i])
							buckets[i] = new list<pair<Key, Value>>(*um.buckets[i]);
					}
					__size = um.size();
					end_iterator = um.end_iterator;
				}
				return *this;
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x9b6e
movq %rsi, %r14
movq %rbx, %rdi
callq 0x9b8e
movq 0x8(%r14), %rsi
subq (%r14), %rsi
shrq $0x3, %rsi
movq %rbx, %rdi
callq 0xb1b0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x9b4a
xorl %r12d, %r12d
movq (%r14), %r13
cmpq $0x0, (%r13,%r12,8)
je 0x9b35
movl $0x10, %edi
callq 0x21f0
movq %rax, %r15
movq (%r13,%r12,8), %rsi
movq %rax, %rdi
callq 0xb298
movq (%rbx), %rax
movq %r15, (%rax,%r12,8)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incq %r12
shrq $0x3, %rax
movl %eax, %eax
cmpq %rax, %r12
jb 0x9b09
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
cmpq %r14, %rbx
je 0x9b6e
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::clear()
void unordered_map<Key, Value, Hash, KeyEqual>::clear() {
		// clear the buckets
		for (size_type i = 0; i < bucket_size(); ++i) {
			if (buckets[i]) {
				delete buckets[i];
				buckets[i] = nullptr;
			}
		}
		__size = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x9be7
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x9bcf
movq %r14, %rdi
callq 0xb238
movq %r14, %rdi
callq 0x21c0
movq (%rbx), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %r15
jb 0x9bab
movl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/memory.h
// Function: ezSTL::shared_ptr<int>::~shared_ptr()
~shared_ptr() {
			// if count == 0, then deallocate space
			if (__ptr) {
				--(*__countptr);
				if (*__countptr == 0) {
					delete __ptr;
					delete __countptr;
					__ptr = nullptr;
					__countptr = nullptr;
				}
			}
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9d1b
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x9d1b
callq 0x21c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9d15
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/memory.h
// Function: ezSTL::shared_ptr<int>::operator=(ezSTL::shared_ptr<int> const&)
shared_ptr<T>& operator= (const shared_ptr<T>& ptr) {
			if (this != &ptr) {
				if (__ptr) {
					--(*__countptr);
					if (*__countptr == 0) {
						delete __ptr;
						delete __countptr;
						__ptr = nullptr;
						__countptr = nullptr;
					}
				}
				__ptr = ptr.__ptr;
				__countptr = ptr.__countptr;
				++(*__countptr);
			}
			return *this;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x9d66
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9d56
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x9d56
callq 0x21c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9d50
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<ezSTL::pair<int, int>, ezSTL::less<ezSTL::pair<int, int>>, ezSTL::allocator<ezSTL::__rbtree_node<ezSTL::pair<int, int>>>>::dfs_clear(ezSTL::__rbtree_node<ezSTL::pair<int, int>>*)
void rbtree<T, Compare, Alloc>::dfs_clear(link_type root) {
		// dfs clear left and right
		if (root->left)
			dfs_clear(root->left);
		if (root->right)
			dfs_clear(root->right);
		Alloc().destroy(root);
		Alloc().deallocate(root);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0xa343
movq %r14, %rdi
callq 0xa328
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xa354
movq %r14, %rdi
callq 0xa328
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::__rbtree_iterator<int>::operator++()
self& operator++() {
			// if it has right node
			if (node->right != nullptr) {
				node = node->right;
				while (node->left != nullptr)
					node = node->left;
			}
			else {
				link_type parent_node = node->parent;
				while (node == parent_node->right) {
					node = parent_node;
					parent_node = parent_node->parent;
				}
				if (node->right != parent_node)
					node = parent_node;
			}
			return *this;
		}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0xa615
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xa607
jmp 0xa638
movq (%rax), %rdx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rdx
jne 0xa632
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rdx
je 0xa622
movq %rdx, (%rax)
cmpq %rcx, 0x18(%rdx)
je 0xa63b
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::dfs_isRBTree(ezSTL::__rbtree_node<int>*, unsigned int, unsigned int)
bool rbtree<T, Compare, Alloc>::dfs_isRBTree(link_type root, unsigned int count_of_black_now, const unsigned int count_of_black) {
		// if root is black, count plus 1
		if (root->color == __rbtree_black)
			++count_of_black_now;
		// left or right is nullptr
		if (root->left == nullptr && root->right == nullptr) {
			++count_of_black_now;
			if (count_of_black_now != count_of_black)
				return false;
			else return true;
		}
		// left and right are not nullptr
		else {
			if (root->left == nullptr)
				return count_of_black_now + 1 == count_of_black && dfs_isRBTree(root->right, count_of_black_now, count_of_black);
			else if (root->right == nullptr)
				return count_of_black_now + 1 == count_of_black && dfs_isRBTree(root->left, count_of_black_now, count_of_black);
			else
				return dfs_isRBTree(root->left, count_of_black_now, count_of_black) && dfs_isRBTree(root->right, count_of_black_now, count_of_black);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %r15
movl %r14d, %eax
movzbl (%r12), %r14d
addl %eax, %r14d
movq 0x10(%r12), %rsi
testq %rsi, %rsi
jne 0xa725
cmpq $0x0, 0x18(%r12)
je 0xa760
testq %rsi, %rsi
je 0xa74d
cmpq $0x0, 0x18(%r12)
je 0xa740
movq %r15, %rdi
movl %r14d, %edx
movl %ebx, %ecx
callq 0xa6f0
testb %al, %al
jne 0xa755
jmp 0xa75c
leal 0x1(%r14), %eax
movq %rsi, %r12
cmpl %ebx, %eax
je 0xa703
jmp 0xa75c
leal 0x1(%r14), %eax
cmpl %ebx, %eax
jne 0xa75c
movq 0x18(%r12), %r12
jmp 0xa703
xorl %eax, %eax
jmp 0xa769
incl %r14d
cmpl %ebx, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::left_rotate(ezSTL::__rbtree_node<int>*)
void rbtree<T, Compare, Alloc>::left_rotate(link_type z) {
		link_type y = z->right;
		z->right = y->left;
		if (y->left)
			y->left->parent = z;
		y->parent = z->parent;
		// change root
		if (z == root())
			header.node->parent = y;
		else if (z == z->parent->left)
			z->parent->left = y;
		else if (z == z->parent->right)
			z->parent->right = y;
		y->left = z;
		z->parent = y;
	}

// Assembly:
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsi)
testq %rcx, %rcx
je 0xa86d
movq %rsi, 0x8(%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
cmpq %rsi, 0x8(%rcx)
je 0xa895
movq 0x8(%rsi), %rcx
cmpq %rsi, 0x10(%rcx)
je 0xa89b
cmpq %rsi, 0x18(%rcx)
jne 0xa8a2
addq $0x18, %rcx
jmp 0xa89f
addq $0x8, %rcx
jmp 0xa89f
addq $0x10, %rcx
movq %rax, (%rcx)
movq %rsi, 0x10(%rax)
movq %rax, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::right_rotate(ezSTL::__rbtree_node<int>*)
void rbtree<T, Compare, Alloc>::right_rotate(link_type z) {
		link_type y = z->left;
		z->left = y->right;
		if (y->right)
			y->right->parent = z;
		y->parent = z->parent;
		// change root
		if (z == root())
			header.node->parent = y;
		else if (z == z->parent->left)
			z->parent->left = y;
		else if (z == z->parent->right)
			z->parent->right = y;
		y->right = z;
		z->parent = y;
	}

// Assembly:
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsi)
testq %rcx, %rcx
je 0xa8c1
movq %rsi, 0x8(%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
cmpq %rsi, 0x8(%rcx)
je 0xa8e9
movq 0x8(%rsi), %rcx
cmpq %rsi, 0x10(%rcx)
je 0xa8ef
cmpq %rsi, 0x18(%rcx)
jne 0xa8f6
addq $0x18, %rcx
jmp 0xa8f3
addq $0x8, %rcx
jmp 0xa8f3
addq $0x10, %rcx
movq %rax, (%rcx)
movq %rsi, 0x18(%rax)
movq %rax, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::__rbtree_iterator<int>::operator--()
self& operator--() {
			// present node is header
			if (node->color == __rbtree_red && node->parent->parent == node)
				node = node->right;
			// if node has left child
			else if (node->left != nullptr) {
				node = node->left;
				while (node->right != nullptr)
					node = node->right;
			}
			else {
				link_type parent_node = node->parent;
				while (node == parent_node->left) {
					node = parent_node;
					parent_node = parent_node->parent;
				}
				node = parent_node;
			}
			return *this;
		}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
cmpb $0x0, (%rcx)
jne 0xaa87
movq 0x8(%rcx), %rdx
cmpq %rcx, 0x8(%rdx)
je 0xaabd
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0xaa9e
movq %rdx, %rcx
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0xaa90
jmp 0xaac1
movq (%rax), %rdx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rdx
jne 0xaac1
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rdx
je 0xaaab
movq %rdx, (%rax)
jmp 0xaac1
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::unordered_map<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::begin() const
iterator begin() const {
				// find the first pair
				for (size_type i = 0; i < buckets.size(); ++i)
					if (buckets[i]) {
						iterator temp;
						temp.list_iterator = buckets[i]->begin();
						temp.list_pointer = buckets[i];
						temp.um_pointer = const_cast<unordered_map<Key, Value, Hash, KeyEqual>*>(this);
						temp.bucket = i;
						return temp;
					}
				return end();
			}

// Assembly:
movq %rdi, %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
setne %dil
je 0xb122
cmpq $0x0, (%rcx)
je 0xb0e0
xorl %edx, %edx
xorl %r8d, %r8d
jmp 0xb104
leal -0x1(%rdx), %edi
xorl %r9d, %r9d
cmpl %r9d, %edi
je 0xb122
leaq 0x1(%r9), %r8
cmpq $0x0, 0x8(%rcx,%r9,8)
movq %r8, %r9
je 0xb0e6
cmpl %edx, %r8d
setb %dil
movl %r8d, %edx
movq (%rcx,%r8,8), %rcx
movq (%rcx), %r8
movq 0x8(%r8), %r8
movq %r8, (%rax)
movq %rcx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movl %edx, 0x18(%rax)
testb %dil, %dil
jne 0xb137
movups 0x20(%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x30(%rsi), %rcx
movq %rcx, 0x10(%rax)
movl 0x38(%rsi), %ecx
movl %ecx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::operator++()
self& operator++() {
				// if the next node in the same list
				if (list_iterator + 1 != list_pointer->end())
					++list_iterator;
				// if the next node not in the same list
				else {
					list_pointer = um_pointer->buckets[++bucket];
					// go to next bucket until the next bucket is not empty or overranging
					while (bucket < um_pointer->buckets.size() && list_pointer == nullptr)
						list_pointer = um_pointer->buckets[++bucket];
					// if it is not overanging
					if (bucket < um_pointer->buckets.size())
						list_iterator = list_pointer->begin();
				}
				return *this;
			}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x8(%rcx), %rsi
cmpq (%rdx), %rsi
jne 0xb1a8
movq 0x10(%rax), %rsi
movl 0x18(%rax), %ecx
incl %ecx
movl %ecx, 0x18(%rax)
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
subq %rdx, %r8
shrq $0x3, %r8
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
cmpl %r8d, %ecx
setb %dil
jae 0xb1a0
testq %rsi, %rsi
jne 0xb1a0
movl %r8d, %r8d
leaq 0x1(%rcx), %r9
movq (%rdx,%r9,8), %rsi
movq %rsi, 0x8(%rax)
incl %ecx
cmpq %r8, %r9
setb %dil
jae 0xb19d
incq %r9
testq %rsi, %rsi
je 0xb182
movl %ecx, 0x18(%rax)
testb %dil, %dil
je 0xb1af
movq (%rsi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>>*, ezSTL::allocator<ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>>*>>::resize(unsigned int)
void vector<T, Alloc>::resize(size_type n) {
		size_type old_size = size();
		// if old size is bigger than n
		if (old_size >= n) {
			for (; old_size > n; --old_size) {
				pop_back();
			}
		}
		else {
			// allocate more space
			iterator new_start = allocate(n);
			for (size_type i = 0; i < n; ++i) {
				if(i < size()) construct(new_start + i, (*this)[i]);
				else construct(new_start + i, T());
			}
			clear();
			start = new_start;
			finish = start + n;
			end_of_storage = finish;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
cmpl %esi, %eax
jae 0xb212
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x21f0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rsi
jae 0xb1f3
movq (%rcx,%rsi,8), %rdi
jmp 0xb1f5
xorl %edi, %edi
movq %rdi, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0xb1e8
movq %rax, (%rbx)
leaq (%rax,%r14,8), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0xb22f
jbe 0xb22f
movq 0x8(%rbx), %rcx
notl %esi
addl %eax, %esi
shlq $0x3, %rsi
negq %rsi
leaq (%rcx,%rsi), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/algorithm.h
// Function: void ezSTL::__merge_sort<ezSTL::pair<unsigned int, unsigned int>*, ezSTL::less<ezSTL::pair<unsigned int, unsigned int>>>(ezSTL::pair<unsigned int, unsigned int>*, ezSTL::pair<unsigned int, unsigned int>*, ezSTL::less<ezSTL::pair<unsigned int, unsigned int>>)
inline void __merge_sort(Iterator First, Iterator Last, Compare cmp) {
		unsigned int count = Last - First;
		if (count < 2)
			return;
		// if < insertion_threshold, use insertion sort
		else if (count <= insertion_threshold)
			__insertion_sort(First, Last, cmp);
		else {
			Iterator Medium = First + (Last - First) / 2;
			__merge_sort(First, Medium, cmp);
			__merge_sort(Medium, Last, cmp);
			__merge(First, Medium, Last, cmp);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
subq %rdi, %r13
sarq $0x3, %r13
cmpl $0x2, %r13d
jb 0xc356
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x14, %r13d
ja 0xc365
leaq 0x8(%r14), %rsi
cmpq %rbx, %rsi
je 0xc356
movq %r14, %rax
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
movq %rsi, %rax
cmpl (%r14), %edx
jae 0xc32b
cmpq %r14, %rax
jbe 0xc323
movq %rax, %rsi
movq -0x8(%rsi), %rdi
movq %rdi, (%rsi)
leaq -0x8(%rsi), %rdi
movq %rdi, %rsi
cmpq %r14, %rdi
ja 0xc310
movl %edx, (%r14)
movq %r14, %rsi
jmp 0xc34a
movl -0x8(%rax), %edi
movq %rax, %rsi
cmpl %edi, %edx
jae 0xc348
movl %edi, (%rsi)
movl -0x10(%rsi), %edi
movl -0x4(%rsi), %r8d
movl %r8d, 0x4(%rsi)
addq $-0x8, %rsi
jmp 0xc331
movl %edx, (%rsi)
movl %ecx, 0x4(%rsi)
leaq 0x8(%rax), %rsi
cmpq %rbx, %rsi
jne 0xc2fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
shrq $0x3f, %r12
addq %r13, %r12
sarq %r12
leaq (%r14,%r12,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc2c7
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc2c7
leaq (,%r12,8), %rbp
movl %r12d, %r12d
shlq $0x3, %r12
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rbp, %rdx
movabsq $0x7fffffff8, %rax      # imm = 0x7FFFFFFF8
andq %rax, %rdx
je 0xc3da
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
leaq (%rcx,%rbp), %rax
andq %rcx, %rax
addq %rax, %r15
addq $0x8, %r15
movq %r15, %rdi
subq %r12, %rdi
incq %r13
movq %r14, %rax
cmpq $0x3, %r13
jb 0xc40b
movq %r14, %rax
movq %rdi, %rcx
cmpq %rax, %rcx
je 0xc3fd
movq (%rax), %rdx
movq %rdx, (%rcx)
addq $0x8, %rax
addq $0x8, %rcx
addq $-0x8, %rbp
jne 0xc3f2
cmpq %rbx, %r14
je 0xc454
movq %rdi, %rcx
cmpq %r15, %rcx
je 0xc423
cmpq %rbx, %rax
je 0xc443
movl (%rax), %edx
cmpl (%rcx), %edx
jae 0xc443
movq %rax, %rdx
leaq 0x8(%rax), %rsi
cmpq %rax, %r14
movq %rsi, %rax
je 0xc438
movq (%rdx), %rdx
movq %rdx, (%r14)
addq $0x8, %r14
cmpq %rbx, %r14
jne 0xc413
jmp 0xc454
movq %rcx, %rdx
leaq 0x8(%rcx), %rsi
cmpq %rcx, %r14
movq %rsi, %rcx
jne 0xc432
jmp 0xc438
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/nicluo[P]sorting-numbers/sort.cpp
// Function: readFromFile(char*)
std::vector<int> readFromFile(char* filename) {
    std::vector<int> values = std::vector<int>();
    
    /* Open input file */
    std::ifstream in(filename);
    
    /* Read all integers from file */
    if(in) {
        int v;
        while(in >> v) {
            values.push_back(v);
        }
    }
    
    in.close();
    
    return values;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movl $0x8, %edx
callq 0x21d0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x2418
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23f4
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2455
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2422
movq %rbx, %rdi
movq %r15, %rdx
callq 0x26ba
jmp 0x2422
jmp 0x2469
movq %rax, %r14
jmp 0x2476
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x248a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/nicluo[P]sorting-numbers/sort.cpp
// Function: writeToFile(char*, std::vector<int, std::allocator<int>>&)
void writeToFile(char* filename, std::vector<int> &values) {
    /* Open output file */
    std::ofstream out;
    out.open(filename, std::ofstream::out);
    
    /* Write all integers to file */
    for(int v : values) {
        out << v << "\n";
    }
    
    out.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21a0
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2040
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x24ff
leaq 0x8(%rsp), %rbx
leaq 0xb40(%rip), %r14       # 0x301b
movl (%r15), %esi
movq %rbx, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
addq $0x4, %r15
cmpq %r12, %r15
jne 0x24db
leaq 0x8(%rsp), %rdi
callq 0x2150
movq 0x2ac0(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x20f0
leaq 0x100(%rsp), %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x254c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/nicluo[P]sorting-numbers/sort.cpp
// Function: sortHelper(std::vector<int, std::allocator<int>>&, int, int)
void sortHelper(std::vector<int> &values, int start, int end) {
    /* Check if already sorted */
    if(end - start <= 1) return;

    /* Pick the first element as the pivot,
       we already know the elements are random
       so this is as good as a random pivot */
    int pivot = values[start];

    int swapIndex = start + 1;
    for(int index = start + 1; index < end; index++) {
        /* Move elements smaller than pivot value to the front
           of the list */
        if(values[index] < pivot) {
            swap(values, index, swapIndex);
            swapIndex++;
        }
    }

    /* Swap pivot to appropriate point in list,
       since elements to the left of the pivot are smaller,
       and the pivot is at the zeroth position,
       it should swap with a smaller value, i.e. swapIndex - 1 */
    swap(values, start, swapIndex - 1);

    /* Sort sublists */
    sortHelper(values, start, swapIndex);
    sortHelper(values, swapIndex, end);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ebp
movl %ebx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jl 0x25f4
movslq %esi, %rax
movq (%r14), %rcx
leal 0x1(%rsi), %r15d
cmpl %ebx, %r15d
jge 0x25d4
movl (%rcx,%rax,4), %edx
movslq %r15d, %rdi
leaq (%rcx,%rdi,4), %rdi
movl %ebp, %r8d
subl %esi, %r8d
xorl %r9d, %r9d
movl (%rdi,%r9,4), %r10d
cmpl %edx, %r10d
jge 0x25cc
movslq %r15d, %r15
movl (%rcx,%r15,4), %r11d
movl %r11d, (%rdi,%r9,4)
movl %r10d, (%rcx,%r15,4)
incl %r15d
incq %r9
cmpl %r9d, %r8d
jne 0x25b1
movl (%rcx,%rax,4), %edi
movslq %r15d, %rdx
movl -0x4(%rcx,%rdx,4), %r8d
movl %r8d, (%rcx,%rax,4)
movl %edi, -0x4(%rcx,%rdx,4)
movq %r14, %rdi
callq 0x2577
movl %r15d, %esi
jmp 0x2586
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nicluo[P]sorting-numbers/sort.cpp
// Function: main
int main(int argc, char *argv[]) {
    /* Must provide -f */
    if (argc != 3 || strncmp(argv[1], "-f", 3) != 0) {
        printUsage(argv[0]);
        return 1;
    }
    
    std::vector<int> values = readFromFile(argv[2]);
    sort(values);
    writeToFile(argv[2], values);
    
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x2639
movq 0x8(%rbx), %rdi
leaq 0x9f2(%rip), %rsi       # 0x301d
movl $0x3, %edx
callq 0x20a0
testl %eax, %eax
je 0x264e
movq (%rbx), %rdi
callq 0x231c
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x23b8
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2577
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2492
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2694
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
xorl %eax, %eax
jmp 0x2646
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x26b1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_arc.cc
// Function: Interp::arc_data_comp_r(int, int, int, double, double, double, double, double, double, double*, double*, int*, double)
int Interp::arc_data_comp_r(int move,    //!< either G_2 (cw arc) or G_3 (ccw arc)
                            int plane,
                           int side,    //!< either RIGHT or LEFT
                           double tool_radius,  //!< radius of the tool
                           double current_x,    //!< first coordinate of current point
                           double current_y,    //!< second coordinate of current point
                           double end_x,        //!< first coordinate of arc end point
                           double end_y,        //!< second coordinate of arc end point
                           double big_radius,   //!< radius of arc
                           double *center_x,    //!< pointer to first coordinate of center of arc
                           double *center_y,    //!< pointer to second coordinate of center of arc
                           int *turn,           //!< pointer to number of full or partial circles CCW
                           double tolerance)    //!< tolerance of differing radii
{
  double abs_radius;            // absolute value of big_radius

  abs_radius = fabs(big_radius);
  CHKS(((abs_radius <= tool_radius) && (((side == LEFT) && (move == G_3)) ||
                                       ((side == RIGHT) && (move == G_2)))),
      NCE_TOOL_RADIUS_NOT_LESS_THAN_ARC_RADIUS_WITH_COMP);

  return arc_data_r(move, plane, current_x, current_y, end_x, end_y, big_radius, 
             center_x, center_y, turn, tolerance);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbp), %rax
movapd 0x294b5(%rip), %xmm7    # 0x35020
andpd %xmm5, %xmm7
ucomisd %xmm7, %xmm0
jae 0xbb9f
movq %rbx, %rdi
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
movaps %xmm3, %xmm2
movaps %xmm4, %xmm3
movapd %xmm5, %xmm4
movq %r8, %rcx
movq %r9, %r8
movq %rax, %r9
movaps %xmm6, %xmm5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xac60
movl %ecx, %edx
xorl $0x2, %edx
movl %esi, %edi
xorl $0x1e, %edi
orl %edx, %edi
je 0xbbb9
xorl $0x1, %ecx
movl %esi, %edx
xorl $0x14, %edx
orl %ecx, %edx
jne 0xbb75
leaq 0x295b1(%rip), %rdi     # 0x35171
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x38387(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x295c5(%rip), %rsi     # 0x351b6
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_check.cc
// Function: Interp::check_items(block_struct*, setup_struct*)
int Interp::check_items(block_pointer block,     //!< pointer to a block to be checked
                       setup_pointer settings)  //!< pointer to machine settings
{

  CHP(check_g_codes(block, settings));
  CHP(check_m_codes(block));
  CHP(check_other_codes(block));
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xa1a0
movl %eax, %ebx
testl %eax, %eax
je 0xc317
movq 0x37cab(%rip), %r12     # 0x43f60
movslq 0xd670(%r12), %rax
cmpq $0x30, %rax
jg 0xc313
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r12,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x2aacd(%rip), %rsi     # 0x36daa
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r12), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r12,%rcx)
incl %eax
movl %eax, 0xd670(%r12)
movb %dl, 0xc720(%r12,%rcx)
testl %ebx, %ebx
jne 0xc390
movq %r15, %rdi
movq %r14, %rsi
callq 0xafe0
movl %eax, %r12d
testl %eax, %eax
je 0xc38b
movq 0x37c30(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0xc388
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x2aa53(%rip), %rsi     # 0x36daa
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
movl %r12d, %ebx
testl %r12d, %r12d
je 0xc39b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0xa390
testl %eax, %eax
je 0xc410
movl %eax, %ebx
movq 0x37bad(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0xc390
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x2a9d0(%rip), %rsi     # 0x36daa
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r14), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0xc390
xorl %ebx, %ebx
jmp 0xc390
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_current(setup_struct*, double, double, double)
int Interp::comp_set_current(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->current_x = x;
        settings->current_y = y;
        settings->current_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->current_x = y;
        settings->current_y = z;
        settings->current_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_current");
    }
    return INTERP_OK;
}

// Assembly:
movl 0xc67c(%rsi), %eax
cmpl $0x3, %eax
je 0xca9c
cmpl $0x1, %eax
jne 0xcab7
movsd %xmm0, 0x600(%rsi)
movsd %xmm1, 0x608(%rsi)
movsd %xmm2, 0x610(%rsi)
jmp 0xcab4
movsd %xmm1, 0x600(%rsi)
movsd %xmm2, 0x608(%rsi)
movsd %xmm0, 0x610(%rsi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2b097(%rip), %rsi     # 0x37b5b
xorl %eax, %eax
callq 0xa850
movq 0x3748e(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x2a563(%rip), %rsi     # 0x3704d
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_programmed(setup_struct*, double, double, double)
int Interp::comp_set_programmed(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->program_x = x;
        settings->program_y = y;
        settings->program_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->program_x = y;
        settings->program_y = z;
        settings->program_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_programmed");
    }
    return INTERP_OK;
}

// Assembly:
movl 0xc67c(%rsi), %eax
cmpl $0x3, %eax
je 0xcbec
cmpl $0x1, %eax
jne 0xcc07
movsd %xmm0, 0xc690(%rsi)
movsd %xmm1, 0xc698(%rsi)
movsd %xmm2, 0xc6a0(%rsi)
jmp 0xcc04
movsd %xmm1, 0xc690(%rsi)
movsd %xmm2, 0xc698(%rsi)
movsd %xmm0, 0xc6a0(%rsi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2af98(%rip), %rsi     # 0x37bac
xorl %eax, %eax
callq 0xa850
movq 0x3733e(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x2a4b5(%rip), %rsi     # 0x370ef
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_control_mode(int, double, double, setup_struct*)
int Interp::convert_control_mode(int g_code,     //!< g_code being executed (G_61, G61_1, || G_64)
				double tolerance,    //tolerance for the path following in G64
				double naivecam_tolerance,    //tolerance for the naivecam
                                setup_pointer settings) //!< pointer to machine settings                 
{
  CHKS((settings->cutter_comp_side != OFF),
       (_("Cannot change control mode with cutter radius compensation on")));
  if (g_code == G_61) {
    SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH, 0);
    settings->control_mode = CANON_EXACT_PATH;
  } else if (g_code == G_61_1) {
    SET_MOTION_CONTROL_MODE(CANON_EXACT_STOP, 0);
    settings->control_mode = CANON_EXACT_STOP;
  } else if (g_code == G_64) {
	if (tolerance >= 0) {
	    SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS, tolerance);
	} else {
	    SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS, 0);
	}
	if (naivecam_tolerance >= 0) {
	    SET_NAIVECAM_TOLERANCE(naivecam_tolerance);
	} else if (tolerance >= 0) {
	    SET_NAIVECAM_TOLERANCE(tolerance);   // if no naivecam_tolerance specified use same for both
	} else {
	    SET_NAIVECAM_TOLERANCE(0);
	}
    settings->control_mode = CANON_CONTINUOUS;
  } else 
    ERS(NCE_BUG_CODE_NOT_G61_G61_1_OR_G64);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpl $0x0, 0x624(%rdx)
je 0x108e2
leaq 0x27c82(%rip), %rdi     # 0x3850c
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x336bd(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x26a1a(%rip), %rsi     # 0x372d5
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x10989
movq %rdx, %rbx
cmpl $0x280, %esi            # imm = 0x280
je 0x10935
cmpl $0x263, %esi            # imm = 0x263
je 0x1091b
cmpl $0x262, %esi            # imm = 0x262
jne 0x10992
xorpd %xmm0, %xmm0
movl $0x2, %edi
callq 0xa0d0
movl $0x2, 0x5f8(%rbx)
jmp 0x10987
xorpd %xmm0, %xmm0
movl $0x1, %edi
callq 0xa0d0
movl $0x1, 0x5f8(%rbx)
jmp 0x10987
xorpd %xmm2, %xmm2
cmplesd %xmm0, %xmm2
andpd %xmm0, %xmm2
movapd %xmm2, -0x30(%rbp)
movl $0x3, %edi
movapd %xmm2, %xmm0
movaps %xmm1, -0x20(%rbp)
callq 0xa0d0
xorpd %xmm0, %xmm0
movapd -0x20(%rbp), %xmm2
cmpnlesd %xmm2, %xmm0
movapd -0x30(%rbp), %xmm1
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
callq 0xa960
movl $0x3, 0x5f8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x27bb1(%rip), %rdi     # 0x3854a
jmp 0x1088a
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::rotate(double*, double*, double)
void Interp::rotate(double *x, double *y, double theta) {
    double xx, yy;
    double t = D2R(theta);
    xx = *x * cos(t) - *y * sin(t); 
    yy = *x * sin(t) + *y * cos(t);
    *x = xx;
    *y = yy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
mulsd 0x2651c(%rip), %xmm0    # 0x36ed0
movq %rsi, %r14
divsd 0x26519(%rip), %xmm0    # 0x36ed8
movsd %xmm0, -0x30(%rbp)
movsd (%rsi), %xmm1
movsd %xmm1, -0x20(%rbp)
callq 0xb550
movsd %xmm0, -0x28(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa1d0
mulsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd (%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa1d0
movsd %xmm0, -0x18(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xb550
mulsd -0x38(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd %xmm1, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_cutter_compensation(int, block_struct*, setup_struct*)
int Interp::convert_cutter_compensation(int g_code,      //!< must be G_40, G_41, or G_42             
                                       block_pointer block,     //!< pointer to a block of RS274 instructions
                                       setup_pointer settings)  //!< pointer to machine settings             
{

  if (g_code == G_40) {
    CHP(convert_cutter_compensation_off(settings));
  } else if (g_code == G_41) {
    CHP(convert_cutter_compensation_on(LEFT, block, settings));
  } else if (g_code == G_42) {
    CHP(convert_cutter_compensation_on(RIGHT, block, settings));
  } else if (g_code == G_41_1) {
    CHP(convert_cutter_compensation_on(LEFT, block, settings));
  } else if (g_code == G_42_1) {
    CHP(convert_cutter_compensation_on(RIGHT, block, settings));
  } else
    ERS("BUG: Code not G40, G41, G41.1, G42, G42.2");

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x19a, %esi            # imm = 0x19A
jle 0x10f4e
cmpl $0x19b, %esi            # imm = 0x19B
je 0x10f66
cmpl $0x1a4, %esi            # imm = 0x1A4
je 0x10f47
cmpl $0x1a5, %esi            # imm = 0x1A5
jne 0x10fea
movl $0x1, %esi
jmp 0x10f6b
cmpl $0x190, %esi            # imm = 0x190
je 0x10fe0
cmpl $0x19a, %esi            # imm = 0x19A
jne 0x10fea
movl $0x2, %esi
callq 0xa260
testl %eax, %eax
je 0x10fdc
movl %eax, %ebx
movq 0x32fe3(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x10fd8
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x263d3(%rip), %rsi     # 0x37377
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r14), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
testl %ebx, %ebx
jne 0x11039
xorl %ebx, %ebx
jmp 0x11039
movq %rcx, %rsi
callq 0xaf70
jmp 0x10f70
leaq 0x27613(%rip), %rsi     # 0x38604
xorl %eax, %eax
callq 0xa850
movq 0x32f61(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x26360(%rip), %rsi     # 0x37377
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_cutter_compensation_off(setup_struct*)
int Interp::convert_cutter_compensation_off(setup_pointer settings)      //!< pointer to machine settings
{
#ifdef DEBUG_EMC
  enqueue_COMMENT("interpreter: cutter radius compensation off");
#endif
  if(settings->cutter_comp_side != OFF && settings->cutter_comp_radius > 0.0) {
      double cx, cy, cz;
      comp_get_current(settings, &cx, &cy, &cz);
      CHP(move_endpoint_and_flush(settings, cx, cy));
      dequeue_canons(settings);
      settings->current_x = settings->program_x;
      settings->current_y = settings->program_y;
      settings->current_z = settings->program_z;
      settings->arc_not_allowed = ON;
  }
  settings->cutter_comp_side = OFF;
  settings->cutter_comp_firstmove = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x275d2(%rip), %rdi     # 0x3862e
callq 0xb370
cmpl $0x0, 0x624(%rbx)
je 0x11156
movsd 0x618(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x11156
leaq -0x38(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq -0x28(%rbp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xb6b0
movsd (%r15), %xmm0
movsd (%r12), %xmm1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa760
movl %eax, %r14d
testl %eax, %eax
je 0x11122
movq 0x32e9b(%rip), %r15     # 0x43f60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x11151
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x262dc(%rip), %rsi     # 0x373c8
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r15), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r15,%rcx)
incl %eax
movl %eax, 0xd670(%r15)
movb %dl, 0xc720(%r15,%rcx)
jmp 0x11151
movq %rbx, %rdi
callq 0xa300
movsd 0xc690(%rbx), %xmm0
movsd %xmm0, 0x600(%rbx)
movupd 0xc698(%rbx), %xmm0
movupd %xmm0, 0x608(%rbx)
movb $0x1, 0x110(%rbx)
testl %r14d, %r14d
jne 0x1116a
movl $0x0, 0x624(%rbx)
movb $0x1, 0xc689(%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq