LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x18(%rsp), %rax
je 0xed7e
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xed56
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0xed54
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xed24
movq 0x8(%rsp), %rdi
callq 0x2200
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xed40
movq (%rsp), %rdi
callq 0x2200
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
jmp 0xed56
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_unique_ptr<int>(ezSTL::unique_ptr<int>&)
void test::print_unique_ptr(unique_ptr<T>& ptr) {
		if (ptr)
			std::cout << "unique_ptr: value:" << *ptr << std::endl;
		else
			std::cout << "null object" << std::endl;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15980
testb $0x1, %al
jne 0xedc9
jmp 0xee08
movq 0x22208(%rip), %rdi     # 0x30fd8
leaq 0x17b5f(%rip), %rsi     # 0x26936
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x159a0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq %rax, %rdi
movq 0x221c7(%rip), %rsi     # 0x30fc8
callq 0x2250
jmp 0xee2a
movq 0x221c9(%rip), %rdi     # 0x30fd8
leaq 0x17b14(%rip), %rsi     # 0x2692a
callq 0x2220
movq %rax, %rdi
movq 0x221a3(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x18, %rsp
retq
nop
// File: cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_weak_ptr<int>(ezSTL::weak_ptr<int>&)
void test::print_weak_ptr(weak_ptr<T>& ptr) {
		if (!ptr.expired())
			std::cout << "weak_ptr: shared_ptr use_count: " << ptr.use_count() << " ; expired: " << ptr.expired() << std::endl;
		else
			std::cout << "null object" << std::endl;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x159b0
testb $0x1, %al
jne 0xef22
movq 0x2211a(%rip), %rdi     # 0x30fd8
leaq 0x17a84(%rip), %rsi     # 0x26949
callq 0x2220
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x159f0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x17a7d(%rip), %rsi     # 0x2696a
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x159b0
movq 0x8(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq %rax, %rdi
movq 0x220ad(%rip), %rsi     # 0x30fc8
callq 0x2250
jmp 0xef44
movq 0x220af(%rip), %rdi     # 0x30fd8
leaq 0x179fa(%rip), %rsi     # 0x2692a
callq 0x2220
movq %rax, %rdi
movq 0x22089(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10917
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x108e0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10936
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x108e0
movq 0x18(%rsp), %rsi
leaq 0x17(%rsp), %rdi
callq 0x10960
movq 0x18(%rsp), %rsi
leaq 0x16(%rsp), %rdi
movl $0x1, %edx
callq 0x10980
addq $0x28, %rsp
retq
nop
// File: cjc12[P]ezSTL/src/../include/iterator.h
// Function: void ezSTL::__advance<ezSTL::__list_iterator<int>, int>(ezSTL::__list_iterator<int>&, int, ezSTL::bidirectional_iterator_tag)
inline void __advance(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag) {
		if (n >= 0)
			while (n--) ++i;
		else
			while (n++) --i;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x11e36
jmp 0x11e16
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x0, %eax
je 0x11e34
movq 0x8(%rsp), %rdi
callq 0x11d30
jmp 0x11e16
jmp 0x11e58
jmp 0x11e38
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x0, %eax
je 0x11e56
movq 0x8(%rsp), %rdi
callq 0x11e70
jmp 0x11e38
jmp 0x11e58
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x1215a
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x12158
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x12138
jmp 0x121bd
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1219b
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x1216b
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rsp), %rax
je 0x121bb
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x121bd
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::isRBTree()
bool rbtree<T, Compare, Alloc>::isRBTree() {
		if (empty()) return true;
		// if root is not black, return false
		if (root()->color != __rbtree_black)
			return false;
		// if a node is red and its left or right is not black, return false
		for (auto ite = begin(); ite != end(); ++ite) {
			if (ite.node->color == __rbtree_red) {
				if (ite.node->left != nullptr && ite.node->left->color != __rbtree_black)
					return false;
				if (ite.node->right != nullptr && ite.node->right->color != __rbtree_black)
					return false;
			}
				
		}
		link_type x = root();
		unsigned int count_of_black = 0;
		// count the number of black nodes in a path
		while (x != nullptr) {
			if (x->color == __rbtree_black)
				++count_of_black;
			x = x->left;
		}
		// NIL node is black
		++count_of_black;
		// if the number of black nodes in any path are different, return false
		return dfs_isRBTree(root(), 0, count_of_black);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x120b0
testb $0x1, %al
jne 0x121ed
jmp 0x121f7
movb $0x1, 0x37(%rsp)
jmp 0x12337
movq (%rsp), %rdi
callq 0x12390
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x12216
movb $0x0, 0x37(%rsp)
jmp 0x12337
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x120d0
movq (%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd2a0
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd570
testb $0x1, %al
jne 0x12247
jmp 0x122c1
movq 0x20(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x122b0
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12283
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x12283
movb $0x0, 0x37(%rsp)
jmp 0x12337
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x122ae
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x122ae
movb $0x0, 0x37(%rsp)
jmp 0x12337
jmp 0x122b0
jmp 0x122b2
leaq 0x20(%rsp), %rdi
callq 0x12110
jmp 0x12224
movq (%rsp), %rdi
callq 0x12390
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1230b
movq 0x10(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x122fb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x122d7
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
callq 0x12390
movq (%rsp), %rdi
movq %rax, %rsi
movl 0xc(%rsp), %ecx
xorl %edx, %edx
callq 0x123b0
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x123ec
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1242d
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1242d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
je 0x12423
movb $0x0, 0x37(%rsp)
jmp 0x12517
movb $0x1, 0x37(%rsp)
jmp 0x12517
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1247a
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
xorl %eax, %eax
cmpl 0x18(%rsp), %ecx
movb %al, 0xf(%rsp)
jne 0x1246b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x123b0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x12517
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x124c4
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
xorl %eax, %eax
cmpl 0x18(%rsp), %ecx
movb %al, 0xe(%rsp)
jne 0x124b8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x123b0
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x12517
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x123b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
jne 0x124ee
jmp 0x1250d
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x123b0
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12856
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x12390
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x1289b
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x128ed
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0x128c3
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x128eb
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jne 0x128e9
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x128eb
jmp 0x128ed
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12966
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x12390
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x129ab
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x129fd
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0x129d3
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x129fb
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jne 0x129f9
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x129fb
jmp 0x129fd
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: 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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq (%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x12f67
movq -0x18(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpq (%rcx), %rax
jne 0x12f67
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x12ff7
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x12fa7
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x12fa5
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x12f85
jmp 0x12ff5
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x12fe8
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x12fb8
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x12ff7
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: cjc12[P]ezSTL/src/../include/utility.h
// Function: ezSTL::pair<int, int>::operator=(ezSTL::pair<int, int> const&)
pair<FIRST, SECOND>& operator=(const pair<FIRST, SECOND>& p) {
			if (this != &p)
			{
				first = p.first;
				second = p.second;
			}
			return *this;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq -0x10(%rsp), %rax
je 0x13754
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)
// File: 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>>>>*>>::allocate_and_fill(unsigned int, ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>>* const&)
iterator allocate_and_fill(size_type n, const_reference value) {
			iterator result = allocate(n);
			for (size_type i = 0; i < n; ++i)
				construct(result++, value);
			return result - n;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsp), %esi
callq 0x14670
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x14649
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdx
callq 0x14690
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14612
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x144b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x14948
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14af0
cmpq $0x0, (%rax)
je 0x14936
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14af0
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x14b20
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14b50
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14af0
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq (%rdx), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movl 0x34(%rsp), %ecx
movl %ecx, 0x18(%rax)
jmp 0x14957
jmp 0x14938
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x148ad
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xe4d0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x14b90
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x14d00
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x14ce0
testb $0x1, %al
jne 0x149fa
jmp 0x14a09
movq 0x10(%rsp), %rdi
callq 0x14c80
jmp 0x14ada
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
addl $0x1, %esi
movl %esi, 0x18(%rax)
callq 0x14d30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0x144b0
movl 0x8(%rsp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
jae 0x14a65
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x14a6f
jmp 0x14a97
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
addl $0x1, %esi
movl %esi, 0x18(%rax)
callq 0x14d30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x14a2f
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x4(%rsp)
movq 0x10(%rax), %rdi
callq 0x144b0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x14ad8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x18(%rsp), %rdi
callq 0x14b20
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14b50
jmp 0x14ada
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::operator==(ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>> const&) const
bool operator== (const self& x) const {
				// if *this and x are both end()
				if (bucket >= um_pointer->buckets.size() && x.bucket >= x.um_pointer->buckets.size())
					return true;
				return list_iterator == x.list_iterator && bucket == x.bucket;
			}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rax), %ecx
movl %ecx, 0x1c(%rsp)
movq 0x10(%rax), %rdi
callq 0x144b0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jb 0x14dbd
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x144b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jb 0x14dbd
movb $0x1, 0x37(%rsp)
jmp 0x14dfc
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15110
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x14ddb
jmp 0x14df2
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x144b0
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jb 0x15022
jmp 0x14ffc
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jbe 0x1501d
movq 0x18(%rsp), %rdi
callq 0x15280
movl 0x38(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x14ffc
jmp 0x15109
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x14670
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x150d8
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x144b0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x1509e
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %esi
callq 0x14d30
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x14690
jmp 0x150c6
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rdx
callq 0x14690
jmp 0x150c8
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1503d
movq 0x18(%rsp), %rdi
callq 0x152a0
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movl 0x3c(%rsp), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nop
// File: cjc12[P]ezSTL/src/../include/functional.h
// Function: ezSTL::_Hash_seq(unsigned char const*, unsigned int)
inline unsigned int _Hash_seq(const unsigned char* str, unsigned int count) {
		const unsigned int FNV_offset_basis = 2166136261U;
		const unsigned int FNV_prime = 16777619U;

		unsigned int result = FNV_offset_basis;
		for (unsigned int next = 0; next < count; ++next) {
			result ^= (unsigned int)str[next];
			result *= FNV_prime;
		}
		return result;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x811c9dc5, -0x10(%rsp) # imm = 0x811C9DC5
movl $0x1000193, -0x14(%rsp) # imm = 0x1000193
movl $0x811c9dc5, -0x18(%rsp) # imm = 0x811C9DC5
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x15191
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
xorl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
imull $0x1000193, -0x18(%rsp), %eax # imm = 0x1000193
movl %eax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x15159
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: cjc12[P]ezSTL/src/../include/unordered_map.h
// Function: ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>>::operator=(ezSTL::__unordered_map_iterator<int, int, ezSTL::hash<int>, ezSTL::equal_to<int>> const&)
self& operator= (const iterator& x) {
				if (this != &x) {
					list_iterator = x.list_iterator;
					list_pointer = x.list_pointer;
					um_pointer = x.um_pointer;
					bucket = x.bucket;
				}
				return *this;
			}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x15905
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14b50
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jae 0x19c8f
jmp 0x19d12
cmpl $0x14, 0x1c(%rsp)
ja 0x19ca7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19d20
jmp 0x19d10
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x19c60
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19c60
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x19e30
jmp 0x19d12
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: cjc12[P]ezSTL/src/../include/algorithm.h
// Function: void ezSTL::__insertion_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 __insertion_sort(Iterator First, Iterator Last, Compare cmp) {
		auto next = First;
		auto value = *First;
		for (auto ite = First + 1; ite != Last; ++ite) {
			next = ite;
			value = *ite;
			if (cmp(value, *First)) {
				__copy_to_next(First, ite);
				*First = value;
			}
			else {
				// unguarded linear insertion
				while (cmp(value, *(next - 1))) {
					*next = *(next - 1);
					--next;
				}
				*next = value;
			}
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18070
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x19e1f
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x17d40
movq 0x28(%rsp), %rdx
leaq 0x37(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d10
testb $0x1, %al
jne 0x19d98
jmp 0x19db8
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19fb0
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d40
jmp 0x19e0a
jmp 0x19dba
movq 0x18(%rsp), %rdx
addq $-0x8, %rdx
leaq 0x37(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d10
testb $0x1, %al
jne 0x19dd8
jmp 0x19dfb
movq 0x18(%rsp), %rsi
addq $-0x8, %rsi
movq 0x18(%rsp), %rdi
callq 0x17d40
movq 0x18(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x19dba
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d40
jmp 0x19e0c
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x19d55
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: cjc12[P]ezSTL/src/../include/algorithm.h
// Function: void ezSTL::__merge<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::pair<unsigned int, unsigned int>*, ezSTL::less<ezSTL::pair<unsigned int, unsigned int>>)
inline void __merge(Iterator First, Iterator Medium, Iterator Last, Compare cmp) {
		vector<typename remove_reference<decltype(*First)>::type> v(Medium - First);
		auto ite1 = First;
		auto ite2 = v.begin();
		// copy from {First, Medium) to vector v
		while (ite1 != Medium)
			*ite2++ = *ite1++;
		ite2 = v.begin();
		// merge
		for (auto ite = First; ite != Last; ++ite) {
			if (ite2 != v.end() && (ite1 == Last || !cmp(*ite1, *ite2)))
				*ite = *ite2++;
			else
				*ite = *ite1++;
		}
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x1a000
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfe30
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x60(%rsp), %rax
je 0x19eae
movq 0x38(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
callq 0x17d40
jmp 0x19e79
leaq 0x40(%rsp), %rdi
callq 0xfe30
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x19f8f
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfe40
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x19f5f
movq 0x38(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x19f28
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x77(%rsp), %rdi
callq 0x17d10
movb %al, 0xf(%rsp)
jmp 0x19f1e
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x19f5f
jmp 0x19f28
movq 0x30(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17d40
jmp 0x19f7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfe80
jmp 0x19f9e
movq 0x38(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17d40
jmp 0x19f7c
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x19ec7
leaq 0x40(%rsp), %rdi
callq 0xfe80
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: cjc12[P]ezSTL/src/../include/algorithm.h
// Function: void ezSTL::__intro_sort_loop<unsigned int*, ezSTL::less<unsigned int>>(unsigned int*, unsigned int*, unsigned int, ezSTL::less<unsigned int>)
void __intro_sort_loop(Iterator First, Iterator Last, unsigned int depth, Compare cmp) {
		unsigned int count;
		while ((count = Last - First) > insertion_threshold && depth > 0) {
			--depth;
			Iterator Medium = __quick_sort_partition(First, Last, cmp);
			if (Medium - First < Last - Medium) {
				__intro_sort_loop(First, Medium, depth, cmp);
				First = Medium;
			}
			else {
				__intro_sort_loop(Medium, Last, depth, cmp);
				Last = Medium;
			}
		}
		// if exceed recursive depth limitation
		if (depth <= 0)
			__heap_sort(First, Last, cmp);
		// if < insertion_threshold, change to insertion sort
		else if (count >= 2)
			__insertion_sort(First, Last, cmp);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl %eax, %ecx
movl %ecx, 0x18(%rsp)
xorl %eax, %eax
cmpl $0x14, %ecx
movb %al, 0xa(%rsp)
jbe 0x1a250
cmpl $0x0, 0x1c(%rsp)
seta %al
movb %al, 0xa(%rsp)
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x1a25d
jmp 0x1a2e4
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1a360
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq %rdx, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jge 0x1a2c2
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x1a210
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x1a2df
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x1a210
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1a222
cmpl $0x0, 0x1c(%rsp)
ja 0x1a2fc
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1a5b0
jmp 0x1a314
cmpl $0x2, 0x18(%rsp)
jb 0x1a312
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1aa10
jmp 0x1a314
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x240(%rbp)
movq %rdi, %rax
movq %rax, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x1800
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x11a0
jmp 0x1392
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x1120
movb %al, -0x241(%rbp)
jmp 0x13b2
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0x13c1
jmp 0x1456
jmp 0x13c3
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x10b0
movq %rax, -0x250(%rbp)
jmp 0x13df
movq -0x250(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1120
movb %al, -0x251(%rbp)
jmp 0x13fd
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x1409
jmp 0x1454
movq -0x240(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x1820
jmp 0x141e
jmp 0x13c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1496
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x1050
jmp 0x1496
jmp 0x1456
leaq -0x220(%rbp), %rdi
callq 0x1040
jmp 0x1464
movb $0x1, -0x11(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x1050
testb $0x1, -0x11(%rbp)
jne 0x1486
movq -0x240(%rbp), %rdi
callq 0x1890
movq -0x238(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x1890
movq -0x228(%rbp), %rdi
callq 0x1190
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x1170
movq -0x248(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x10, %edx
callq 0x1030
jmp 0x14ed
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x18f0
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x1920
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x1950
testb $0x1, %al
jne 0x1537
jmp 0x15ab
leaq -0x230(%rbp), %rdi
callq 0x1990
movl (%rax), %eax
movl %eax, -0x23c(%rbp)
movl -0x23c(%rbp), %esi
leaq -0x210(%rbp), %rdi
callq 0x1180
movq %rax, -0x250(%rbp)
jmp 0x1566
movq -0x250(%rbp), %rdi
leaq 0x1aa7(%rip), %rsi      # 0x301b
callq 0x10e0
jmp 0x157b
jmp 0x157d
leaq -0x230(%rbp), %rdi
callq 0x19b0
jmp 0x151e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x1140
jmp 0x15ce
leaq -0x210(%rbp), %rdi
callq 0x1130
jmp 0x15b9
leaq -0x210(%rbp), %rdi
callq 0x1140
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x1190
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
jg 0x1672
jmp 0x1707
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x19d0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x16d7
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19d0
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x16ca
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x15e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16cc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1696
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x15e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1650
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1650
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0x177a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x18b2(%rip), %rsi      # 0x301d
movl $0x3, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x178f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12f0
movl $0x1, -0x4(%rbp)
jmp 0x17eb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1340
movq -0x40(%rbp), %rdi
callq 0x1710
jmp 0x17af
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14b0
jmp 0x17c2
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1890
jmp 0x17eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1890
jmp 0x17f4
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/interp_arc.cc
// Function: Interp::arc_axis1(int)
char Interp::arc_axis1(int plane) {
    switch(plane) {
    case CANON_PLANE_XY: return 'X';
    case CANON_PLANE_XZ: return 'Z';
    case CANON_PLANE_YZ: return 'Y';
    default: return '!';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x1251c
jmp 0x12508
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x12528
jmp 0x12512
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x12522
jmp 0x1252e
movb $0x58, -0x1(%rbp)
jmp 0x12532
movb $0x5a, -0x1(%rbp)
jmp 0x12532
movb $0x59, -0x1(%rbp)
jmp 0x12532
movb $0x21, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_arc.cc
// Function: Interp::arc_axis2(int)
char Interp::arc_axis2(int plane) {
    switch(plane) {
    case CANON_PLANE_XY: return 'Y';
    case CANON_PLANE_XZ: return 'X';
    case CANON_PLANE_YZ: return 'Z';
    default: return '!';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x1256c
jmp 0x12558
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x12578
jmp 0x12562
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x12572
jmp 0x1257e
movb $0x59, -0x1(%rbp)
jmp 0x12582
movb $0x58, -0x1(%rbp)
jmp 0x12582
movb $0x5a, -0x1(%rbp)
jmp 0x12582
movb $0x21, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)