LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_list<int>(ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>&)
void test::print_list(list<T>& l) {
		std::cout << "size: " << l.size();
		std::cout << " ; empty: " << l.empty();
		if (!l.empty()) std::cout << " ; front: " << l.front();
		if (!l.empty()) std::cout << " ; back: " << l.back();
		std::cout << std::endl << "list: ";
		for (auto ite = l.begin(); ite != l.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xd8c3(%rip), %rbx      # 0x15fd8
leaq 0x820b(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x816b(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x87c3
movq 0xd86e(%rip), %r15      # 0x15fd8
leaq 0x8141(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
cmpl $0x0, 0x8(%r14)
je 0x87c3
movq 0xd83a(%rip), %r15      # 0x15fd8
leaq 0x8118(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
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 0x80df(%rip), %rsi      # 0x108d0
movl $0x6, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %r13
cmpq %rax, %r13
je 0x883d
movq 0xd7c7(%rip), %r15      # 0x15fd8
leaq 0x7ca8(%rip), %r12      # 0x104c0
movl 0x10(%r13), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq 0x8(%r13), %r13
cmpq (%r14), %r13
jne 0x8818
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
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>>::list(ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>> const&)
list<T, Alloc>::list(const list<T, Alloc>& other) {
		Alloc alloc = Alloc();
		link_type prev_node = alloc.allocate();
		alloc.construct(prev_node, __list_node<T>());
		list_iterator.node = prev_node;
		__size = 0;
		// copy each node of other
		for (iterator ite = other.begin(); ite != other.end(); ++ite) {
			link_type new_node = alloc.allocate();
			alloc.construct(new_node, __list_node<T>(*ite));
			if (ite == other.begin())
				list_iterator.node->next = new_node;
			prev_node->next = new_node;
			new_node->prev = prev_node;
			prev_node = new_node;
			++__size;
		}
		prev_node->next = list_iterator.node;
		list_iterator.node->prev = prev_node;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %r12
cmpq %rax, %r12
je 0xb286
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r12), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
movq (%r14), %rcx
cmpq 0x8(%rcx), %r12
jne 0xb26a
movq (%rbx), %rdx
movq %rax, 0x8(%rdx)
movq %rax, 0x8(%r15)
movq %r15, (%rax)
incl 0x8(%rbx)
movq 0x8(%r12), %r12
movq %rax, %r15
cmpq %rcx, %r12
jne 0xb241
movq (%rbx), %r15
jmp 0xb289
movq %r15, %rax
movq %r15, 0x8(%rax)
movq %rax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::operator=(ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>> const&)
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& other) {
		if (this != &other) {
			Alloc alloc = Alloc();
			link_type prev_node = alloc.allocate();
			alloc.construct(prev_node, __list_node<T>());
			list_iterator.node = prev_node;
			__size = 0;
			// copy each node of other
			for (iterator ite = other.begin(); ite != other.end(); ++ite) {
				link_type new_node = alloc.allocate();
				alloc.construct(new_node, __list_node<T>(*ite));
				if (ite == other.begin())
					list_iterator.node->next = new_node;
				prev_node->next = new_node;
				new_node->prev = prev_node;
				prev_node = new_node;
				++__size;
			}
			prev_node->next = list_iterator.node;
			list_iterator.node->prev = prev_node;
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x898e
movq %rsi, %r14
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, 0x10(%r15)
movq %r15, (%rbx)
movl %eax, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %r12
cmpq %rax, %r12
je 0x8984
movl $0x18, %edi
callq 0x21f0
movl 0x10(%r12), %ecx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ecx, 0x10(%rax)
movq (%r14), %rcx
cmpq 0x8(%rcx), %r12
jne 0x8968
movq (%rbx), %rdx
movq %rax, 0x8(%rdx)
movq %rax, 0x8(%r15)
movq %r15, (%rax)
incl 0x8(%rbx)
movq 0x8(%r12), %r12
movq %rax, %r15
cmpq %rcx, %r12
jne 0x8940
movq (%rbx), %r15
jmp 0x8987
movq %r15, %rax
movq %r15, 0x8(%rax)
movq %rax, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::clear()
void list<T, Alloc>::clear() {
		Alloc alloc = Alloc();
		// clear all node
		for (iterator ite = begin(), next_iterator = begin(); ite != end(); ite = next_iterator) {
			next_iterator = ite + 1;
			alloc.destroy(ite.node);
			alloc.deallocate(ite.node);
		}
		list_iterator.node->prev = list_iterator.node;
		list_iterator.node->next = list_iterator.node;
		__size = 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
cmpq %rax, %rdi
je 0x89c5
movq 0x8(%rdi), %r14
callq 0x21c0
movq (%rbx), %rax
movq %r14, %rdi
cmpq %rax, %r14
jne 0x89b1
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_stack<int>(ezSTL::stack<int>&)
void test::print_stack(stack<T>& s) {
		std::cout << "size: " << s.size();
		std::cout << " ; empty: " << s.empty();
		if (!s.empty()) std::cout << " ; top: " << s.top();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd5cb(%rip), %rbx      # 0x15fd8
leaq 0x7f13(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7e73(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x8a87
movq 0xd576(%rip), %r15      # 0x15fd8
leaq 0x7e6e(%rip), %rsi      # 0x108d7
movl $0x8, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
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
popq %rbx
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_queue<int>(ezSTL::queue<int>&)
void test::print_queue(queue<T>& q) {
		std::cout << "size: " << q.size();
		std::cout << " ; empty: " << q.empty();
		if (!q.empty()) std::cout << " ; front: " << q.front();
		if (!q.empty()) std::cout << " ; back: " << q.back();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd515(%rip), %rbx      # 0x15fd8
leaq 0x7e5d(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7dbd(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x8b71
movq 0xd4c0(%rip), %r15      # 0x15fd8
leaq 0x7d93(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
cmpl $0x0, 0x8(%r14)
je 0x8b71
movq 0xd48c(%rip), %r15      # 0x15fd8
leaq 0x7d6a(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
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
popq %rbx
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_priority_queue<int, ezSTL::less<int>>(ezSTL::priority_queue<int, ezSTL::less<int>>&)
void test::print_priority_queue(priority_queue<T, Compare>& pq) {
		std::cout << "size: " << pq.size();
		std::cout << " ; empty: " << pq.empty();
		if (!pq.empty()) std::cout << " ; top: " << pq.top();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd42b(%rip), %rbx      # 0x15fd8
leaq 0x7d73(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7cca(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movq (%r14), %rax
xorl %esi, %esi
cmpq 0x8(%r14), %rax
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x8c30
movq 0xd3c9(%rip), %r15      # 0x15fd8
leaq 0x7cc1(%rip), %rsi      # 0x108d7
movl $0x8, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x22d0
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
popq %rbx
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/queue.h
// Function: ezSTL::priority_queue<int, ezSTL::less<int>>::push(int const&)
void push(const_reference x) {
			base_vector.push_back(x);
			// percolateUp
			for (size_type i = size() - 1; i > 0;) {
				// swap new inserted value and its parent
				if (cmp(base_vector[i], base_vector[(i - 1) / 2])) {
					ezSTL::swap(base_vector[i], base_vector[(i - 1) / 2]);
					i = (i - 1) / 2;
				}
				else break;
			}
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8480
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
je 0x8c9c
movl %ecx, %edx
movl (%rax,%rdx,4), %edx
leal -0x1(%rcx), %esi
movl %esi, %edi
shrl %edi
movl (%rax,%rdi,4), %r8d
cmpl %r8d, %edx
jge 0x8c9c
movl %ecx, %ecx
movl %r8d, (%rax,%rcx,4)
movl %edx, (%rax,%rdi,4)
movl %edi, %ecx
cmpl $0x1, %esi
ja 0x8c7c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_rbtree<int, ezSTL::less<int>>(ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>&)
void test::print_rbtree(rbtree<T, Compare>& rbt) {
		std::cout << "size: " << rbt.size();
		std::cout << " ; empty: " << rbt.empty();
		std::cout << std::endl << "rbtree: ";
		for (auto ite = rbt.begin(); ite != rbt.end(); ++ite)
			std::cout << *ite << " ";
		/*for(auto ite = rbt.end(); ite != rbt.begin(); --ite)
			if(ite != rbt.end()) std::cout << *ite << " ";
		if(!empty()) std::cout << *rbt.begin() << " ";*/
		std::cout << std::endl;
		if(rbt.isRBTree())
			std::cout << "It is exactly an rbtree!" << std::endl;
		else
			std::cout << "It is not an rbtree." << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0xd26f(%rip), %rbx      # 0x15fd8
leaq 0x7bb7(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7b18(%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 0x7b04(%rip), %rsi      # 0x108e0
movl $0x8, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
cmpq %rcx, %rax
je 0x8e3c
movq 0xd1d6(%rip), %r15      # 0x15fd8
leaq 0x76b7(%rip), %r12      # 0x104c0
leaq 0x8(%rsp), %r13
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq %r13, %rdi
callq 0xa578
movq 0x8(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x8e0e
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
movq %r14, %rdi
callq 0xa5c0
movq 0xd166(%rip), %rdi      # 0x15fd8
testb %al, %al
je 0x8e84
leaq 0x7a6c(%rip), %rsi      # 0x108e9
movl $0x18, %edx
jmp 0x8e90
leaq 0x7a77(%rip), %rsi      # 0x10902
movl $0x14, %edx
callq 0x2220
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 $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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>>>>::insert(ezSTL::pair<int, int> const&)
void rbtree<T, Compare, Alloc>::insert(const value_type& v) {
		// z : node to be inserted
		link_type z = Alloc().allocate();
		Alloc().construct(z, v);
		// y : parent node of z
		link_type y = nullptr;
		// x : node used to find proper position
		link_type x = root();
		// find the proper position to insert
		while (x != nullptr) {
			y = x;
			if (cmp(v, x->data))
				x = x->left;
			else if(cmp(x->data, v))
				x = x->right;
			// if v == x->data , renew it
			else {
				x->data = v;
				return;
			}
		}
		z->parent = y;
		// if it is an empty tree
		if (y == nullptr) {
			header.node->parent = z;
			header.node->left = z;
			header.node->right = z;
			z->parent = header.node;
		}
		else if (cmp(v, y->data))
			y->left = z;
		else y->right = z;
		// fix up
		insert_fixup(z);
		// adjust header: left and right
		if (empty() || cmp(v, leftmost()->data))
			header.node->left = z;
		if (empty() || cmp(rightmost()->data, v))
			header.node->right = z;
		++__size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %edi
callq 0x21f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl (%r15), %eax
movl 0x4(%r15), %ecx
movb $0x0, (%r14)
movups 0x1(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movups %xmm0, 0x1(%r14)
movq %rdx, 0x10(%r14)
movq %rsi, 0x18(%r14)
movl %eax, 0x20(%r14)
movl %ecx, 0x24(%r14)
movq 0x8(%rbx), %rdx
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xab6f
movq %rsi, %rdx
movl 0x20(%rsi), %edi
movl $0x10, %esi
cmpl %edi, %eax
jl 0xab57
movl $0x18, %esi
jle 0xab81
movq (%rdx,%rsi), %rsi
testq %rsi, %rsi
jne 0xab41
movq %rdx, 0x8(%r14)
cmpl 0x20(%rdx), %eax
jge 0xab92
movq %r14, 0x10(%rdx)
jmp 0xab96
movq %r14, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq %r14, 0x18(%rdx)
movq %rdx, 0x8(%r14)
jmp 0xab96
leaq 0x20(%rdx), %rsi
cmpq %r15, %rsi
je 0xabd2
movl %eax, 0x20(%rdx)
movl %ecx, 0x24(%rdx)
jmp 0xabd2
movq %r14, 0x18(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabdc
movl (%rbx), %eax
movq 0x8(%rbx), %rcx
testl %eax, %eax
je 0xabc6
movq 0x10(%rcx), %rsi
movl (%r15), %edx
cmpl 0x20(%rsi), %edx
jge 0xabbb
movq %r14, 0x10(%rcx)
movq 0x18(%rcx), %rsi
cmpl %edx, 0x20(%rsi)
jl 0xabca
jmp 0xabce
movq %r14, 0x10(%rcx)
movq %r14, 0x18(%rcx)
incl %eax
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::erase(ezSTL::__rbtree_iterator<int>)
void rbtree<T, Compare, Alloc>::erase(iterator pos) {
		// adjust leftmost and rightmost
		if (pos == begin())
			header.node->left = (pos + 1).node;
		if(pos == (end() - 1))
			header.node->right = (pos - 1).node;
		link_type todelete = nullptr;
		if (pos.node->left == nullptr || pos.node->right == nullptr)
			todelete = pos.node;
		else
			todelete = (pos + 1).node;
		
		// son: son of node todelete, father: parent of son
		link_type son = nullptr, father = nullptr;
		if (todelete->left != nullptr)
			son = todelete->left;
		else
			son = todelete->right;
		if (son)
			son->parent = todelete->parent;
		father = todelete->parent;
		if (todelete == father->left)
			father->left = son;
		else if(todelete == father->right)
			father->right = son;
		if (todelete == root())
			header.node->parent = son;
		// copy data from node to be deleted to pos
		if (todelete != pos.node)
			pos.node->data = todelete->data;
		// if the deleted node is black, then fix up
		if (todelete->color == __rbtree_black)
			delete_fixup(father, son);
		// deallocate node
		Alloc().destroy(todelete);
		Alloc().deallocate(todelete);
		--__size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rsi), %rcx
cmpq 0x10(%rax), %rcx
jne 0x8fee
movq %rsp, %r15
movq %rcx, (%r15)
movq %r15, %rdi
callq 0xa578
movq (%r15), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq %rsp, %r12
movq %rax, (%r12)
movq %r12, %rdi
callq 0xaa02
movq (%r14), %r15
cmpq (%r12), %r15
jne 0x9024
movq %rsp, %r12
movq %r15, (%r12)
movq %r12, %rdi
callq 0xaa02
movq (%r12), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%r14), %r15
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x9050
cmpq $0x0, 0x18(%r15)
je 0x9059
movq %rsp, %r12
movq %r15, (%r12)
movq %r12, %rdi
callq 0xa578
movq (%r12), %r15
movq 0x10(%r15), %rdx
testq %rdx, %rdx
jne 0x9059
movq 0x18(%r15), %rdx
testq %rdx, %rdx
je 0x90bb
movq 0x8(%r15), %rsi
movq %rsi, 0x8(%rdx)
cmpq 0x10(%rsi), %r15
je 0x9073
cmpq 0x18(%rsi), %r15
jne 0x907a
leaq 0x18(%rsi), %rax
jmp 0x9077
leaq 0x10(%rsi), %rax
movq %rdx, (%rax)
movq 0x8(%rbx), %rax
cmpq 0x8(%rax), %r15
jne 0x9088
movq %rdx, 0x8(%rax)
movq (%r14), %rax
cmpq %rax, %r15
je 0x9097
movl 0x20(%r15), %ecx
movl %ecx, 0x20(%rax)
cmpb $0x1, (%r15)
jne 0x90a5
movq %rbx, %rdi
callq 0xa878
movq %r15, %rdi
callq 0x21c0
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r15), %rsi
xorl %edx, %edx
jmp 0x9061
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::clear()
void rbtree<T, Compare, Alloc>::clear() {
		// dfs clear
		if (root())
			dfs_clear(root());
		header.node->left = header.node;
		header.node->right = header.node->right;
		header.node->parent = nullptr;
		header.node->color = __rbtree_red;
		__size = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x90e1
movq %rbx, %rdi
callq 0xaa54
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rax)
movq $0x0, 0x8(%rax)
movb $0x0, (%rax)
movl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_set<int, ezSTL::less<int>>(ezSTL::set<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>&)
void test::print_set(set<T, Compare>& s) {
		std::cout << "size: " << s.size();
		std::cout << " ; empty: " << s.empty();
		std::cout << std::endl << "set: ";
		for (auto ite = s.begin(); ite != s.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0xcec9(%rip), %rbx      # 0x15fd8
leaq 0x7811(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7772(%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 0x7795(%rip), %rsi      # 0x10917
movl $0x5, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
cmpq %rcx, %rax
je 0x91e2
movq 0xce30(%rip), %r15      # 0x15fd8
leaq 0x7311(%rip), %r12      # 0x104c0
leaq 0x8(%rsp), %r13
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq %r13, %rdi
callq 0xa578
movq 0x8(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x91b4
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 $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcdab(%rip), %rbx      # 0x15fd8
leaq 0x76f3(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7654(%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 0x7698(%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 0x9325
movq 0xcd13(%rip), %r15      # 0x15fd8
leaq 0x6ddd(%rip), %r12      # 0x100a9
leaq 0x71ed(%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 0xaa90
movq (%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x92d6
movq 0xccac(%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_O3/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 0xcc5e(%rip), %rbx      # 0x15fd8
leaq 0x75a6(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x757c(%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 0x74dd(%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 0x7516(%rip), %rsi      # 0x1092e
movl $0xf, %edx
movq %rax, %rdi
callq 0x2220
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb052
leaq 0x6c6d(%rip), %r12      # 0x100a9
leaq 0x707d(%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 0x9476
movq 0x30(%r14), %rsi
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
shrq $0x3, %rdi
cmpl %edi, %eax
jae 0x94d5
movq 0x8(%rsp), %rsi
cmpq %rcx, %rsi
setne %cl
cmpl %eax, %edx
setne %al
orb %cl, %al
je 0x94d5
movl 0x10(%rsi), %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 0xb0a8
jmp 0x9443
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_O3/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 0x97ca
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 0x9826
movq (%rax), %r8
movl (%rcx), %r9d
movq %r8, %rcx
movq 0x8(%rcx), %rcx
cmpq %r8, %rcx
je 0x9826
cmpl %r9d, 0x10(%rcx)
jne 0x9807
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movl %edx, 0x18(%rdi)
jmp 0x983b
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_O3/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 %rax, (%rcx)
callq 0x21c0
decl 0x8(%r15)
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x98aa
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
movq (%rax), %rax
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x988f
movq %r15, %rdi
callq 0xb1a2
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_O3/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 0x9add
movq %rsi, %r14
movq %rbx, %rdi
callq 0x9afe
movq 0x8(%r14), %rsi
subq (%r14), %rsi
shrq $0x3, %rsi
movq %rbx, %rdi
callq 0xb120
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x9abe
xorl %r12d, %r12d
movq (%r14), %r13
cmpq $0x0, (%r13,%r12,8)
je 0x9aaa
movl $0x10, %edi
callq 0x21f0
movq %rax, %r15
movq (%r13,%r12,8), %rsi
movq %rax, %rdi
callq 0xb202
movq (%rbx), %rax
movq %r15, (%rax,%r12,8)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
incq %r12
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %r12
jb 0x9a77
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x9b5d
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x9b49
movq %r14, %rdi
callq 0xb1a2
movq %r14, %rdi
callq 0x21c0
movq (%rbx), %rax
movq $0x0, (%rax,%r15,8)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %r15
jb 0x9b1e
movl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9c8c
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x9c8c
callq 0x21c0
movq 0x8(%rbx), %rdi
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9cd1
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9cc1
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x9cc1
callq 0x21c0
movq 0x8(%rbx), %rdi
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa2b7
movq %r14, %rdi
callq 0xa29c
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xa2c8
movq %r14, %rdi
callq 0xa29c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
movq 0x18(%rsi), %rdx
testq %rdx, %rdx
je 0xa595
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xa587
jmp 0xa5bc
movq 0x8(%rsi), %rcx
cmpq 0x18(%rcx), %rsi
je 0xa5a3
xorl %edx, %edx
jmp 0xa5b7
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rdx
je 0xa5a3
movq %rdx, (%rax)
movq 0x18(%rdx), %rdx
cmpq %rcx, %rdx
je 0xa5bf
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movq %rsi, %r12
movq %rdi, %r14
movl %r15d, %eax
movzbl (%r12), %r15d
addl %eax, %r15d
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rax
testq %rsi, %rsi
je 0xa6ae
testq %rax, %rax
je 0xa6c0
movq %r14, %rdi
movl %r15d, %edx
movl %ebx, %ecx
callq 0xa664
testb %al, %al
je 0xa6cb
movq 0x18(%r12), %r12
jmp 0xa677
leal 0x1(%r15), %ecx
testq %rax, %rax
je 0xa6cf
movq %rax, %r12
cmpl %ebx, %ecx
je 0xa677
jmp 0xa6cf
leal 0x1(%r15), %eax
movq %rsi, %r12
cmpl %ebx, %eax
je 0xa677
xorl %eax, %eax
jmp 0xa6dc
cmpl %ebx, %ecx
sete %cl
testq %rax, %rax
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7e9
movq %rsi, 0x8(%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rdx
cmpq %rsi, 0x8(%rdx)
je 0xa80d
cmpq %rsi, 0x10(%rcx)
je 0xa813
cmpq %rsi, 0x18(%rcx)
jne 0xa81d
addq $0x18, %rcx
jmp 0xa817
addq $0x8, %rdx
jmp 0xa81a
addq $0x10, %rcx
movq %rcx, %rdx
movq %rax, (%rdx)
movq %rsi, 0x10(%rax)
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa83b
movq %rsi, 0x8(%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rdx
cmpq %rsi, 0x8(%rdx)
je 0xa85f
cmpq %rsi, 0x10(%rcx)
je 0xa865
cmpq %rsi, 0x18(%rcx)
jne 0xa86f
addq $0x18, %rcx
jmp 0xa869
addq $0x8, %rdx
jmp 0xa86c
addq $0x10, %rcx
movq %rcx, %rdx
movq %rax, (%rdx)
movq %rsi, 0x18(%rax)
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa17
movq 0x8(%rcx), %rdx
cmpq %rcx, 0x8(%rdx)
je 0xaa4c
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0xaa2e
movq %rdx, %rcx
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0xaa20
jmp 0xaa50
movq 0x8(%rcx), %rdx
cmpq 0x10(%rdx), %rcx
je 0xaa3d
movq %rdx, %rcx
jmp 0xaa50
movq 0x8(%rdx), %rcx
cmpq 0x10(%rcx), %rdx
movq %rcx, %rdx
je 0xaa3d
jmp 0xaa50
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0xb07c
movl %edx, %edi
xorl %edx, %edx
movq (%rcx,%rdx,8), %r8
testq %r8, %r8
jne 0xb092
incq %rdx
cmpq %rdx, %rdi
jne 0xb06b
movups 0x20(%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x30(%rsi), %rcx
movq %rcx, 0x10(%rax)
movl 0x38(%rsi), %ecx
movl %ecx, 0x18(%rax)
retq
movq (%r8), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq %r8, 0x8(%rax)
movq %rsi, 0x10(%rax)
movl %edx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
cmpq (%rdx), %rcx
jne 0xb11b
movq 0x10(%rax), %rsi
movl 0x18(%rax), %ecx
incl %ecx
movl %ecx, 0x18(%rax)
movq (%rsi), %rdx
movq 0x8(%rsi), %rdi
subq %rdx, %rdi
shrq $0x3, %rdi
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
cmpl %edi, %ecx
jae 0xb110
testq %rsi, %rsi
jne 0xb110
movl %edi, %edi
leaq 0x1(%rcx), %r9
movq %r9, %r8
movq (%rdx,%r9,8), %rsi
movq %rsi, 0x8(%rax)
incl %ecx
cmpq %rdi, %r9
jae 0xb107
leaq 0x1(%r8), %r9
testq %rsi, %rsi
je 0xb0ec
movl %ecx, 0x18(%rax)
cmpq %rdi, %r8
jb 0xb114
retq
cmpl %edi, %ecx
jae 0xb10f
movq (%rsi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rax, %rcx
subq (%rdi), %rcx
shrq $0x3, %rcx
cmpl %esi, %ecx
jae 0xb185
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 0xb166
movq (%rcx,%rsi,8), %rdi
jmp 0xb168
xorl %edi, %edi
movq %rdi, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0xb15b
movq %rax, (%rbx)
leaq (%rax,%r14,8), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0xb19a
jbe 0xb19a
notl %esi
addl %ecx, %esi
shlq $0x3, %rsi
subq %rsi, %rax
addq $-0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbp
subq %rdi, %rbp
sarq $0x3, %rbp
cmpl $0x2, %ebp
jae 0xc26c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x14, %ebp
ja 0xc2d3
leaq 0x8(%r14), %rax
cmpq %rbx, %rax
je 0xc25d
movq (%rax), %rcx
cmpl (%r14), %ecx
jae 0xc2b8
movq %r14, %rdx
cmpq %r14, %rax
jbe 0xc2a9
movq %rax, %rdx
movq -0x8(%rdx), %rsi
movq %rsi, (%rdx)
leaq -0x8(%rdx), %rsi
movq %rsi, %rdx
cmpq %r14, %rsi
ja 0xc293
movq %r14, %rdx
movq %rcx, %xmm0
movq %xmm0, (%rdx)
addq $0x8, %rax
jmp 0xc27b
movl -0x8(%rax), %esi
movq %rax, %rdx
cmpl %esi, %ecx
jae 0xc2a9
movl %esi, (%rdx)
movl -0x10(%rdx), %esi
movl -0x4(%rdx), %edi
movl %edi, 0x4(%rdx)
addq $-0x8, %rdx
jmp 0xc2be
movq %rbp, %r15
shrq $0x3f, %r15
addq %rbp, %r15
sarq %r15
leaq (%r14,%r15,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xc243
movq %r12, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc243
leaq (,%r15,8), %r12
movl %r15d, %r13d
shlq $0x3, %r13
movq %r13, %rdi
callq 0x21f0
movq %rax, %r15
movq %r12, %rdx
movabsq $0x7fffffff8, %rax      # imm = 0x7FFFFFFF8
andq %rax, %rdx
je 0xc34c
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
leaq (%r12,%rcx), %rax
andq %rcx, %rax
addq %rax, %r15
addq $0x8, %r15
movq %r15, %rdi
subq %r13, %rdi
incq %rbp
movq %r14, %rax
cmpq $0x3, %rbp
jb 0xc381
movq %r14, %rax
movq %rdi, %rcx
cmpq %rax, %rcx
je 0xc36f
movq (%rax), %rdx
movq %rdx, (%rcx)
addq $0x8, %rax
addq $0x8, %rcx
addq $-0x8, %r12
jne 0xc364
movq (%rsp), %rax
cmpq %rbx, %r14
je 0xc3ca
movq %rdi, %rcx
cmpq %r15, %rcx
je 0xc399
cmpq %rbx, %rax
je 0xc3b9
movl (%rax), %edx
cmpl (%rcx), %edx
jae 0xc3b9
movq %rax, %rdx
leaq 0x8(%rax), %rsi
cmpq %rax, %r14
movq %rsi, %rax
je 0xc3ae
movq (%rdx), %rdx
movq %rdx, (%r14)
addq $0x8, %r14
cmpq %rbx, %r14
jne 0xc389
jmp 0xc3ca
movq %rcx, %rdx
leaq 0x8(%rcx), %rsi
cmpq %rcx, %r14
movq %rsi, %rcx
jne 0xc3a8
jmp 0xc3ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0