LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11940
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x11a60
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11940
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0xb922
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11b30
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x11a30
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xb8c1
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x11940
movq (%rsp), %rcx
movl %eax, %edx
movq 0x18(%rsp), %rax
movl %edx, %edx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq 0x30(%rsp), %rax
jne 0xb9fe
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xbaf8
movq 0x20(%rsp), %rdi
callq 0xb7b0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x11a20
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq %rax, %rdx
callq 0x11850
movq 0x20(%rsp), %rdi
callq 0x118b0
movq 0x30(%rsp), %rdi
callq 0x11940
movq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x11a60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11940
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0xbabd
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x11b30
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x11a30
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xba5c
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x11940
movq (%rsp), %rcx
movl %eax, %edx
movq 0x20(%rsp), %rax
movl %edx, %edx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::operator=(ezSTL::vector<int, ezSTL::allocator<int>>&&)
vector<T, Alloc>& vector<T, Alloc>::operator= (vector<T, Alloc>&& v) noexcept {
		if (this == &v) return *this;
		else {
			start = v.start;
			finish = v.finish;
			end_of_storage = v.end_of_storage;
			v.start = nullptr;
			v.finish = nullptr;
			v.end_of_storage = nullptr;
			return *this;
		}
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq -0x18(%rsp), %rax
jne 0xbb37
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xbb8c
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq $0x0, (%rcx)
movq -0x18(%rsp), %rcx
movq $0x0, 0x8(%rcx)
movq -0x18(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rax)
leaq 0x37(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20f0
movq 0x8(%rsp), %rsi
leaq 0x36(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x11b80
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movq (%rax), %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x25308(%rip), %rdi     # 0x30fd8
leaq 0x1ac0e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11c60
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x252da(%rip), %rdi     # 0x30fd8
leaq 0x1ab60(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11bf0
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x30(%rsp), %rdi
callq 0x11bf0
testb $0x1, %al
jne 0xbd65
movq 0x2529a(%rip), %rdi     # 0x30fd8
leaq 0x1ab2b(%rip), %rsi     # 0x26870
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11c70
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x30(%rsp), %rdi
callq 0x11bf0
testb $0x1, %al
jne 0xbd9f
movq 0x2525e(%rip), %rdi     # 0x30fd8
leaq 0x1aafa(%rip), %rsi     # 0x2687b
callq 0x2220
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x11ca0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x25232(%rip), %rdi     # 0x30fd8
movq 0x2521b(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x1aad2(%rip), %rsi     # 0x2688e
callq 0x2220
movq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xc170
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x11d00
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x11ce0
testb $0x1, %al
jne 0xbdf4
jmp 0xbe27
leaq 0x28(%rsp), %rdi
callq 0xc1e0
movl (%rax), %esi
movq 0x251d1(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x1a692(%rip), %rsi     # 0x264a8
callq 0x2220
leaq 0x28(%rsp), %rdi
callq 0x11d30
jmp 0xbdd0
movq 0x251aa(%rip), %rdi     # 0x30fd8
movq 0x25193(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x11e90
movq (%rsp), %rsi
leaq 0x2e(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x11b80
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x30(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq (%rcx), %rdx
movq 0x30(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x30(%rsp), %rdx
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rdx, 0x8(%rcx)
movq 0x30(%rsp), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x11d00
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x11d50
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rsi
leaq 0xf(%rsp), %rdi
callq 0x11c10
movq 0x18(%rsp), %rsi
leaq 0xe(%rsp), %rdi
movl $0x1, %edx
callq 0x11c30
movq (%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xc170
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq (%rax), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rsi
leaq 0x17(%rsp), %rdi
callq 0x11c10
movq 0x18(%rsp), %rsi
leaq 0x16(%rsp), %rdi
movl $0x1, %edx
callq 0x11c30
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x11e90
movq 0x8(%rsp), %rsi
leaq 0x4e(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x11b80
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsi), %rdx
movq 0x50(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq (%rsi), %rcx
movq (%rcx), %rdx
movq 0x50(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x50(%rsp), %rdx
movq (%rsi), %rcx
movq (%rcx), %rcx
movq %rdx, 0x8(%rcx)
movq 0x50(%rsp), %rdx
movq (%rsi), %rcx
movq %rdx, (%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, %edx
callq 0x11d50
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rax
movq 0x10(%rsp), %rsi
movq %rdi, 0x8(%rsp)
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x1, %edx
callq 0x11d50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq (%rdx), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %rax
movq %rcx, 0x8(%rax)
movq (%rdi), %rcx
movq (%rdx), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq (%rdx), %rsi
leaq 0x2f(%rsp), %rdi
callq 0x11c10
movq 0x10(%rsp), %rdx
movq (%rdx), %rsi
leaq 0x2e(%rsp), %rdi
movl $0x1, %edx
callq 0x11c30
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movl 0x8(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x8(%rcx)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::list(ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x77(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x20f0
leaq 0x77(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20f0
movq 0x8(%rsp), %rsi
leaq 0x77(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x11b80
movq 0x10(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0xc170
movq 0x78(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x11d00
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11ce0
testb $0x1, %al
jne 0xc36f
jmp 0xc42d
leaq 0x77(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc1e0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x11e90
movq (%rsp), %rsi
leaq 0x77(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x11b80
movq 0x78(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc170
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11ec0
testb $0x1, %al
jne 0xc3da
jmp 0xc3eb
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x68(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x48(%rsp), %rdi
callq 0x11d30
jmp 0xc348
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x68(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x68(%rsp), %rcx
movq (%rax), %rax
movq %rcx, (%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x78(%rsp), %rax
je 0xc664
leaq 0x77(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x20f0
leaq 0x77(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20f0
movq 0x8(%rsp), %rsi
leaq 0x77(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x11b80
movq 0x10(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0xc170
movq 0x78(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x11d00
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11ce0
testb $0x1, %al
jne 0xc58a
jmp 0xc648
leaq 0x77(%rsp), %rdi
movl $0x1, %esi
callq 0x11b60
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc1e0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x11e90
movq (%rsp), %rsi
leaq 0x77(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x11b80
movq 0x78(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc170
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11ec0
testb $0x1, %al
jne 0xc5f5
jmp 0xc606
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x68(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x48(%rsp), %rdi
callq 0x11d30
jmp 0xc563
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x68(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x68(%rsp), %rcx
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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>>>&&)
list<T, Alloc>& operator=(list<T, Alloc>&& other) noexcept {
			list_iterator = other.list_iterator;
			__size = other.__size;
			other.__size = 0;
			return *this;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x11ee0
jmp 0xc6a3
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl $0x0, 0x8(%rcx)
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x108b0
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x20f0
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xc170
movq (%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc170
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x11d00
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11ce0
testb $0x1, %al
jne 0xc732
jmp 0xc789
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0xc1a0
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x11ee0
movq 0x20(%rsp), %rsi
leaq 0x2f(%rsp), %rdi
callq 0x11c10
movq 0x20(%rsp), %rsi
leaq 0x2f(%rsp), %rdi
movl $0x1, %edx
callq 0x11c30
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11ee0
jmp 0xc70f
movq (%rsp), %rax
movq (%rax), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movq (%rax), %rdx
movq (%rax), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, 0x8(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::~list()
~list() {
			if (!empty()) {
				clear();
				Alloc().destroy(list_iterator.node);
				Alloc().deallocate(list_iterator.node);
			}
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11bf0
movb %al, 0xd(%rsp)
jmp 0xc7cd
movb 0xd(%rsp), %al
testb $0x1, %al
jne 0xc80f
jmp 0xc7d7
movq (%rsp), %rdi
callq 0xc6d0
jmp 0xc7e2
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0xf(%rsp), %rdi
callq 0x11c10
jmp 0xc7f5
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0xe(%rsp), %rdi
movl $0x1, %edx
callq 0x11c30
jmp 0xc80d
jmp 0xc80f
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x108b0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x24798(%rip), %rdi     # 0x30fd8
leaq 0x1a09e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f20
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x2476a(%rip), %rdi     # 0x30fd8
leaq 0x19ff0(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f30
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x20(%rsp), %rdi
callq 0x11f30
testb $0x1, %al
jne 0xc8d5
movq 0x2472a(%rip), %rdi     # 0x30fd8
leaq 0x19fe0(%rip), %rsi     # 0x26895
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f50
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x246fc(%rip), %rdi     # 0x30fd8
movq 0x246e5(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x24678(%rip), %rdi     # 0x30fd8
leaq 0x19f7e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f60
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x2464a(%rip), %rdi     # 0x30fd8
leaq 0x19ed0(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f70
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x20(%rsp), %rdi
callq 0x11f70
testb $0x1, %al
jne 0xc9f5
movq 0x2460a(%rip), %rdi     # 0x30fd8
leaq 0x19e9b(%rip), %rsi     # 0x26870
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11f90
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x20(%rsp), %rdi
callq 0x11f70
testb $0x1, %al
jne 0xca2f
movq 0x245ce(%rip), %rdi     # 0x30fd8
leaq 0x19e6a(%rip), %rsi     # 0x2687b
callq 0x2220
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x11fa0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x245a2(%rip), %rdi     # 0x30fd8
movq 0x2458b(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x24518(%rip), %rdi     # 0x30fd8
leaq 0x19e1e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11fb0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x244ea(%rip), %rdi     # 0x30fd8
leaq 0x19d70(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11fc0
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x20(%rsp), %rdi
callq 0x11fc0
testb $0x1, %al
jne 0xcb55
movq 0x244aa(%rip), %rdi     # 0x30fd8
leaq 0x19d60(%rip), %rsi     # 0x26895
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11fe0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x2447c(%rip), %rdi     # 0x30fd8
movq 0x24465(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rsi
callq 0xb400
movq 0x18(%rsp), %rdi
callq 0x11fb0
subl $0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jbe 0xcc3f
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %esi
callq 0x11a80
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %esi
subl $0x1, %esi
shrl %esi
callq 0x11a80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x11ff0
testb $0x1, %al
jne 0xcbf8
jmp 0xcc38
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11a80
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
movl 0x24(%rsp), %esi
subl $0x1, %esi
shrl %esi
callq 0x11a80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x12020
movl 0x24(%rsp), %eax
subl $0x1, %eax
shrl %eax
movl %eax, 0x24(%rsp)
jmp 0xcc3a
jmp 0xcc3f
jmp 0xcba3
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, (%rax)
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
callq 0x12080
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movb $0x0, (%rcx)
movq 0x8(%rax), %rcx
movq $0x0, 0x8(%rcx)
movq 0x8(%rax), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x23f78(%rip), %rdi     # 0x30fd8
leaq 0x1987e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x120a0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x23f4c(%rip), %rdi     # 0x30fd8
leaq 0x197d2(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x120b0
movq 0x8(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x23f1a(%rip), %rdi     # 0x30fd8
movq 0x23f03(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x197ca(%rip), %rsi     # 0x2689e
callq 0x2220
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x120d0
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xd2a0
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd570
testb $0x1, %al
jne 0xd10c
jmp 0xd13f
leaq 0x18(%rsp), %rdi
callq 0xd2d0
movl (%rax), %esi
movq 0x23eb9(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x1937a(%rip), %rsi     # 0x264a8
callq 0x2220
leaq 0x18(%rsp), %rdi
callq 0x12110
jmp 0xd0e8
movq 0x23e92(%rip), %rdi     # 0x30fd8
movq 0x23e7b(%rip), %rsi     # 0x30fc8
callq 0x2250
movq 0x20(%rsp), %rdi
callq 0x121d0
testb $0x1, %al
jne 0xd162
jmp 0xd186
movq 0x23e6f(%rip), %rdi     # 0x30fd8
leaq 0x19737(%rip), %rsi     # 0x268a7
callq 0x2220
movq %rax, %rdi
movq 0x23e49(%rip), %rsi     # 0x30fc8
callq 0x2250
jmp 0xd1a8
movq 0x23e4b(%rip), %rdi     # 0x30fd8
leaq 0x1972c(%rip), %rsi     # 0x268c0
callq 0x2220
movq %rax, %rdi
movq 0x23e25(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x12390
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xd263
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x20, %rdx
callq 0x11ff0
testb $0x1, %al
jne 0xd20d
jmp 0xd21d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xd261
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
movq 0x20(%rsp), %rdx
callq 0x11ff0
testb $0x1, %al
jne 0xd23f
jmp 0xd24f
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xd25f
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x12370
jmp 0xd271
jmp 0xd261
jmp 0xd1e3
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
callq 0xd2a0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12390
cmpq $0x0, %rax
je 0xd855
movq 0x8(%rsp), %rdi
callq 0x12390
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x13000
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x18(%rcx)
movq 0x8(%rax), %rcx
movq $0x0, 0x8(%rcx)
movq 0x8(%rax), %rcx
movb $0x0, (%rcx)
movl $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x236f8(%rip), %rdi     # 0x30fd8
leaq 0x18ffe(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x13080
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x236cc(%rip), %rdi     # 0x30fd8
leaq 0x18f52(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x13090
movq 0x8(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x2369a(%rip), %rdi     # 0x30fd8
movq 0x23683(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x18f81(%rip), %rsi     # 0x268d5
callq 0x2220
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x130b0
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xda20
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd570
testb $0x1, %al
jne 0xd98c
jmp 0xd9bf
leaq 0x18(%rsp), %rdi
callq 0xd2d0
movl (%rax), %esi
movq 0x23639(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x18afa(%rip), %rsi     # 0x264a8
callq 0x2220
leaq 0x18(%rsp), %rdi
callq 0x12110
jmp 0xd968
movq 0x23612(%rip), %rdi     # 0x30fd8
movq 0x235fb(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x234d8(%rip), %rdi     # 0x30fd8
leaq 0x18dde(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x130e0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x234aa(%rip), %rdi     # 0x30fd8
leaq 0x18d30(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x130f0
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x23478(%rip), %rdi     # 0x30fd8
movq 0x23461(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x18d80(%rip), %rsi     # 0x268f6
callq 0x2220
movq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x13110
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdd00
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdd60
testb $0x1, %al
jne 0xdbae
jmp 0xdc0f
leaq 0x28(%rsp), %rdi
callq 0x13140
movl (%rax), %esi
movq 0x23417(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x184c1(%rip), %rsi     # 0x26091
callq 0x2220
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13140
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x188ad(%rip), %rsi     # 0x264a8
callq 0x2220
leaq 0x28(%rsp), %rdi
callq 0x13160
jmp 0xdb8a
movq 0x233c2(%rip), %rdi     # 0x30fd8
movq 0x233ab(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x23118(%rip), %rdi     # 0x30fd8
leaq 0x18a1e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x14840
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x230ea(%rip), %rdi     # 0x30fd8
leaq 0x189e6(%rip), %rsi     # 0x268db
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x14850
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x230bc(%rip), %rdi     # 0x30fd8
leaq 0x18942(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x14860
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x2308a(%rip), %rdi     # 0x30fd8
movq 0x23073(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x18988(%rip), %rsi     # 0x268ec
callq 0x2220
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x14880
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xe4d0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xe4a0
testb $0x1, %al
jne 0xdf9c
jmp 0xdff7
leaq 0x40(%rsp), %rdi
callq 0x14970
movl %eax, %esi
movq 0x23029(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x180d3(%rip), %rsi     # 0x26091
callq 0x2220
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x14990
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x184c2(%rip), %rsi     # 0x264a8
callq 0x2220
leaq 0x40(%rsp), %rdi
callq 0x149b0
jmp 0xdf78
movq 0x22fda(%rip), %rdi     # 0x30fd8
movq 0x22fc3(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x4b(%rsp), %rdi
callq 0x14e10
movq 0x18(%rsp), %rdi
movl %eax, 0x24(%rsp)
callq 0x144b0
movq 0x18(%rsp), %rdi
movl %eax, %ecx
movl 0x24(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
callq 0x14d30
cmpq $0x0, (%rax)
jne 0xe3cd
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xe4d0
jmp 0xe495
movq 0x18(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x14d30
movq (%rax), %rsi
leaq 0x40(%rsp), %rdi
callq 0x14b20
movq 0x18(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x14d30
movq (%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x14d00
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x14ce0
testb $0x1, %al
jne 0xe418
jmp 0xe486
leaq 0x40(%rsp), %rdi
callq 0x15350
movq %rax, %rsi
movq 0x50(%rsp), %rdx
leaq 0x37(%rsp), %rdi
callq 0x15320
testb $0x1, %al
jne 0xe43a
jmp 0xe475
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x14730
movq 0x18(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x14d30
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq (%rax), %rdx
movl 0x4c(%rsp), %r8d
leaq 0x28(%rsp), %rsi
callq 0x144f0
jmp 0xe495
jmp 0xe477
leaq 0x40(%rsp), %rdi
callq 0x14c80
jmp 0xe3e8
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xe4d0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x14730
movq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x15360
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x15410
testb $0x1, %al
jne 0xe558
jmp 0xe5a3
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x14d30
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xe58b
movq 0x8(%rsp), %rdi
callq 0x15430
movq 0x8(%rsp), %rdi
callq 0x2200
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x14d30
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq 0x38(%rsp), %rax
je 0xe935
movq 0x18(%rsp), %rdi
callq 0xe9b0
movq 0x38(%rsp), %rdi
callq 0x14850
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x14fd0
movl $0x0, 0x34(%rsp)
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x14850
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0xe911
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14af0
cmpq $0x0, (%rax)
je 0xe8ff
movl $0x10, %edi
callq 0x2230
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14af0
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x15630
jmp 0xe8cf
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x14d30
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0xe8ff
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x2200
jmp 0xe93f
jmp 0xe901
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xe86b
movq 0x38(%rsp), %rdi
callq 0x14840
movq 0x18(%rsp), %rdi
movl %eax, 0x18(%rdi)
movq 0x38(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x158b0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2320
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0xe9a5
movq 0x8(%rsp), %rdi
callq 0x15810
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x15820
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x18(%rdi)
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x158b0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x14850
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0xea4f
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x14d30
cmpq $0x0, (%rax)
je 0xea3d
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x14d30
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xea28
movq (%rsp), %rdi
callq 0x15430
movq (%rsp), %rdi
callq 0x2200
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x14d30
movq $0x0, (%rax)
jmp 0xea3f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xe9cb
movq 0x10(%rsp), %rax
movl $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
// File: cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_shared_ptr<int>(ezSTL::shared_ptr<int>&)
void test::print_shared_ptr(shared_ptr<T>& ptr) {
		if (ptr)
			std::cout << "shared_ptr: value:" << *ptr << " ; use_count: " << ptr.use_count() << " ; unique: " << ptr.unique() << std::endl;
		else
			std::cout << "null object" << std::endl;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15910
testb $0x1, %al
jne 0xeb0c
jmp 0xeba3
movq 0x224c5(%rip), %rdi     # 0x30fd8
leaq 0x17de2(%rip), %rsi     # 0x268fc
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15930
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x17dcb(%rip), %rsi     # 0x2690f
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15940
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x17db0(%rip), %rsi     # 0x2691e
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15960
movq 0x18(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq %rax, %rdi
movq 0x2242c(%rip), %rsi     # 0x30fc8
callq 0x2250
jmp 0xebc5
movq 0x2242e(%rip), %rdi     # 0x30fd8
leaq 0x17d79(%rip), %rsi     # 0x2692a
callq 0x2220
movq %rax, %rdi
movq 0x22408(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0xec93
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0xec91
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xec5f
movq 0x10(%rsp), %rdi
callq 0x2200
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xec7d
movq 0x8(%rsp), %rdi
callq 0x2200
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
jmp 0xec93
addq $0x28, %rsp
retq
nopl (%rax,%rax)