LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq (%rdx), %rdx
cmpq 0x10(%rdi), %rdx
je 0x756b
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq 0x8(%r12), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x756f
testq %rdx, %rdx
je 0x7574
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x51f0
testl %eax, %eax
sete %r12b
jmp 0x7577
xorl %eax, %eax
jmp 0x75df
xorl %r12d, %r12d
jmp 0x7577
movb $0x1, %r12b
leaq -0x38(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x7589
callq 0x5190
testb %r12b, %r12b
je 0x7593
movq (%r15), %rax
jmp 0x75df
movq (%r15), %rdx
movq (%r14), %rax
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5040
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x75c2
callq 0x5190
movq (%r15), %rdx
testl %r12d, %r12d
js 0x75d0
addq $0x30, %rdx
jmp 0x75d4
addq $0x28, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7514
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x75ff
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, -0x30(%rbp)
cmpq %rdx, 0x10(%rdi)
je 0x76e9
movq %rdi, %r14
movq %rdx, %r12
movq (%r14), %rax
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq *0x10(%rax)
movq (%r14), %rax
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq -0x48(%rbp), %r13
movq -0x68(%rbp), %rbx
cmpq %r13, %rbx
movq %r13, %rdx
cmovbq %rbx, %rdx
testq %rdx, %rdx
je 0x7681
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x50c0
movl %eax, %r15d
jmp 0x7684
xorl %r15d, %r15d
testl %r15d, %r15d
jne 0x76ad
subq %rbx, %r13
cmpq $-0x7fffffff, %r13      # imm = 0x80000001
movq $-0x80000000, %rax      # imm = 0x80000000
cmovlq %rax, %r13
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r13
cmovgeq %rax, %r13
movl %r13d, %r15d
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x76bf
callq 0x5190
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x76d1
callq 0x5190
notl %r15d
shrl $0x1f, %r15d
movq 0x28(%r12,%r15,8), %rdx
cmpq 0x10(%r14), %rdx
jne 0x7634
jmp 0x76ec
xorl %r12d, %r12d
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7713
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7026
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x702a
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x10(%r8), %r8
cmpq %rdx, %r8
je 0x7040
movq %rax, 0x8(%r8)
movq %r8, %rdx
movq (%rsi), %r8
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_O1/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 0x7090
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x7094
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x18(%r8), %r8
cmpq %rdx, %r8
je 0x70aa
movq %rax, 0x8(%r8)
movq %r8, %rdx
movq (%rsi), %r8
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_O1/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::less<char> const&, std::allocator<ft::red_black_tree_node<ft::pair<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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x2f867(%rip), %rax     # 0x4a908
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r12d, %r12d
movq %r12, 0x18(%rdi)
movl $0x48, %edi
callq 0x51e0
movq %rax, %r15
movq %rax, 0x10(%r14)
leaq -0x78(%rbp), %rbx
movb %r12b, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movq %r12, -0x8(%rbx)
movb %r12b, (%rbx)
leaq -0x60(%rbp), %rdi
movb %r12b, -0x8(%rdi)
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x728c
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movb -0x68(%rbp), %al
movb %al, (%r15)
leaq 0x8(%r15), %rdi
movq %r15, %rax
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
callq 0x728c
leaq -0x40(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0x34(%r15)
movups %xmm0, 0x28(%r15)
movq -0x20(%rax), %rdi
cmpq %r12, %rdi
je 0x1b150
callq 0x5190
movq -0x88(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1b161
callq 0x5190
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b18c
callq 0x5190
jmp 0x1b18c
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1b19d
callq 0x5190
movq %r14, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x95f0
movq %rsi, %r14
leaq 0x8(%rbx), %r15
cmpq $0x0, 0x8(%rbx)
je 0x95d3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6c08
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x95fe
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>>>::copy_helper(ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*&, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
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, -0x30(%rbp)
cmpq %rbx, %r15
je 0x226b4
movl $0x48, %edi
callq 0x51e0
movq %rax, %r12
movq %rax, (%r14)
movb (%r15), %al
movb %al, (%r12)
leaq 0x8(%r12), %rdi
leaq 0x18(%r12), %rax
movq %rax, 0x8(%r12)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x728c
movups 0x28(%r15), %xmm0
movups 0x34(%r15), %xmm1
movups %xmm1, 0x34(%r12)
movups %xmm0, 0x28(%r12)
movq (%r14), %rax
movq %r13, 0x28(%rax)
movq (%r14), %rcx
leaq 0x30(%rcx), %rsi
movq 0x30(%r15), %rdx
movq -0x30(%rbp), %rdi
movq %rbx, %r8
callq 0x2261a
movq (%r14), %r13
leaq 0x38(%r13), %r14
movq 0x38(%r15), %r15
jmp 0x22638
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28462(%rip), %rax     # 0x4a908
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x18(%rdi)
movl $0x48, %edi
callq 0x51e0
movq %rax, %r12
movq %rax, 0x10(%r14)
leaq -0x80(%rbp), %r15
movb %r13b, -0x18(%r15)
movq %r15, -0x10(%r15)
movq %r13, -0x8(%r15)
movb %r13b, (%r15)
leaq -0x68(%rbp), %rdi
movb %r13b, -0x8(%rdi)
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rsi
movq %r15, %rdx
callq 0x728c
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x1, -0x30(%rbp)
movb -0x70(%rbp), %al
movb %al, (%r12)
leaq 0x8(%r12), %rdi
movq %r12, %rax
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
callq 0x728c
leaq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0x34(%r12)
movups %xmm0, 0x28(%r12)
movq -0x20(%rax), %rdi
cmpq %r13, %rdi
je 0x22559
callq 0x5190
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x2256a
callq 0x5190
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x225bc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x225a2
callq 0x5190
jmp 0x225a2
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x225b3
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq 0x8(%rdx), %rax
movq 0x18(%rax), %rdx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdx
je 0xd1d8
cmpq $0x0, 0x18(%r14)
je 0xd1f3
movq %rdx, %r13
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
jne 0xd1ca
jmp 0xd1f6
movq 0x8(%r14), %rcx
movq %rax, %rdx
movq 0x8(%rdx), %r13
cmpq %rcx, %rdx
je 0xd1f6
cmpq 0x18(%r13), %rdx
movq %r13, %rdx
je 0xd1df
jmp 0xd1f6
xorl %r13d, %r13d
movq %rdi, -0x30(%rbp)
leaq 0x3cdef(%rip), %rcx     # 0x49ff0
leaq -0x50(%rbp), %rsi
movq %rcx, (%rsi)
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, %r12d
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
cmpl %eax, %r12d
jge 0xd2b2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movl %eax, %r12d
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *0x10(%rax)
cmpl %eax, %r12d
jge 0xd2b2
movl $0x28, %edi
callq 0x51e0
movl (%rbx), %ecx
movq 0x10(%r14), %rdx
movl %ecx, (%rax)
movq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq 0x18(%r14)
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9236
movups 0x8(%r14), %xmm0
movq -0x30(%rbp), %rcx
leaq 0x3cd4b(%rip), %rdx     # 0x49ff0
movq %rdx, (%rcx)
movq %rax, 0x8(%rcx)
movups %xmm0, 0x10(%rcx)
jmp 0xd2ea
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8628
movq -0x30(%rbp), %rcx
leaq 0x3cd21(%rip), %rax     # 0x49ff0
movq %rax, (%rcx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rcx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rcx)
movq %rcx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x91cc
movq 0x18(%rbx), %rax
movq %rax, %rcx
testq %rax, %rax
je 0xd329
movq 0x10(%rbx), %rcx
movq -0x28(%rbp), %rsi
cmpq %rcx, %rsi
je 0xd354
testq %rax, %rax
je 0xd33b
movq 0x10(%rbx), %rax
movl $0x1, %r14d
cmpq %rax, %rsi
je 0xd357
movq %rbx, %rdi
callq 0xd46a
decq 0x18(%rbx)
jmp 0xd357
xorl %r14d, %r14d
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x10(%r14), %rax
cmpq %rax, %rcx
jne 0xd48a
cmpq %rax, 0x18(%rbx)
je 0xd4ec
movq 0x18(%rbx), %rsi
cmpq %rax, %rsi
je 0xd4a8
cmpq $0x0, 0x18(%r14)
je 0xd4c2
movq %rsi, %rdx
movq 0x10(%rsi), %rsi
cmpq %rax, %rsi
jne 0xd49a
jmp 0xd4c4
cmpq %rax, %rcx
je 0xd4d1
cmpq $0x0, 0x18(%r14)
je 0xd4c2
movq %rcx, %rdx
movq 0x18(%rcx), %rcx
cmpq %rax, %rcx
jne 0xd4b4
jmp 0xd4c4
xorl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd6f2
jmp 0xd477
movq 0x8(%r14), %rax
movq %rbx, %rcx
movq 0x8(%rcx), %rdx
cmpq %rax, %rcx
je 0xd4c4
cmpq 0x10(%rdx), %rcx
movq %rdx, %rcx
je 0xd4d8
jmp 0xd4c4
cmpl $0x1, 0x20(%rbx)
jne 0xd4fd
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd532
cmpq %rbx, 0x8(%r14)
je 0xd517
movq 0x8(%rbx), %rax
movq 0x10(%r14), %rcx
cmpq %rbx, 0x10(%rax)
je 0xd521
movq %rcx, 0x18(%rax)
jmp 0xd525
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
jmp 0xd525
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5190
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdx), %r8
movq 0x10(%rdx), %rcx
movq 0x18(%rdx), %rax
leaq 0x8(%rdi), %r9
movq 0x8(%rdi), %r10
movq %r9, %r11
cmpq %rsi, %r10
je 0xd72c
movq 0x8(%rsi), %r11
cmpq %rsi, 0x10(%r11)
je 0xd728
cmpq %rsi, 0x18(%r11)
jne 0xd72f
addq $0x18, %r11
jmp 0xd72c
addq $0x10, %r11
movq %rdx, (%r11)
movq 0x8(%rsi), %r11
movq %r11, 0x8(%rdx)
movq (%r9), %r11
xorq %r11, %r10
xorq %rdx, %r11
orq %r10, %r11
je 0xd75b
cmpq %rdx, 0x10(%r8)
je 0xd757
cmpq %rdx, 0x18(%r8)
jne 0xd75e
leaq 0x18(%r8), %r9
jmp 0xd75b
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 0xd777
movq %rdx, 0x8(%r8)
movq 0x18(%rsi), %r8
movq %r8, 0x18(%rdx)
cmpq %rdi, %r8
je 0xd788
movq %rdx, 0x8(%r8)
movq %rcx, 0x10(%rsi)
cmpq %rdi, %rcx
je 0xd795
movq %rsi, 0x8(%rcx)
movq %rax, 0x18(%rsi)
cmpq %rdi, %rax
je 0xd7a2
movq %rsi, 0x8(%rax)
movl 0x20(%rdx), %eax
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdx)
movl %eax, 0x20(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rax
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %rcx
cmpq %rcx, %rsi
je 0xebb2
movq 0x10(%rsi), %rdi
cmpq %rcx, %rdi
je 0xeba4
movq %rdi, %rdx
movq 0x18(%rdi), %rdi
cmpq %rcx, %rdi
jne 0xeb8d
jmp 0xebc2
cmpq 0x10(%rdx), %rsi
movq %rdx, %rsi
jne 0xebc2
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
jne 0xeb9b
movq %rcx, %rdx
jmp 0xebc2
movq 0x10(%rax), %rsi
movq %rsi, %rdx
movq 0x18(%rsi), %rsi
cmpq %rcx, %rsi
jne 0xebb6
movq %rdx, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movq 0x18(%rsi), %rdx
testq %rdx, %rdx
je 0x112bd
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rax
movq %rcx, %r13
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x112af
jmp 0x112c0
xorl %r13d, %r13d
testq %rdx, %rdx
movq 0x8(%r12), %r15
movq 0x10(%r12), %rbx
cmovneq %rbx, %rdx
cmpq %rdx, %r13
je 0x113a1
leaq 0x38d0f(%rip), %r14     # 0x49ff0
movq %rdx, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movq %r14, -0x88(%rbp)
movq %r13, -0x80(%rbp)
movq %r15, -0x78(%rbp)
movq %rbx, -0x70(%rbp)
movq (%r12), %rax
movq %r12, %rdi
leaq -0x88(%rbp), %rsi
callq *0x18(%rax)
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
cmpl %eax, %ecx
jl 0x1139e
movq %r14, -0x68(%rbp)
movq %r13, -0x60(%rbp)
movq %r15, -0x58(%rbp)
movq %rbx, -0x50(%rbp)
movq (%r12), %rax
movq %r12, %rdi
leaq -0x68(%rbp), %rsi
movl %ecx, %r14d
callq *0x18(%rax)
cmpl %eax, %r14d
je 0x113a7
cmpq %rbx, %r13
je 0x11379
movq 0x18(%r13), %rcx
cmpq %rbx, %rcx
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r15
je 0x11365
movq %rcx, %rax
movq 0x10(%rcx), %rcx
cmpq %rbx, %rcx
jne 0x11357
jmp 0x11389
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x11386
cmpq 0x18(%rax), %r13
movq %rax, %r13
je 0x11365
jmp 0x11389
movq %r13, %rax
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r15
jmp 0x11389
movq %rbx, %rax
movq %rax, %r13
cmpq %rdx, %rax
leaq 0x38c5a(%rip), %r14     # 0x49ff0
jne 0x112e9
jmp 0x113a1
movq %r13, %rdx
movq -0x30(%rbp), %rax
jmp 0x113b2
movq %r13, %rdx
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %r15
leaq 0x38c37(%rip), %rcx     # 0x49ff0
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x11413
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
movq %rcx, %r13
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x11405
jmp 0x11416
xorl %r13d, %r13d
testq %r14, %r14
movq 0x8(%r15), %rbx
movq 0x10(%r15), %r12
cmovneq %r12, %r14
cmpq %r14, %r13
je 0x1149b
leaq 0x38bbf(%rip), %rax     # 0x49ff0
movq %rax, -0x58(%rbp)
movq %r13, -0x50(%rbp)
movq %rbx, -0x48(%rbp)
movq %r12, -0x40(%rbp)
movq (%r15), %rax
movq %r15, %rdi
leaq -0x58(%rbp), %rsi
callq *0x18(%rax)
movq -0x38(%rbp), %rcx
cmpl %eax, (%rcx)
jl 0x11498
cmpq %r12, %r13
je 0x11486
movq 0x18(%r13), %rcx
cmpq %r12, %rcx
je 0x11472
movq %rcx, %rax
movq 0x10(%rcx), %rcx
cmpq %r12, %rcx
jne 0x11464
jmp 0x1148e
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x1148b
cmpq 0x18(%rax), %r13
movq %rax, %r13
je 0x11472
jmp 0x1148e
movq %r13, %rax
jmp 0x1148e
movq %r12, %rax
movq %rax, %r13
cmpq %r14, %rax
jne 0x1142a
jmp 0x1149b
movq %r13, %r14
movq -0x30(%rbp), %rax
leaq 0x38b4a(%rip), %rcx     # 0x49ff0
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x92c6
testq %rax, %rax
je 0x1157d
movq 0x10(%r15), %rcx
jmp 0x11593
cmpq $0x0, 0x18(%r15)
je 0x1158d
movq 0x10(%r15), %rax
movq %rax, %rcx
jmp 0x11593
movq 0x10(%r15), %rcx
xorl %eax, %eax
movq (%r14), %rdx
leaq 0x38d73(%rip), %rsi     # 0x4a310
movq %rsi, (%rbx)
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x80, %rsp
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1206c
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rax
movq %r8, %rdx
movq 0x10(%r8), %r8
cmpq %rax, %r8
jne 0x1205e
jmp 0x1206e
xorl %edx, %edx
testq %rcx, %rcx
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rdi
leaq 0x38290(%rip), %rax     # 0x4a310
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x20(%rbp)
cmovneq %rdi, %rcx
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x120c3
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rdx
movq %r8, %rcx
movq 0x10(%r8), %r8
cmpq %rdx, %r8
jne 0x120b5
jmp 0x120c5
xorl %ecx, %ecx
testq %rdi, %rdi
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rsi
leaq -0x80(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq %r8, 0x10(%rdx)
movq %rsi, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
cmovneq %rsi, %rdi
movq %rax, (%rcx)
movq %rdi, 0x8(%rcx)
movq %r8, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x121b2
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
je 0x18b1b
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%r14), %rcx
cmpq 0x8(%rbx), %rcx
je 0x18b28
movb (%rcx), %dl
movb (%rax), %sil
cmpb %sil, %dl
jl 0x18b28
jg 0x18aeb
movl 0x4(%rcx), %edi
cmpl 0x4(%rax), %edi
jl 0x18b28
cmpb %dl, %sil
setl %dl
jne 0x18afc
movl 0x4(%rax), %eax
cmpl 0x4(%rcx), %eax
setl %dl
testb %dl, %dl
jne 0x18b2c
movq %r12, %rdi
callq 0x18a5c
movq %r14, %rdi
callq 0x18a5c
movq 0x8(%r12), %rax
cmpq 0x8(%r15), %rax
jne 0x18acd
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
setne %al
jmp 0x18b2e
xorl %eax, %eax
jmp 0x18b2e
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37918(%rip), %rax     # 0x4a370
movq %rax, (%rdi)
cmpq $0x0, 0x18(%rdi)
je 0x12a6a
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x12a7a
movq 0x8(%rbx), %rdi
callq 0x5190
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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), %rax
testq %rax, %rax
je 0x31c62
movq 0x20(%rbx), %rsi
cmpq %rsi, %rax
jne 0x31c6f
addq %rsi, %rsi
jmp 0x31c67
movl $0x1, %esi
movq %rbx, %rdi
callq 0x28258
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x728c
incq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rdx
callq 0x1b28e
movq %rax, %r15
testq %rax, %rax
jne 0x1abc1
movb (%rbx), %al
leaq -0x88(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq -0x48(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x728c
movb -0x50(%rbp), %al
leaq -0x70(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x728c
leaq -0xc0(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x1b2e8
movq -0xb8(%rbp), %r15
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x1aba2
callq 0x5190
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1abb0
callq 0x5190
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1abc1
callq 0x5190
addq $0x8, %r15
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x1abf0
callq 0x5190
jmp 0x1abf0
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1ac03
callq 0x5190
jmp 0x1ac03
movq %rax, %r14
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1ac14
callq 0x5190
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12eea
movq %rsi, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x12ef6
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 0x12fee
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 $0x28, %rsp
movq %rsi, %rax
shrq $0x3a, %rax
jne 0x282ff
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x20(%rdi)
jae 0x282f0
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x28382
movq %rax, %r15
movq 0x18(%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x282d8
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq (%r15,%r13), %rdi
movq 0x8(%r14), %rax
leaq (%r15,%r13), %rcx
addq $0x10, %rcx
movq %rcx, (%r15,%r13)
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
addq %rsi, %rdx
callq 0x728c
incq %r12
addq $0x20, %r13
cmpq 0x18(%r14), %r12
jb 0x282a6
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, 0x8(%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r14)
movq %rbx, 0x20(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x50e0
movq %rax, %rbx
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xf7f6(%rip), %rsi      # 0x37b12
leaq 0xf821(%rip), %rdx      # 0x37b44
leaq -0x50(%rbp), %rdi
callq 0x5fe8
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0x22c83(%rip), %rsi     # 0x4afc8
movq 0x22c64(%rip), %rdx     # 0x4afb0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2836d
callq 0x5190
jmp 0x2836d
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x2837a
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x13013
movq $0x0, 0x18(%rbx)
movq (%r14), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x12ef6
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 0x13078
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: bool ft::operator<<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>>(ft::map<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>> const&, ft::map<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>> const&)
bool
	operator<(map<Key, T, Compare, Alloc> const& lhs, map<Key, T, Compare, Alloc> const& rhs)
	{
		return lexicographical_compare(lhs.begin(),
										lhs.end(),
										rhs.begin(),
										rhs.end());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x18942
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rax
movq %r8, %rdx
movq 0x10(%r8), %r8
cmpq %rax, %r8
jne 0x18934
jmp 0x18944
xorl %edx, %edx
testq %rcx, %rcx
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rdi
leaq 0x31dc2(%rip), %rax     # 0x4a718
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x20(%rbp)
cmovneq %rdi, %rcx
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x18999
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rdx
movq %r8, %rcx
movq 0x10(%r8), %r8
cmpq %rdx, %r8
jne 0x1898b
jmp 0x1899b
xorl %ecx, %ecx
testq %rdi, %rdi
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rsi
leaq -0x80(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq %r8, 0x10(%rdx)
movq %rsi, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
cmovneq %rsi, %rdi
movq %rax, (%rcx)
movq %rdi, 0x8(%rcx)
movq %r8, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18aac
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: ft::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<ft::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mapped_type&
		at(key_type const& k)
		{
			node_pointer position = this->find_helper(k, this->_root);

			// Match
			if (position)
				return position->data.second;
			// No match
			else
				throw std::out_of_range("at:: out of range index");
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rdi), %rdx
callq 0x1bc48
testq %rax, %rax
je 0x1ae44
addq $0x20, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x50e0
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1cce4(%rip), %rsi     # 0x37b45
leaq 0x1ccf4(%rip), %rdx     # 0x37b5c
leaq -0x40(%rbp), %rdi
callq 0x5fe8
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x5240
xorl %r15d, %r15d
movq 0x30146(%rip), %rsi     # 0x4afd0
movq 0x3012f(%rip), %rdx     # 0x4afc0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1aeb2
callq 0x5190
jmp 0x1aeb2
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1aebf
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::vector(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
explicit
		vector(size_type n,
				value_type const& val = value_type(),
				allocator_type const& alloc = allocator_type()) :
			_start(NULL),
			_allocator(alloc),
			_size(0),
			_capacity(0)
		{
			reserve(n);

			for (size_type i = 0; i < n; i++)
				_allocator.construct(_start + i, val);

			_size = n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x222bc(%rip), %rax     # 0x4a340
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
callq 0x28258
testq %r12, %r12
je 0x280d9
xorl %r13d, %r13d
movq %r12, %rbx
movq 0x8(%r15), %rdi
leaq (%rdi,%r13), %rax
addq $0x10, %rax
addq %r13, %rdi
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x728c
addq $0x20, %r13
decq %rbx
jne 0x280ae
movq -0x30(%rbp), %rax
movq %r12, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq