LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::vector(ezSTL::vector<int, ezSTL::allocator<int>> const&)
vector<T, Alloc>::vector(const vector<T, Alloc>& v) {
		// copy from v to *this
		start = allocate(v.size());
		for (size_type i = 0; i < v.size(); ++i)
			construct(start + i, v[i]);
		finish = start + v.size();
		end_of_storage = finish;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movabsq $0x3fffffffc, %rdi      # imm = 0x3FFFFFFFC
andq %rax, %rdi
callq 0x21e0
movq %rax, (%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movl %ecx, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x6ae2
movl (%rdx,%rdi,4), %r8d
movl %r8d, (%rax,%rdi,4)
incq %rdi
jmp 0x6ad0
movl %ecx, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::operator=(ezSTL::vector<int, ezSTL::allocator<int>> const&)
vector<T, Alloc>& vector<T, Alloc>::operator= (const vector<T, Alloc>& v) {
		if (this == &v) return *this;
		else {
			// destroy and deallocate old vector
			destroy(begin(), end());
			deallocate();
			// allocate and construct new vector
			start = allocate(v.size());
			for (size_type i = 0; i < v.size(); ++i)
				construct(start + i, v[i]);
			finish = start + v.size();
			end_of_storage = finish;
			return *this;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x6b5d
movq %rsi, %r14
movq %rbx, %rdi
callq 0x8934
movq 0x8(%r14), %rax
subq (%r14), %rax
movabsq $0x3fffffffc, %rdi      # imm = 0x3FFFFFFFC
andq %rax, %rdi
callq 0x21e0
movq %rax, (%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movl %ecx, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x6b4f
movl (%rdx,%rdi,4), %r8d
movl %r8d, (%rax,%rdi,4)
incq %rdi
jmp 0x6b3d
movl %ecx, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::list()
list() : __size(0) {
			link_type new_node = Alloc().allocate();
			Alloc().construct(new_node, __list_node<T>());
			list_iterator.node = new_node;
			list_iterator.node->prev = list_iterator.node;
			list_iterator.node->next = list_iterator.node;
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
pushq $0x18
popq %rdi
callq 0x21e0
andl $0x0, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xe42d(%rip), %r14      # 0x14fd8
leaq 0x7d4b(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x7cb1(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, 0x8(%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
cmpl $0x0, 0x8(%rbx)
je 0x6c42
movq 0xe3e5(%rip), %rdi      # 0x14fd8
leaq 0x7c8e(%rip), %rsi      # 0xe888
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8942
movl (%rax), %esi
movq %r14, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%rbx)
je 0x6c42
movq 0xe3b7(%rip), %rdi      # 0x14fd8
leaq 0x7c6b(%rip), %rsi      # 0xe893
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8964
movl (%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq 0xe38f(%rip), %r14      # 0x14fd8
movq %r14, %rdi
callq 0x20d0
leaq 0x7c4e(%rip), %rsi      # 0xe8a6
movq %rax, %rdi
callq 0x21d0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6df4
movq (%r15), %rax
leaq 0x7846(%rip), %r15      # 0xe4c0
cmpq (%rbx), %rax
je 0x6ca5
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6c7a
movq 0xe32c(%rip), %rdi      # 0x14fd8
callq 0x20d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::push_back(int const&)
void list<T, Alloc>::push_back(const_reference x){
		// alloacate space and construct
		link_type new_node = Alloc().allocate();
		Alloc().construct(new_node, __list_node<T>(x));
		// adjust pointers when list is empty or not
		new_node->next = list_iterator.node;
		new_node->prev = list_iterator.node->prev;
		list_iterator.node->prev->next = new_node;
		list_iterator.node->prev = new_node;
		++__size;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x21e0
movl (%rbx), %ecx
movl %ecx, 0x10(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::push_front(int const&)
void list<T, Alloc>::push_front(const_reference x){
		// alloacate space and construct
		link_type new_node = Alloc().allocate();
		Alloc().construct(new_node, __list_node<T>(x));
		// adjust pointers
		new_node->next = list_iterator.node->next;
		new_node->prev = list_iterator.node;
		list_iterator.node->next->prev = new_node;
		list_iterator.node->next = new_node;
		++__size;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x21e0
movl (%rbx), %ecx
movl %ecx, 0x10(%rax)
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rdx)
movq %rax, 0x8(%rcx)
incl 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::pop_back()
void list<T, Alloc>::pop_back(){
		iterator back_iterator = end() - 1;
		// adjust pointers
		list_iterator.node->prev = back_iterator.node->prev;
		back_iterator.node->prev->next = list_iterator.node;
		// destroy object and deallocate space
		Alloc().destroy(back_iterator.node);
		Alloc().deallocate(back_iterator.node);
		--__size;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rsp, %r14
movq %rax, (%r14)
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x89a4
movq (%r14), %rdi
movq (%rdi), %rax
movq (%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
callq 0x21b0
decl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::pop_front()
void list<T, Alloc>::pop_front(){
		iterator front_iterator = begin();
		// adjust pointers
		list_iterator.node->next = front_iterator.node->next;
		front_iterator.node->next->prev = list_iterator.node;
		// destroy object and deallocate space
		Alloc().destroy(front_iterator.node);
		Alloc().deallocate(front_iterator.node);
		--__size;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6df4
movq (%r14), %rdi
movq 0x8(%rdi), %rax
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, (%rax)
callq 0x21b0
decl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::insert(ezSTL::__list_iterator<int>, int const&)
typename list<T, Alloc>::iterator
		list<T, Alloc>::insert(iterator pos, const_reference x) {
		// alloacate space and construct
		link_type new_node = Alloc().allocate();
		Alloc().construct(new_node, __list_node<T>(x));
		// adjust pointers
		new_node->next = pos.node;
		new_node->prev = pos.node->prev;
		pos.node->prev->next = new_node;
		pos.node->prev = new_node;
		++__size;
		return pos - 1;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x18
popq %rdi
callq 0x21e0
movl (%rbx), %ecx
movl %ecx, 0x10(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%r15)
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x898c
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::erase(ezSTL::__list_iterator<int>)
typename list<T, Alloc>::iterator
		list<T, Alloc>::erase(iterator pos) {
		iterator before_iterator = pos - 1;
		// adjust pointers
		before_iterator.node->next = pos.node->next;
		pos.node->next->prev = before_iterator.node;
		// destroy object and deallocate space
		Alloc().destroy(pos.node);
		Alloc().deallocate(pos.node);
		--__size;
		return before_iterator;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x898c
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%r15), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, (%rax)
callq 0x21b0
decl 0x8(%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x9660
movq (%r13), %rax
leaq 0x10(%rsp), %r13
cmpq (%r14), %rax
je 0x99ac
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbp
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq %rax, 0x10(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x9660
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x9992
movq (%rbx), %rcx
movq %rbp, 0x8(%rcx)
movq %rbp, 0x8(%r12)
movq %r12, (%rbp)
incl 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbp, %r12
jmp 0x9950
movq (%rbx), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x6fd5
movq %rsi, %r14
pushq $0x18
popq %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x6df4
movq (%r13), %rax
leaq 0x10(%rsp), %r13
cmpq (%r14), %rax
je 0x6fca
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbp
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movl %eax, 0x10(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x6df4
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x6fb0
movq (%rbx), %rcx
movq %rbp, 0x8(%rcx)
movq %rbp, 0x8(%r12)
movq %r12, (%rbp)
incl 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbp, %r12
jmp 0x6f70
movq (%rbx), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6df4
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x6df4
movq (%r14), %rax
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rbp
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0x7052
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x89a4
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x21b0
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x701b
movq %rcx, (%rcx)
movq %rcx, 0x8(%rcx)
andl $0x0, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xdf42(%rip), %r14      # 0x14fd8
leaq 0x7860(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x77c6(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, 0x8(%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
cmpl $0x0, 0x8(%rbx)
je 0x70ff
movq 0xdefa(%rip), %rdi      # 0x14fd8
leaq 0x77c8(%rip), %rsi      # 0xe8ad
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8964
movl (%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq 0xded2(%rip), %rdi      # 0x14fd8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xdeb8(%rip), %r14      # 0x14fd8
leaq 0x77d6(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x773c(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, 0x8(%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
cmpl $0x0, 0x8(%rbx)
je 0x71b7
movq 0xde70(%rip), %rdi      # 0x14fd8
leaq 0x7719(%rip), %rsi      # 0xe888
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8942
movl (%rax), %esi
movq %r14, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%rbx)
je 0x71b7
movq 0xde42(%rip), %rdi      # 0x14fd8
leaq 0x76f6(%rip), %rsi      # 0xe893
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8964
movl (%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq 0xde1a(%rip), %rdi      # 0x14fd8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xde00(%rip), %r14      # 0x14fd8
leaq 0x771e(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
movl %ecx, %esi
movq %rax, %rdi
callq 0x2120
leaq 0x767a(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rcx
xorl %esi, %esi
cmpq 0x8(%rbx), %rcx
sete %sil
movq %rax, %rdi
callq 0x22b0
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x7249
movq 0xdda8(%rip), %rdi      # 0x14fd8
leaq 0x7676(%rip), %rsi      # 0xe8ad
callq 0x21d0
movq (%rbx), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq 0xdd88(%rip), %rdi      # 0x14fd8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68ea
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
testl %ecx, %ecx
je 0x7291
movl %ecx, %edx
decl %ecx
shrl %ecx
movl (%rax,%rdx,4), %esi
movl (%rax,%rcx,4), %edi
cmpl %edi, %esi
jge 0x7291
movl %edi, (%rax,%rdx,4)
movl %esi, (%rax,%rcx,4)
jmp 0x7275
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::rbtree()
rbtree() : __size(0) {
			header.node = Alloc().allocate();
			header.node->color = __rbtree_red;
			header.node->parent = nullptr;
			header.node->left = header.node;
			header.node->right = header.node;
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
pushq $0x28
popq %rdi
callq 0x21e0
movq %rax, 0x8(%rbx)
movb $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xdc62(%rip), %r14      # 0x14fd8
leaq 0x7580(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x74e7(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, (%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
movq %r14, %rdi
callq 0x20d0
leaq 0x74f8(%rip), %rsi      # 0xe8b6
movq %rax, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rax
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x70e5(%rip), %r12      # 0xe4c0
cmpq %rcx, %rax
je 0x7408
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x89ca
movq 0x8(%rbx), %rcx
movq (%rsp), %rax
jmp 0x73db
movq 0xdbc9(%rip), %r14      # 0x14fd8
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x8a02
leaq 0x7499(%rip), %rcx      # 0xe8bf
leaq 0x74ab(%rip), %rsi      # 0xe8d8
testb %al, %al
cmovneq %rcx, %rsi
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::find(int const&) const
typename rbtree<T, Compare, Alloc>::iterator rbtree<T, Compare, Alloc>::find(const value_type& v) const {
		link_type x = root();
		while (x != nullptr) {
			if (cmp(v, x->data))
				x = x->left;
			else if (cmp(x->data, v))
				x = x->right;
			else
				return iterator(x);
		}
		return end();
	}

// Assembly:
movq %rdi, %rax
movq 0x8(%rsi), %rcx
leaq 0x8(%rcx), %rsi
movl (%rdx), %edx
pushq $0x10
popq %rdi
pushq $0x18
popq %r8
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x7485
movl 0x20(%rsi), %r10d
movq %rdi, %r9
cmpl %r10d, %edx
jl 0x747d
movq %r8, %r9
jle 0x7482
addq %r9, %rsi
jmp 0x7464
movq %rsi, %rcx
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x21e0
movq %rax, %r14
andq $0x0, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movl (%r15), %eax
movl 0x4(%r15), %ecx
movb $0x0, (%r14)
movups 0x1(%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm0, 0x1(%r14)
movups %xmm1, 0x10(%r14)
movl %eax, 0x20(%r14)
movl %ecx, 0x24(%r14)
movq 0x8(%rbx), %rdx
leaq 0x8(%rdx), %r10
xorl %r8d, %r8d
pushq $0x10
popq %rsi
pushq $0x18
popq %rdi
movq (%r10), %r9
testq %r9, %r9
je 0x8fbd
movl 0x20(%r9), %r8d
movq %rsi, %r10
cmpl %r8d, %eax
jl 0x8fb5
movq %rdi, %r10
jle 0x8fd2
addq %r9, %r10
movq %r9, %r8
jmp 0x8f9c
movq %r8, 0x8(%r14)
testq %r8, %r8
je 0x8fe5
cmpl 0x20(%r8), %eax
jge 0x8ff7
movq %r14, 0x10(%r8)
jmp 0x8ffb
leaq 0x20(%r9), %rdx
cmpq %r15, %rdx
je 0x9037
movl %eax, 0x20(%r9)
movl %ecx, 0x24(%r9)
jmp 0x9037
movq %r14, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq %r14, 0x18(%rdx)
movq %rdx, 0x8(%r14)
jmp 0x8ffb
movq %r14, 0x18(%r8)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9042
movl (%rbx), %eax
movq 0x8(%rbx), %rcx
testl %eax, %eax
je 0x902b
movq 0x10(%rcx), %rsi
movl (%r15), %edx
cmpl 0x20(%rsi), %edx
jge 0x9020
movq %r14, 0x10(%rcx)
movq 0x18(%rcx), %rsi
cmpl %edx, 0x20(%rsi)
jl 0x902f
jmp 0x9033
movq %r14, 0x10(%rcx)
movq %r14, 0x18(%rcx)
incl %eax
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75ad
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x8c92
movq (%r15), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq %rsp, %r12
movq %rax, (%r12)
pushq $-0x1
popq %rsi
movq %r12, %rdi
callq 0x8e16
movq (%r14), %r15
cmpq (%r12), %r15
jne 0x75e7
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ca8
movq (%r15), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%r14), %r15
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x7614
cmpq $0x0, 0x18(%r15)
je 0x761d
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x8c92
movq (%r15), %r15
movq 0x10(%r15), %rdx
testq %rdx, %rdx
jne 0x761d
movq 0x18(%r15), %rdx
testq %rdx, %rdx
je 0x767f
movq 0x8(%r15), %rsi
movq %rsi, 0x8(%rdx)
cmpq 0x10(%rsi), %r15
je 0x7637
cmpq 0x18(%rsi), %r15
jne 0x763e
leaq 0x18(%rsi), %rax
jmp 0x763b
leaq 0x10(%rsi), %rax
movq %rdx, (%rax)
movq 0x8(%rbx), %rax
cmpq 0x8(%rax), %r15
jne 0x764c
movq %rdx, 0x8(%rax)
movq (%r14), %rax
cmpq %rax, %r15
je 0x765b
movl 0x20(%r15), %ecx
movl %ecx, 0x20(%rax)
cmpb $0x1, (%r15)
jne 0x7669
movq %rbx, %rdi
callq 0x8cc0
movq %r15, %rdi
callq 0x21b0
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r15), %rsi
xorl %edx, %edx
jmp 0x7625
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76a5
movq %rbx, %rdi
callq 0x8e8e
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rax)
andq $0x0, 0x8(%rax)
movb $0x0, (%rax)
andl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd900(%rip), %r14      # 0x14fd8
leaq 0x721e(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x7185(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, (%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
movq %r14, %rdi
callq 0x20d0
leaq 0x71cd(%rip), %rsi      # 0xe8ed
movq %rax, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rax
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x6d83(%rip), %r12      # 0xe4c0
cmpq %rcx, %rax
je 0x776a
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x89ca
movq 0x8(%rbx), %rcx
movq (%rsp), %rax
jmp 0x773d
movq 0xd867(%rip), %rdi      # 0x14fd8
callq 0x20d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xd82d(%rip), %r14      # 0x14fd8
leaq 0x714b(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x70b2(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, (%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
movq %r14, %rdi
callq 0x20d0
leaq 0x711b(%rip), %rsi      # 0xe90e
movq %rax, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x6897(%rip), %r12      # 0xe0a9
leaq 0x6ca7(%rip), %r13      # 0xe4c0
cmpq %rcx, %rax
je 0x7862
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq 0x8(%rsp), %rcx
movl 0x24(%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x8eca
movq 0x8(%rbx), %rcx
movq 0x8(%rsp), %rax
jmp 0x7819
movq 0xd76f(%rip), %rdi      # 0x14fd8
callq 0x20d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %rbx
movq 0xd6d2(%rip), %r14      # 0x14fd8
leaq 0x6ff0(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x6fcc(%rip), %rsi      # 0xe8f3
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
movl %ecx, %esi
movq %rax, %rdi
callq 0x2120
leaq 0x6f32(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
xorl %esi, %esi
cmpl $0x0, 0x18(%rbx)
sete %sil
movq %rax, %rdi
callq 0x22b0
movq %r14, %rdi
callq 0x20d0
leaq 0x6f90(%rip), %rsi      # 0xe904
movq %rax, %rdi
callq 0x21d0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x954e
movq %rsp, %r12
leaq 0x6713(%rip), %r13      # 0xe0a9
leaq 0x6b23(%rip), %rbp      # 0xe4c0
movups 0x20(%rbx), %xmm0
movaps %xmm0, (%rsp)
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movl 0x38(%rbx), %eax
movl %eax, 0x18(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7c9c
testb %al, %al
je 0x7a04
movq 0x28(%rsp), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
movq 0x28(%rsp), %rcx
movl 0x14(%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x95d4
jmp 0x799d
movq 0xd5cd(%rip), %rdi      # 0x14fd8
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x4
popq %rsi
movq %rdx, %rdi
callq 0x97ed
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
shrq $0x3, %rsi
xorl %edx, %edx
divl %esi
movl %edx, %r15d
movq (%rcx,%r15,8), %rsi
testq %rsi, %rsi
je 0x7c62
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x9660
movq (%r14), %rax
movl (%r12), %edx
movq (%r13), %rcx
movq (%rax,%r15,8), %rsi
cmpq (%rsi), %rcx
je 0x7c62
cmpl %edx, 0x10(%rcx)
je 0x7c7b
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rsp)
jmp 0x7c49
movups 0x20(%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x10(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x18(%rbx)
jmp 0x7c8a
movq %rcx, (%rbx)
movq %rsi, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movl %r15d, 0x18(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rsp, %rdi
callq 0x980e
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x7d0a
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
movq (%rax), %rax
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x7cf2
movq %r15, %rdi
callq 0x984a
movq %r15, %rdi
callq 0x21b0
movq 0x10(%r14), %rax
movl 0x18(%r14), %ecx
movq (%rax), %rax
andq $0x0, (%rax,%rcx,8)
decl 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x7ea4
movq %rsi, %r14
movq %rbx, %rdi
callq 0x7f04
movq 0x8(%r14), %rsi
subq (%r14), %rsi
shrq $0x3, %rsi
movq %rbx, %rdi
callq 0x9770
xorl %r13d, %r13d
pushq $0x10
popq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
movl %eax, %eax
cmpq %rax, %r13
jae 0x7e8d
movq (%r14), %rbp
cmpq $0x0, (%rbp,%r13,8)
je 0x7e88
movq %r15, %rdi
callq 0x21e0
movq %rax, %r12
movq (%rbp,%r13,8), %rsi
movq %rax, %rdi
callq 0x9902
movq (%rbx), %rax
movq %r12, (%rax,%r13,8)
incq %r13
jmp 0x7e4c
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
addq $0x20, %r14
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x99e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>&&)
unordered_map<Key, Value, Hash, KeyEqual>& operator= (unordered_map<Key, Value, Hash, KeyEqual>&& um) noexcept {
				if (this != &um) {
					buckets = move(um.buckets);
					__size = um.__size;
					end_iterator = um.end_iterator;
				}
				return *this;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x7ef8
movq %rsi, %r14
movq %rbx, %rdi
callq 0x99c6
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
addq $0x20, %r14
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x99e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %r15
jae 0x7f4a
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x7f45
movq %r14, %rdi
callq 0x984a
movq %r14, %rdi
callq 0x21b0
movq (%rbx), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x7f0f
andl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8020
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x8020
callq 0x21b0
movq 0x8(%rbx), %rdi
callq 0x21b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8065
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8055
movq 0x8(%rbx), %rax
decl (%rax)
jne 0x8055
callq 0x21b0
movq 0x8(%rbx), %rdi
callq 0x21b0
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_O2/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 0x8735
movq %r14, %rdi
callq 0x871a
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x8746
movq %r14, %rdi
callq 0x871a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %esi, %esi
js 0x89b9
movq (%rdi), %rax
subl $0x1, %esi
jb 0x89c8
movq 0x8(%rax), %rax
movq %rax, (%rdi)
jmp 0x89ab
decl %esi
movq %rdi, %rax
movq (%rax), %rax
incl %esi
jne 0x89be
movq %rax, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
movq 0x18(%rdx), %rsi
testq %rsi, %rsi
je 0x89ed
movq %rsi, %rcx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x89d9
jmp 0x89fd
movq %rcx, (%rax)
movq %rcx, %rdx
movq 0x8(%rdx), %rcx
cmpq 0x18(%rcx), %rdx
je 0x89e7
cmpq %rcx, 0x18(%rdx)
je 0x8a00
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8adc
testq %rax, %rax
je 0x8aee
movq %r14, %rdi
movl %r15d, %edx
movl %ebx, %ecx
callq 0x8a92
testb %al, %al
je 0x8af9
movq 0x18(%r12), %r12
jmp 0x8aa5
leal 0x1(%r15), %ecx
testq %rax, %rax
je 0x8afd
movq %rax, %r12
cmpl %ebx, %ecx
je 0x8aa5
jmp 0x8afd
leal 0x1(%r15), %eax
movq %rsi, %r12
cmpl %ebx, %eax
je 0x8aa5
xorl %eax, %eax
jmp 0x8b0a
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