LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<ft::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::red_black_tree(ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, custom_allocator<ft::red_black_tree_node<ft::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
explicit
		red_black_tree(key_compare const& comp = key_compare(),
						allocator_type const& alloc = allocator_type()) :
			_root(NULL),
			_nil(NULL),
			_size(0),
			_comp(comp),
			_alloc(alloc)
		{
			_nil = _alloc.allocate(1);
			_alloc.construct(_nil, node_type(value_type(), NULL, NULL, NULL, black));

			// All leaf nodes will point to _nil and _nil is a black node
			// Set root pointing to _nil for an empty tree
			_root = _nil;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x2fbe2(%rip), %rax     # 0x46648
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
pushq $0x60
popq %rdi
callq 0x51b0
movq %rax, %r14
movq %rax, 0x10(%rbx)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x16bde
leaq -0xb0(%rbp), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rsi)
andq $0x0, 0x50(%rsi)
movl $0x1, 0x58(%rsi)
movq %r14, %rdi
callq 0x16bb4
leaq -0xb0(%rbp), %rdi
callq 0x16260
leaq -0x50(%rbp), %rdi
callq 0x16260
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x16260
jmp 0x16b13
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x16260
movq %rbx, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::clear_helper(ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>* const&)
void
		clear_helper(node_pointer const& node)
		{
			// Base case of recursion
			if (node == _nil)
				return;

			// Clear all nodes to the left and right of it
			clear_helper(node->left);
			clear_helper(node->right);

			// Clear the node itself
			_alloc.destroy(node);
			_alloc.deallocate(node, 1);

			_size--;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rsi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x17e5e
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x17e18
movq (%r14), %rsi
addq $0x38, %rsi
movq %rbx, %rdi
callq 0x17e18
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x51d0
movq (%r14), %rdi
callq 0x5170
decq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::find(int const&)
iterator
		find(key_type const& key)
		{
			node_pointer position = find_helper(key, _root);

			if (!position)
				return end();
			else
				return iterator(position, _root, _nil);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x68f2
testq %rax, %rax
je 0x681b
movups 0x8(%r14), %xmm0
leaq 0x3f522(%rip), %rcx     # 0x45d30
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0x6826
movq %rbx, %rdi
movq %r14, %rsi
callq 0x682e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::insert_helper(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
node_pointer
		insert_helper(node_pointer node, node_pointer hint)
		{
			node->parent = find_right_position(node, hint);

			// Set node in the position found. Either left or right
			// If parent NULL then it means we are at the root of the tree
			// so we can retrun
			if (node->parent == NULL)
			{
				_root = node;
				_root->color = black;

				return _root;
			}
			else if (_comp(get_key_from_val(node->data), get_key_from_val(node->parent->data)))
				node->parent->left = node;
			else
				node->parent->right = node;

			// If parent is _root then we are at level 1 of the tree
			// so we can't be unbalancing the tree
			// Else the new node could have unbalanced the red-black tree
			// so we need to check after each insert
			if (node->parent != _root)
				check_insert(node);

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, -0x20(%rbp)
callq 0x7206
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x7047
movq (%r14), %rax
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq 0x20(%rbx), %rdx
movq (%r14), %rax
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq *0x10(%rax)
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7195
movl %eax, %r15d
leaq -0x40(%rbp), %rdi
callq 0x51d0
leaq -0x60(%rbp), %rdi
callq 0x51d0
movq 0x20(%rbx), %rax
xorb $0x1, %r15b
movzbl %r15b, %ecx
movq %rbx, 0x28(%rax,%rcx,8)
cmpq 0x8(%r14), %rax
je 0x7052
leaq -0x20(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72b6
movq (%rbx), %rbx
jmp 0x7052
movq %rbx, 0x8(%r14)
movl $0x1, 0x38(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x51d0
jmp 0x7071
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::find_helper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* const&) const
node_pointer
		find_helper(key_type const& key, node_pointer const& node) const
		{
			// Base case of recursion
			if (node == _nil)
				return NULL;
			else if (get_key_from_val(node->data) == key)
				return node;

			if (_comp(key, get_key_from_val(node->data)))
				return find_helper(key, node->left);
			else
				return find_helper(key, node->right);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq (%rdx), %rdx
cmpq 0x10(%rdi), %rdx
je 0x70dc
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x715e
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x51d0
testb %r12b, %r12b
je 0x70e0
movq (%r15), %rax
jmp 0x7127
xorl %eax, %eax
jmp 0x7127
movq (%r15), %rdx
movq (%r14), %rax
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7195
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x51d0
movq (%r15), %rdx
testb %r12b, %r12b
je 0x7118
addq $0x28, %rdx
jmp 0x711c
addq $0x30, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x708a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x51d0
jmp 0x714e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::find_right_position(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
node_pointer
		find_right_position(node_pointer node, node_pointer hint)
		{
			node_pointer	parent = NULL;
			node_pointer	child = hint;

			while (child != _nil)
			{
				parent = child;
				if (_comp(get_key_from_val(node->data), get_key_from_val(child->data)))
					child = child->left;
				else
					child = child->right;
			}

			return parent;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
xorl %eax, %eax
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
cmpq 0x10(%r15), %r14
je 0x727d
movq (%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq *0x10(%rax)
movq (%r15), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7195
movl %eax, %ebx
movq %r13, %rdi
callq 0x51d0
movq %r12, %rdi
callq 0x51d0
xorb $0x1, %bl
movzbl %bl, %ecx
movq %r14, %rax
movq 0x28(%r14,%rcx,8), %r14
jmp 0x722b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x51d0
jmp 0x729d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::rotate_left(ft::red_black_tree_node<int>*&)
void
		rotate_left(node_pointer& node)
		{
			node_pointer grandparent = node->parent->parent;
			node_pointer parent = node->parent;
			node_pointer tmp = _nil;

			// Update grandparent
			if (grandparent == NULL)
				_root = node;
			else if (grandparent->left == parent)
				grandparent->left = node;
			else
				grandparent->right = node;

			// Save node to the left of node before overwritting it
			if (node->left != _nil)
			{
				tmp = node->left;
				tmp->parent = parent;
			}

			// Update node itself
			node->left = parent;
			if (node == _root)
				node->parent = NULL;
			else
				node->parent = grandparent;

			// Update parent
			parent->parent = node;
			parent->right = tmp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %r8
movq 0x8(%r8), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rdx
testq %rcx, %rcx
je 0x6b6a
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x6b6e
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x10(%r8), %r9
cmpq %rdx, %r9
je 0x6b87
movq %rax, 0x8(%r9)
movq (%rsi), %r8
movq %r9, %rdx
movq %rax, 0x10(%r8)
movq (%rsi), %r8
xorl %r9d, %r9d
cmpq 0x8(%rdi), %r8
cmoveq %r9, %rcx
movq %rcx, 0x8(%r8)
movq (%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x18(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::rotate_right(ft::red_black_tree_node<int>*&)
void
		rotate_right(node_pointer& node)
		{
			node_pointer grandparent = node->parent->parent;
			node_pointer parent = node->parent;
			node_pointer tmp = _nil;

			// Update grandparent
			if (grandparent == NULL)
				_root = node;
			else if (grandparent->left == parent)
				grandparent->left = node;
			else
				grandparent->right = node;

			// Save node to the right of node before overwritting it
			// and set its new parent
			if (node->right != _nil)
			{
				tmp = node->right;
				tmp->parent = parent;
			}

			// Update node itself
			node->right = parent;
			if (node == _root)
				node->parent = NULL;
			else
				node->parent = grandparent;

			// Update parent
			parent->parent = node;
			parent->left = tmp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %r8
movq 0x8(%r8), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rdx
testq %rcx, %rcx
je 0x6bd4
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x6bd8
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x18(%r8), %r9
cmpq %rdx, %r9
je 0x6bf1
movq %rax, 0x8(%r9)
movq (%rsi), %r8
movq %r9, %rdx
movq %rax, 0x18(%r8)
movq (%rsi), %r8
xorl %r9d, %r9d
cmpq 0x8(%rdi), %r8
cmoveq %r9, %rcx
movq %rcx, 0x8(%r8)
movq (%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::red_black_tree(ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&)
red_black_tree(red_black_tree const& rhs) :
			_root(NULL),
			_nil(NULL),
			_size(0),
			_comp(rhs._comp),
			_alloc(rhs._alloc)
		{
			_nil = _alloc.allocate(1);
			_alloc.construct(_nil, node_type(value_type(), NULL, NULL, NULL, black));

			// All leaf nodes will point to _nil and _nil is a black node
			// Set root pointing to _nil for an empty tree
			_root = _nil;

			*this = rhs;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28b72(%rip), %rax     # 0x46740
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
pushq $0x48
popq %rdi
callq 0x51b0
movq %rax, %r12
movq %rax, 0x10(%r15)
xorl %eax, %eax
leaq -0x40(%rbp), %rbx
movb %al, -0x8(%rbx)
leaq -0x30(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x17de0
leaq -0x90(%rbp), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
andq $0x0, 0x38(%rsi)
movl $0x1, 0x40(%rsi)
movq %r12, %rdi
callq 0x17db6
leaq -0x88(%rbp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x51d0
movq 0x10(%r15), %rax
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1dc96
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x51d0
jmp 0x1dc7e
movq %rax, %r14
movq %rbx, %rdi
callq 0x51d0
movq %r14, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::operator=(ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>> const&)
red_black_tree&
		operator=(red_black_tree const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			// Clear current
			if (_root != NULL)
				clear();
			copy_helper(_root, rhs._root, NULL, rhs._nil);

			_size = rhs._size;

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x8d8f
movq %rsi, %r14
leaq 0x8(%rbx), %r15
cmpq $0x0, 0x8(%rbx)
je 0x8d72
movq %rbx, %rdi
callq 0x667a
movq 0x8(%r14), %rdx
movq 0x10(%r14), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x8d9e
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::copy_helper(ft::red_black_tree_node<int>*&, ft::red_black_tree_node<int>*, ft::red_black_tree_node<int>*, ft::red_black_tree_node<int>*)
void
		copy_helper(node_pointer& lhs,
				node_pointer rhs,
				node_pointer parent,
				node_pointer nil_rhs)
		{
			// Base case of the recursion
			if (rhs == nil_rhs)
			{
				lhs = _nil;
				return;
			}

			lhs = _alloc.allocate(1);
			_alloc.construct(lhs, *rhs);
			// Parent is the previously created node pased as argument
			lhs->parent = parent;

			copy_helper(lhs->left, rhs->left, lhs, nil_rhs);
			copy_helper(lhs->right, rhs->right, lhs, nil_rhs);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
cmpq %rbx, %r15
je 0x8e0a
pushq $0x28
popq %rdi
callq 0x51b0
movq %rax, (%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x20(%rax)
leaq 0x10(%rax), %rsi
movq %r13, 0x8(%rax)
movq 0x10(%r15), %rdx
movq %r12, %rdi
movq %rax, %rcx
movq %rbx, %r8
callq 0x8d9e
movq (%r14), %r13
leaq 0x18(%r13), %r14
movq 0x18(%r15), %r15
jmp 0x8dbb
movq 0x10(%r12), %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::insert(ft::bidirectional_iterator<ft::red_black_tree_node<int>>, int const&)
iterator
		insert(iterator hint, value_type const& val)
		{
			node_pointer successor = get_successor(hint._ptr);
			node_pointer node;

			// Check if position is correct
			if (_comp(get_key_from_iterator(hint), get_key_from_val(val))
					&& _comp(get_key_from_val(val), get_key_from_val(successor->data)))
			{
				// New nodes are necessarily red and leaf nodes so they point
				// to _nil
				node = _alloc.allocate(1);
				_alloc.construct(node, node_type(val, NULL, _nil, _nil, red));

				_size++;

				return iterator(insert_helper(node, hint._ptr), _root, _nil);
			}
			else
				return insert(val).first;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movq %r14, %rdi
callq 0xc1d0
movq %rax, -0x30(%rbp)
leaq 0x39df4(%rip), %rax     # 0x45d30
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r13d
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x10(%rax)
cmpl %eax, %r13d
jge 0xbfe8
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movl %eax, %r13d
movq (%r14), %rax
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq *0x10(%rax)
cmpl %eax, %r13d
jge 0xbfe8
pushq $0x28
popq %rdi
callq 0x51b0
movl (%r12), %ecx
movq 0x10(%r14), %rdx
movl %ecx, (%rax)
andq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
andl $0x0, 0x20(%rax)
incq 0x18(%r14)
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x89b0
movups 0x8(%r14), %xmm0
leaq 0x39d55(%rip), %rcx     # 0x45d30
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0xc01c
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x7f56
leaq 0x39d2f(%rip), %rax     # 0x45d30
movq %rax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::erase(ft::bidirectional_iterator<ft::red_black_tree_node<int>>)
void
		erase(iterator position)
		{
			if (position == end())
				return;

			erase_helper(position._ptr);
			_size--;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d7a
movq 0x8(%r14), %rsi
cmpq 0x8(%r15), %rsi
je 0xc0a8
movq %rbx, %rdi
callq 0xc220
decq 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::erase(int const&)
size_type
		erase(key_type const& key)
		{
			iterator it = find(key);

			// Val not found in tree so nothing erased
			if (it == end())
				return 0;

			erase(it);
			return 1;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8960
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d7a
movq 0x8(%r14), %rax
cmpq 0x8(%r15), %rax
je 0xc116
leaq 0x39c3a(%rip), %rcx     # 0x45d30
leaq -0x58(%rbp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movups -0x28(%rbp), %xmm0
movups %xmm0, 0x10(%rsi)
movq %rbx, %rdi
callq 0xc070
pushq $0x1
popq %rax
jmp 0xc118
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::erase_helper(ft::red_black_tree_node<int>*)
void
		erase_helper(node_pointer node)
		{
			node_pointer	tmp;

			// Case: leaf node (base case of the recursion)
			// We only delete leaf nodes. Internal nodes are replaced
			if (node->left == _nil && node->right == _nil)
			{
				// Fix double black case. If we delete a black leaf node
				// we are violating the rule that states that all paths
				// in a red-black tree have the same number of black nodes
				if (node->color == black)
					fix_double_black(node);

				// Update parent
				if (node == _root)
					_root = _nil;
				else if (node->parent->left == node)
					node->parent->left = _nil;
				else
					node->parent->right = _nil;

				_alloc.destroy(node);
				_alloc.deallocate(node, 1);

			}
			// Case: node one or two childs
			// If two childs, we get successor
			else
			{
				// Find predecessor or successor
				if (node->right != _nil)
					tmp = get_successor(node);
				else
					tmp = get_predecessor(node);

				// Swap nodes but they switch colors and node gets tmp's data
				// but tmp keeps it's data
				swap_nodes(node, tmp);

				// Recursively replace and delete node
				erase_helper(node);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
movq 0x10(%r14), %rcx
movq %rax, %rsi
xorq %rdx, %rsi
xorq %rcx, %rdx
orq %rsi, %rdx
je 0xc26e
movq %r14, %rdi
movq %rbx, %rsi
cmpq %rcx, %rax
je 0xc259
callq 0xc1d0
jmp 0xc25e
callq 0xc47a
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xc4aa
jmp 0xc22d
cmpl $0x1, 0x20(%rbx)
jne 0xc27f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2b4
cmpq %rbx, 0x8(%r14)
je 0xc299
movq 0x8(%rbx), %rax
movq 0x10(%r14), %rcx
cmpq %rbx, 0x10(%rax)
je 0xc2a3
movq %rcx, 0x18(%rax)
jmp 0xc2a7
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
jmp 0xc2a7
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5170
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::swap_nodes(ft::red_black_tree_node<int>*, ft::red_black_tree_node<int>*)
void
		swap_nodes(node_pointer a, node_pointer b)
		{
			node_type		tmp = *b;
			node_pointer	old_root = _root;

			// Update parentage
			// a's parent points to b
			if (_root == a)
				_root = b;
			else if (a->parent->left == a)
				a->parent->left = b;
			else if (a->parent->right == a)
				a->parent->right = b;
			// and b points at a's parent
			b->parent = a->parent;

			// b's parent (via tmp) points to a
			// If root changed it means that _root was originally a and
			// was changed to b
			if (old_root == _root && _root == b)
				_root = a;
			else if (tmp.parent->left == b)
				tmp.parent->left = a;
			else if (tmp.parent->right == b)
				tmp.parent->right = a;
			// and a points back at b's parent
			a->parent = tmp.parent;

			// Update children
			b->left = a->left;
			if (b->left != _nil)
				b->left->parent = b;
			b->right = a->right;
			if (b->right != _nil)
				b->right->parent = b;

			a->left = tmp.left;
			if (a->left != _nil)
				a->left->parent = a;
			a->right = tmp.right;
			if (a->right != _nil)
				a->right->parent = a;

			// Update colors
			swap_color(a, b);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rdx), %r8
movq 0x10(%rdx), %rcx
movq 0x18(%rdx), %rax
leaq 0x8(%rdi), %r9
movq 0x8(%rdi), %r10
cmpq %rsi, %r10
je 0xc4de
movq 0x8(%rsi), %r11
cmpq %rsi, 0x10(%r11)
je 0xc4ea
cmpq %rsi, 0x18(%r11)
jne 0xc4ee
movq %rdx, 0x18(%r11)
jmp 0xc4ee
movq %rdx, (%r9)
movq 0x8(%rsi), %r11
movq %rdx, %rbx
jmp 0xc4f1
movq %rdx, 0x10(%r11)
movq %r10, %rbx
movq %r11, 0x8(%rdx)
xorq %rbx, %r10
xorq %rdx, %rbx
orq %r10, %rbx
je 0xc516
cmpq %rdx, 0x10(%r8)
je 0xc512
cmpq %rdx, 0x18(%r8)
jne 0xc519
leaq 0x18(%r8), %r9
jmp 0xc516
leaq 0x10(%r8), %r9
movq %rsi, (%r9)
movq %r8, 0x8(%rsi)
movq 0x10(%rsi), %r8
movq %r8, 0x10(%rdx)
movq 0x10(%rdi), %rdi
cmpq %rdi, %r8
je 0xc532
movq %rdx, 0x8(%r8)
movq 0x18(%rsi), %r8
movq %r8, 0x18(%rdx)
cmpq %rdi, %r8
je 0xc543
movq %rdx, 0x8(%r8)
movq %rcx, 0x10(%rsi)
cmpq %rdi, %rcx
je 0xc550
movq %rsi, 0x8(%rcx)
movq %rax, 0x18(%rsi)
cmpq %rdi, %rax
je 0xc55d
movq %rsi, 0x8(%rax)
movl 0x20(%rdx), %eax
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdx)
movl %eax, 0x20(%rsi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/bidirectional_iterator.hpp
// Function: ft::bidirectional_iterator<ft::red_black_tree_node<int>>::operator--()
bidirectional_iterator&
		operator--()
		{
			if (_ptr == _nil)
				_ptr = maximum(_root);
			else
				_ptr = predecessor(_ptr);

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0xd32f
movq %rbx, %rdi
callq 0xd360
jmp 0xd33b
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0xd34a
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::rend()
reverse_iterator
		rend()
		{
			if (empty())
				return rbegin();

			iterator it = iterator(minimum(), _root, _nil);
			return reverse_iterator(it);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0xe1d0
movq %r14, %rdi
callq 0x87bc
movq 0x10(%r14), %rcx
jmp 0xe1d7
movq 0x10(%r14), %rax
movq %rax, %rcx
movq 0x8(%r14), %rdx
leaq 0x37e6e(%rip), %rsi     # 0x46050
movq %rsi, (%rbx)
leaq 0x37b44(%rip), %rsi     # 0x45d30
movq %rsi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::rend() const
const_reverse_iterator
		rend() const
		{
			if (empty())
				return rbegin();

			const_iterator it = const_iterator(minimum(), _root, _nil);
			return const_reverse_iterator(it);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0xe226
movq %r14, %rdi
callq 0x87bc
movq 0x10(%r14), %rcx
jmp 0xe22d
movq 0x10(%r14), %rax
movq %rax, %rcx
movq 0x8(%r14), %rdx
leaq 0x37e48(%rip), %rsi     # 0x46080
movq %rsi, (%rbx)
leaq 0x37b1e(%rip), %rsi     # 0x45d60
movq %rsi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::lower_bound(int const&)
iterator
		lower_bound(key_type const& k)
		{
			iterator begin = this->begin();
			iterator end = this->end();

			while (begin != end)
			{
				if (_comp(k, get_key_from_iterator(begin))
						|| k == get_key_from_iterator(begin))
					return begin;
				begin++;
			}

			return end;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7d46
leaq -0xb0(%rbp), %rdi
movq %r15, %rsi
callq 0x7d7a
leaq 0x36c51(%rip), %r12     # 0x45d30
leaq -0x90(%rbp), %r13
movq -0x48(%rbp), %rax
movq -0xa8(%rbp), %rcx
cmpq %rcx, %rax
je 0xf175
movq %r12, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, -0x80(%rbp)
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x18(%rax)
movl (%r14), %ebx
cmpl %eax, %ebx
jl 0xf158
movq %r12, -0x70(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, -0x60(%rbp)
movq (%r15), %rax
movq %r15, %rdi
leaq -0x70(%rbp), %rsi
callq *0x18(%rax)
cmpl %eax, %ebx
je 0xf158
leaq -0xd0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x883a
jmp 0xf0e6
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x38(%rbp), %rdx
jmp 0xf18f
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq %rcx, 0x8(%rax)
leaq -0x98(%rbp), %rdx
movq -0x8(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::upper_bound(int const&)
iterator
		upper_bound(key_type const& k)
		{
			iterator begin = this->begin();
			iterator end = this->end();

			while (begin != end)
			{
				if (_comp(k, get_key_from_iterator(begin)))
					return begin;
				begin++;
			}

			return end;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7d46
leaq -0x90(%rbp), %rdi
movq %r15, %rsi
callq 0x7d7a
leaq 0x36b4b(%rip), %r12     # 0x45d30
leaq -0x70(%rbp), %r13
leaq -0xb0(%rbp), %rbx
movq -0x48(%rbp), %rax
movq -0x88(%rbp), %rcx
cmpq %rcx, %rax
je 0xf231
movq %r12, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, -0x60(%rbp)
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x18(%rax)
cmpl %eax, (%r14)
jl 0xf24a
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x883a
jmp 0xf1f0
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq %rcx, 0x8(%rax)
leaq -0x78(%rbp), %rdx
movq -0x8(%rdx), %rcx
movq %rcx, 0x10(%rax)
jmp 0xf265
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x38(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::find(int const&) const
const_iterator
		find(key_type const& key) const
		{
			node_pointer position = find_helper(key, _root);

			if (!position)
				return end();
			else
				return const_iterator(position, _root, _nil);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x8a32
testq %rax, %rax
je 0xf347
movups 0x8(%r14), %xmm0
leaq 0x36a26(%rip), %rcx     # 0x45d60
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0xf352
movq %rbx, %rdi
movq %r14, %rsi
callq 0x891e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/set.hpp
// Function: bool ft::operator<<int, ft::less<int>, std::allocator<int>>(ft::set<int, ft::less<int>, std::allocator<int>> const&, ft::set<int, ft::less<int>, std::allocator<int>> const&)
bool
	operator<(set<T, Compare, Alloc> const& lhs, set<T, Compare, Alloc> const& rhs)
	{
		return lexicographical_compare(lhs.begin(),
										lhs.end(),
										rhs.begin(),
										rhs.end());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x88ea
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x891e
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88ea
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x891e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0xfb33
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/equal.hpp
// Function: bool ft::equal<ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>)
bool
	equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
	{
		while (first1 != last1)
		{
			if (*first1 != *first2)
				return false;
			first1++;
			first2++;
		}

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movq 0x8(%r15), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0xfb1e
movl (%rax), %edx
movq 0x8(%rbx), %rsi
cmpl (%rsi), %edx
jne 0xfb1e
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6c90
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6c90
jmp 0xfaeb
cmpq %rcx, %rax
sete %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/lexicographical_compare.hpp
// Function: bool ft::lexicographical_compare<ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>)
bool
	lexicographical_compare(InputIterator1 first1,
							InputIterator1 last1,
							InputIterator2 first2,
							InputIterator2 last2)
	{
		// Parse 1st container
		while (first1 != last1)
		{
			// Return false if reach end of 2nd container or
			// if 2nd elem < 1st elem
			if (first2 == last2 || *first2 < *first1)
				return false;
			// Return true if 1st elem < 2nd elem
			else if (*first1 < *first2)
				return true;
			first1++;
			first2++;
		}
		// Reached end of 1st container

		// Return true if we also reached end of 2nd container
		// Return false else
		return (first2 != last2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x48(%rbp), %r13
movq 0x8(%r12), %rsi
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rax
cmpq 0x8(%r15), %rsi
je 0x15aa9
cmpq %rax, %rdi
je 0x15aa5
callq 0x15ac2
testb %al, %al
jne 0x15aa5
movq 0x8(%r12), %rdi
movq 0x8(%r14), %rsi
callq 0x15ac2
testb %al, %al
jne 0x15ab1
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x13534
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x13534
jmp 0x15a55
xorl %eax, %eax
jmp 0x15ab3
cmpq %rax, %rdi
setne %al
jmp 0x15ab3
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/utils/distance.hpp
// Function: ft::iterator_traits<ft::random_access_iterator<int const>>::difference_type ft::distance<ft::random_access_iterator<int const>>(ft::random_access_iterator<int const>, ft::random_access_iterator<int const>)
static typename ft::iterator_traits<InputIterator>::difference_type
	distance(InputIterator first, InputIterator last)
	{

		if (typeid(typename ft::iterator_traits<InputIterator>::iterator_category)
				== typeid(std::output_iterator_tag))
		{
			throw std::exception();
		}
		else if (typeid(typename ft::iterator_traits<InputIterator>::iterator_category)
				== typeid(std::random_access_iterator_tag))
		{
			return last - first;
		}
		else
		{
			typename ft::iterator_traits<InputIterator>::difference_type diff = 0;

			for (InputIterator it = first; it != last; it++)
			{
				diff++;
			}

			return diff;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x36012(%rip), %rdi     # 0x46140
leaq 0x36023(%rip), %rsi     # 0x46158
callq 0x10962
testb %al, %al
jne 0x1016c
leaq 0x35ffb(%rip), %rdi     # 0x46140
movq %rdi, %rsi
callq 0x10962
testb %al, %al
je 0x1015d
movq (%r14), %rax
subq (%rbx), %rax
sarq $0x2, %rax
jmp 0x10167
movq (%r14), %rax
subq (%rbx), %rax
shrq $0x2, %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x50d0
movq 0x36e0d(%rip), %rcx     # 0x46f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x36e37(%rip), %rsi     # 0x46fc0
movq 0x36e60(%rip), %rdx     # 0x46ff0
movq %rax, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::~vector()
virtual
		~vector()
		{
			clear();
			if (_capacity != 0)
				_allocator.deallocate(_start, _capacity);
			_capacity = 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x35ece(%rip), %rax     # 0x460e0
movq %rax, (%rdi)
callq 0x105f8
cmpq $0x0, 0x20(%rbx)
je 0x1022a
movq 0x8(%rbx), %rdi
callq 0x5170
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<Buffer, std::allocator<Buffer>>::push_back(Buffer const&)
void
		push_back(value_type const& val)
		{
			if (empty())
				reserve(1);
			else if (_size == _capacity)
				reserve(_capacity * 2);

			_allocator.construct(&_start[_size], val);
			_size++;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x1027b
cmpq 0x20(%rbx), %rsi
jne 0x10286
addq %rsi, %rsi
jmp 0x1027e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x110e4
imulq $0x1004, 0x18(%rbx), %rdi # imm = 0x1004
addq 0x8(%rbx), %rdi
movl $0x1004, %edx           # imm = 0x1004
movq %r14, %rsi
callq 0x5140
incq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: ft::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<char>, std::allocator<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::operator[](char const&)
mapped_type&
		operator[] (key_type const& k)
		{
			node_pointer position = this->find_helper(k, this->_root);

			// Match
			if (position)
				return position->data.second;
			// No match
			else
			{
				ft::pair<iterator, bool> pr;

				pr = this->insert(ft::make_pair(k, mapped_type()));

				iterator it = pr.first;

				return it._ptr->data.second;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rdx
callq 0x17e64
movq %rax, %r15
testq %rax, %rax
jne 0x1788a
movb (%rbx), %al
leaq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x80(%rbp), %rbx
movb %al, -0x8(%rbx)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x51f0
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x18010
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movq %r14, %rsi
callq 0x17ebe
movq -0xa8(%rbp), %r15
leaq -0x58(%rbp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x51d0
leaq -0x38(%rbp), %rdi
callq 0x51d0
addq $0x8, %r15
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x51d0
jmp 0x178b5
movq %rax, %r14
jmp 0x178bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x51d0
leaq -0x38(%rbp), %rdi
callq 0x51d0
movq %r14, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x5d57
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::operator=(ft::vector<int, std::allocator<int>> const&)
vector&
		operator=(vector const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			this->~vector();

			// Make sure there is enough or just enough space for the new data
			reserve(rhs._size);

			// Deep copy of the rhs sequence
			assign(rhs.begin(), rhs.end());

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x10680
movq %rsi, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1068c
movq 0x8(%r14), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x18(%r14), %rcx
leaq (%rax,%rcx,4), %rax
leaq -0x18(%rbp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10778
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<Buffer, std::allocator<Buffer>>::reserve(unsigned long)
void
		reserve(size_type n)
		{
			// We need to throw we try to allocate more than max_size
			if (n > _allocator.max_size())
				throw std::length_error("reserve:: cannot increase capacity beyond max_size");
			else if (n > _capacity)
			{
				// Allocate for n size
				value_type* new_vec = _allocator.allocate(n);
				size_type	tmp = _size;

				// Copy existing sequence
				for (size_type i = 0; i < _size; i++)
					_allocator.construct(&new_vec[i], _start[i]);

				// Update data
				this->~vector();
				_start = new_vec;
				_size = tmp;
				_capacity = n;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movabsq $0x7fe007fe007ff, %rax  # imm = 0x7FE007FE007FF
cmpq %rax, %rsi
jae 0x11180
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x20(%rdi)
jae 0x11171
leaq 0x10(%r14), %rdi
xorl %r12d, %r12d
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10bde
movq %rax, %r15
movq 0x18(%r14), %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
cmpq %rax, %r13
jae 0x11159
leaq (%r15,%r12), %rdi
movq 0x8(%r14), %rsi
addq %r12, %rsi
movl $0x1004, %edx           # imm = 0x1004
callq 0x5140
incq %r13
movq 0x18(%r14), %rax
addq $0x1004, %r12           # imm = 0x1004
jmp 0x1112f
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, 0x8(%r14)
movq -0x38(%rbp), %rax
movq %rax, 0x18(%r14)
movq %rbx, 0x20(%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x50d0
movq %rax, %rbx
leaq 0x1d9c0(%rip), %rsi     # 0x2eb52
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x5090
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x52e0
xorl %r15d, %r15d
movq 0x35de8(%rip), %rsi     # 0x46fa0
movq 0x35db9(%rip), %rdx     # 0x46f78
movq %rbx, %rdi
callq 0x52b0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x51d0
testb %r15b, %r15b
jne 0x111e5
jmp 0x111ed
movq %rax, %rdi
callq 0x5d57
movq %rax, %r14
movq %rbx, %rdi
callq 0x5120
movq %r14, %rdi
callq 0x52d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: void ft::vector<int, std::allocator<int>>::assign<ft::random_access_iterator<int const>>(ft::random_access_iterator<int const>, ft::random_access_iterator<int const>, ft::enable_if<!ft::is_integral<ft::random_access_iterator<int const>>::value, ft::random_access_iterator<int const>>::type*)
void
		assign(InputIterator first,
				InputIterator last,
				typename ft::enable_if<!ft::is_integral<InputIterator>::value,
					InputIterator>::type* = NULL)
		{
			// Destroy existing elements
			clear();

			// Make sure there is enough or just enough space for the new data
			reserve(ft::distance(first, last));

			// Setting new elements
			insert(begin(), first, last);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x105f8
movq (%r15), %rax
leaq -0x40(%rbp), %rdi
movq %rax, (%rdi)
movq (%r14), %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
callq 0x1011a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1068c
movq 0x8(%rbx), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq (%r15), %rax
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
movq (%r14), %rax
leaq -0x20(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x10816
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq