LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: epfml[P]sent2vec/src/main.cc
// Function: printUsage()
void printUsage() {
  std::cerr
    << "usage: fasttext <command> <args>\n\n"
    << "The commands supported by fasttext are:\n\n"
    << "  supervised                train a supervised classifier\n"
    << "  sent2vec                  train unsupervised sentence embeddings\n"
    << "  quantize                  quantize a model to reduce the memory usage\n"
    << "  test                      evaluate a supervised classifier\n"
    << "  predict                   predict most likely labels\n"
    << "  predict-prob              predict most likely labels with probabilities\n"
    << "  skipgram                  train a skipgram model\n"
    << "  cbow                      train a cbow model\n"
    << "  cbow-c+w-ngrams           train a cbow model augmented with character and word ngrams\n"
    << "  print-word-vectors        print word vectors given a trained model\n"
    << "  print-sentence-vectors    print sentence vectors given a trained model\n"
    << "  print-vocabulary-vectors  print unigram vectors in vocabulary\n"
    << "  print-vocabulary          print word in vocabulary with count\n"
    << "  nn                        query for nearest neighbors\n"
    << "  nnSent                    query for nearest neighbors for sentences\n"
    << "  analogies                 query for analogies\n"
    << "  analogiesSent             query for analogies for Sentences\n"
    << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1fbd5(%rip), %rdi     # 0x5eff0
leaq 0x4ae4(%rip), %rsi      # 0x43f06
callq 0x5420
movq %rax, %rdi
leaq 0x4af8(%rip), %rsi      # 0x43f29
callq 0x5420
movq %rax, %rdi
leaq 0x4b13(%rip), %rsi      # 0x43f53
callq 0x5420
movq %rax, %rdi
leaq 0x4b3f(%rip), %rsi      # 0x43f8e
callq 0x5420
movq %rax, %rdi
leaq 0x4b74(%rip), %rsi      # 0x43fd2
callq 0x5420
movq %rax, %rdi
leaq 0x4bae(%rip), %rsi      # 0x4401b
callq 0x5420
movq %rax, %rdi
leaq 0x4bdd(%rip), %rsi      # 0x44059
callq 0x5420
movq %rax, %rdi
leaq 0x4c06(%rip), %rsi      # 0x44091
callq 0x5420
movq %rax, %rdi
leaq 0x4c42(%rip), %rsi      # 0x440dc
callq 0x5420
movq %rax, %rdi
leaq 0x4c67(%rip), %rsi      # 0x44110
callq 0x5420
movq %rax, %rdi
leaq 0x4c88(%rip), %rsi      # 0x44140
callq 0x5420
movq %rax, %rdi
leaq 0x4cd2(%rip), %rsi      # 0x44199
callq 0x5420
movq %rax, %rdi
leaq 0x4d09(%rip), %rsi      # 0x441df
callq 0x5420
movq %rax, %rdi
leaq 0x4d44(%rip), %rsi      # 0x44229
callq 0x5420
movq %rax, %rdi
leaq 0x4d76(%rip), %rsi      # 0x4426a
callq 0x5420
movq %rax, %rdi
leaq 0x4da8(%rip), %rsi      # 0x442ab
callq 0x5420
movq %rax, %rdi
leaq 0x4dd2(%rip), %rsi      # 0x442e4
callq 0x5420
movq %rax, %rdi
leaq 0x4e0a(%rip), %rsi      # 0x4432b
callq 0x5420
movq %rax, %rdi
leaq 0x4e2c(%rip), %rsi      # 0x4435c
callq 0x5420
movq %rax, %rdi
movq 0x1fa51(%rip), %rsi     # 0x5ef90
callq 0x5460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: superblocks[P]superblocks/set-elp.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "ELP"; 
	coin_name = "Elephantcoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 50;

	// superblock (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 5;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 600000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 300000;
	luck_y[1] = 300021;
	//reward[1] = "rand1 = generateMTRandom(rand, 10001); nSubsidy = (10000 + rand1 - 1) * COIN;";
		secondary_rand[1] = 1;
		secondary_rand_type[1] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[1] = 1;
		secondary_rand_high[1] = 10001;
		secondary_rand_x[1] = 1;
	reward[1] = 10000;

	// superblock (step 2+)

	luck_type[2] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[2] = 100000;
	luck_y[2] = 100301;
	//reward[2] = "rand1 = generateMTRandom(rand, 4001); nSubsidy = (1000 + rand1 - 1) * COIN;";
		secondary_rand[2] = 1;
		secondary_rand_type[2] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[2] = 1;
		secondary_rand_high[2] = 4001;
		secondary_rand_x[2] = 1;
	reward[2] = 1000;

	luck_type[3] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[3] = 500000;
	luck_y[3] = 506001;
	//reward[3] = "rand1 = generateMTRandom(rand, 401); nSubsidy = (100 + rand1 - 1) * COIN;";
		secondary_rand[3] = 1;
		secondary_rand_type[3] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[3] = 1;
		secondary_rand_high[3] = 401;
		secondary_rand_x[3] = 1;
	reward[3] = 100;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0x1801(%rip), %rsi      # 0x5e80
callq 0x21a0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0x17f1(%rip), %rsi      # 0x5e84
callq 0x21a0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x32, 0x14c(%rax)
movl $0x2, 0x60(%rax)
movl $0x5, 0x70(%rax)
movl $0x7, 0x80(%rax)
movl $0x1, 0x90(%rax)
movl $0x927c0, 0xa0(%rax)    # imm = 0x927C0
movl $0x3, 0x120(%rax)
movl $0x493e0, 0x130(%rax)   # imm = 0x493E0
movl $0x493f5, 0x140(%rax)   # imm = 0x493F5
movl $0x1, 0xb0(%rax)
movl $0x1, 0xc0(%rax)
movl $0x1, 0xd0(%rax)
movl $0x2711, 0xe0(%rax)     # imm = 0x2711
movl $0x1, 0xf0(%rax)
movl $0x2710, 0x150(%rax)    # imm = 0x2710
movl $0x3, 0x124(%rax)
movl $0x186a0, 0x134(%rax)   # imm = 0x186A0
movl $0x187cd, 0x144(%rax)   # imm = 0x187CD
movl $0x1, 0xb4(%rax)
movl $0x1, 0xc4(%rax)
movl $0x1, 0xd4(%rax)
movl $0xfa1, 0xe4(%rax)      # imm = 0xFA1
movl $0x1, 0xf4(%rax)
movl $0x3e8, 0x154(%rax)     # imm = 0x3E8
movl $0x3, 0x128(%rax)
movl $0x7a120, 0x138(%rax)   # imm = 0x7A120
movl $0x7b891, 0x148(%rax)   # imm = 0x7B891
movl $0x1, 0xb8(%rax)
movl $0x1, 0xc8(%rax)
movl $0x1, 0xd8(%rax)
movl $0x191, 0xe8(%rax)      # imm = 0x191
movl $0x1, 0xf8(%rax)
movl $0x64, 0x158(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: 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>>>, std::allocator<ft::red_black_tree_node<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&, std::allocator<ft::red_black_tree_node<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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq 0x89327(%rip), %rax     # 0x97e10
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x21, %rdi
movq %rdi, -0x98(%rbp)
movq -0x18(%rbp), %rsi
callq 0xedc0
movq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xedf0
movq %rax, -0x90(%rbp)
jmp 0xeb36
movq -0xa0(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x21, %rcx
movq %rcx, -0xb0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6260
jmp 0xeb6f
xorl %eax, %eax
movl %eax, %r8d
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %r9d
movq %r8, %rdx
movq %r8, %rcx
callq 0xa180
jmp 0xeb92
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xee50
jmp 0xebab
leaq -0x68(%rbp), %rdi
callq 0xa1e0
jmp 0xebb6
leaq -0x88(%rbp), %rdi
callq 0x6130
jmp 0xebc4
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xec21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xec11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa1e0
jmp 0xec0f
jmp 0xec11
leaq -0x88(%rbp), %rdi
callq 0x6130
jmp 0xec1f
jmp 0xec21
movq -0x98(%rbp), %rdi
callq 0xec40
movq -0x20(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nop
// File: 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>>>::clear_helper(ft::red_black_tree_node<int>* 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x8b07
jmp 0x8b6c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x10, %rsi
callq 0x8ae0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
callq 0x8ae0
movq -0x18(%rbp), %rdi
addq $0x21, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8aa0
movq -0x18(%rbp), %rdi
addq $0x21, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x8ab0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq %rdi, %rdx
addq $0x8, %rdx
callq 0x92d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8fe1
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x9040
jmp 0x8ffa
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0x9230
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/bidirectional_iterator.hpp
// Function: ft::bidirectional_iterator<ft::red_black_tree_node<int>>::operator=(ft::bidirectional_iterator<ft::red_black_tree_node<int>> const&)
bidirectional_iterator&
		operator=(bidirectional_iterator const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			_ptr = rhs._ptr;
			_root = rhs._root;
			_nil = rhs._nil;

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x9294
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x92c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0xa829
movq $0x0, -0x8(%rbp)
jmp 0xa95f
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa980
movb %al, -0x79(%rbp)
jmp 0xa85d
leaq -0x40(%rbp), %rdi
callq 0x6130
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xa86f
jmp 0xa89b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa95f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6130
jmp 0xa896
jmp 0xa96c
jmp 0xa89d
movq -0x78(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq *%rax
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xaa00
movb %al, -0x89(%rbp)
jmp 0xa8f7
leaq -0x70(%rbp), %rdi
callq 0x6130
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xa90c
jmp 0xa943
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
addq $0x28, %rdx
callq 0xa7f0
movq %rax, -0x8(%rbp)
jmp 0xa95f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6130
jmp 0xa941
jmp 0xa96c
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
addq $0x30, %rdx
callq 0xa7f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopl (%rax)
// File: 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>>>::minimum() const
node_pointer
		minimum() const
		{
			node_pointer node = _root;

			if (empty())
				return NULL;

			while (node->left != _nil)
				node = node->left;

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0x93e0
testb $0x1, %al
jne 0x9477
jmp 0x9481
movq $0x0, -0x8(%rbp)
jmp 0x94ab
jmp 0x9483
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x94a3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9483
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x80(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
je 0xad32
movq -0x80(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
movq -0x80(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0xaca3
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xaa00
movb %al, -0x89(%rbp)
jmp 0xacbf
leaq -0x68(%rbp), %rdi
callq 0x6130
jmp 0xacca
leaq -0x48(%rbp), %rdi
callq 0x6130
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xacdf
jmp 0xad21
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xad2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xad14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6130
jmp 0xad12
jmp 0xad14
leaq -0x48(%rbp), %rdi
callq 0x6130
jmp 0xad1f
jmp 0xad3f
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xac4f
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x98c6
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x98f6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x98e5
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x98f4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x98f6
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x9926
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rdx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x9957
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x9966
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9a16
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9a46
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x9a35
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x9a44
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x9a46
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x9a76
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rdx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x9aa7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x9ab6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/bidirectional_iterator.hpp
// Function: ft::bidirectional_iterator<ft::red_black_tree_node<int> const>::successor(ft::red_black_tree_node<int> const*)
node_pointer
		successor(node_pointer node)
		{
			node_pointer successor;

			// If node has a right child, it's successor is the minimum
			// of its right subtree
			if (node->right != _nil)
				return minimum(node->right);

			// If not, we need to go look for it in it's parent right side
			// The successor will be the first node that has its
			// right child that isn't also an ancestor of the base node
			successor = node->parent;
			while (node->parent != NULL && node == successor->right)
			{
				node = successor;
				successor = successor->parent;
			}

			// If node is _root then successor is NULL
			if (!successor)
				return _nil;
			else
				return successor;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x18(%rcx), %rax
je 0x9ddd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x9e60
movq %rax, -0x8(%rbp)
jmp 0x9e47
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x29(%rbp)
je 0x9e0b
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9e14
jmp 0x9e2a
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9de9
cmpq $0x0, -0x20(%rbp)
jne 0x9e3f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9e47
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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>>>, std::allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::red_black_tree(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>>>, std::allocator<ft::red_black_tree_node<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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq 0x8826b(%rip), %rax     # 0x97e10
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rsi
addq $0x21, %rdi
movq %rdi, -0x90(%rbp)
addq $0x21, %rsi
callq 0xedc0
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xedf0
movq %rax, -0x88(%rbp)
jmp 0xfbf6
movq -0x98(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x21, %rcx
movq %rcx, -0xa8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6260
jmp 0xfc2c
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x1, %r9d
movq %r8, %rdx
movq %r8, %rcx
callq 0xa180
jmp 0xfc4c
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xee50
jmp 0xfc65
leaq -0x60(%rbp), %rdi
callq 0xa1e0
jmp 0xfc70
leaq -0x80(%rbp), %rdi
callq 0x6130
jmp 0xfc7b
movq -0x98(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
callq 0xfd00
jmp 0xfc95
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xfce0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xfcd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa1e0
jmp 0xfcd1
jmp 0xfcd3
leaq -0x80(%rbp), %rdi
callq 0x6130
jmp 0xfcde
jmp 0xfce0
movq -0x90(%rbp), %rdi
callq 0xec40
movq -0x18(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0xe948
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe994
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe95c
movq -0x20(%rbp), %rdi
callq 0x8a60
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0xe9a0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xe9e2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xea77
movq -0x30(%rbp), %rdi
addq $0x21, %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x88b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x21, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x8910
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %r8
callq 0xe9a0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %r8
callq 0xe9a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, int>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, int>>>>::erase(ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>>>)
void
		erase(iterator position)
		{
			if (position == end())
				return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2a430
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2c340
movb %al, -0x3d(%rbp)
jmp 0x2a4db
leaq -0x30(%rbp), %rdi
callq 0x2a490
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x2a4ed
jmp 0x2a508
jmp 0x2a529
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2a490
jmp 0x2a506
jmp 0x2a52f
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2c370
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x90(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe040
movq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc3a0
jmp 0x15a4d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x15910
movq -0xa0(%rbp), %rdi
movb %al, -0x91(%rbp)
callq 0x8600
jmp 0x15a75
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x15a81
jmp 0x15aa0
movq $0x0, -0x8(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x15b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x15b18
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x90e0
jmp 0x15ab2
movq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x159a0
jmp 0x15ac7
leaq -0x88(%rbp), %rdi
callq 0x8600
jmp 0x15ad5
movq $0x1, -0x8(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x15b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8600
jmp 0x15b00
jmp 0x15b18
leaq -0x38(%rbp), %rdi
callq 0x8600
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x8600
jmp 0x15b23
jmp 0x15b25
movq -0x60(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/set.hpp
// Function: ft::set<int, ft::less<int>, std::allocator<int>>::swap(ft::set<int, ft::less<int>, std::allocator<int>>&)
void
		swap(set& rhs)
		{
			// Swao root
			node_pointer tmp_root = this->_root;
			this->_root = rhs._root;
			rhs._root = tmp_root;

			// Swao nil
			node_pointer tmp_nil = this->_nil;
			this->_nil = rhs._nil;
			rhs._nil = tmp_nil;

			// Swao size
			size_type tmp_size = this->_size;
			this->_size = rhs._size;
			rhs._size = tmp_size;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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>>>::get_successor(ft::red_black_tree_node<int>*)
node_pointer
		get_successor(node_pointer node)
		{
			node_pointer successor;

			// If node has a right child, it's successor is the minimum
			// of its right subtree
			if (node->right != _nil)
				return minimum(node->right);

			// If not, we need to go look for it in it's parent right side
			// The successor will be the first node that has its
			// right child that isn't also an ancestor of the base node
			successor = node->parent;
			while (node != _root && node == successor->right)
			{
				node = successor;
				successor = successor->parent;
			}

			// If node is _root then successor is NULL
			return successor;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x15dbd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x15e20
movq %rax, -0x8(%rbp)
jmp 0x15e15
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
je 0x15dee
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x15df7
jmp 0x15e0d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15dc9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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>>>::minimum(ft::red_black_tree_node<int>*) const
node_pointer
		minimum(node_pointer node) const
		{
			if (empty())
				return NULL;

			while (node->left != _nil)
				node = node->left;

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xdcc0
testb $0x1, %al
jne 0x15e43
jmp 0x15e4d
movq $0x0, -0x8(%rbp)
jmp 0x15e77
jmp 0x15e4f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x15e6f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15e4f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x15f6a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x15f6a
movq -0x10(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x15ee7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15fd0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x15f03
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15f41
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x15f2b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x15f3f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x15f41
movq -0x20(%rbp), %rdi
addq $0x21, %rdi
movq -0x10(%rbp), %rsi
callq 0x8aa0
movq -0x20(%rbp), %rdi
addq $0x21, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x8ab0
jmp 0x15fbe
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x15f8f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15d80
movq %rax, -0x18(%rbp)
jmp 0x15fa0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16280
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16320
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15e90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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>>>::get_predecessor(ft::red_black_tree_node<int>*)
node_pointer
		get_predecessor(node_pointer node)
		{
			node_pointer predecessor;

			// If node has a left child, it's predecessor is the maximum
			// of its left subtree
			if (node->left != _nil)
				return maximum(node->left);

			// If not, we need to go look for it in it's parent left side
			// The predecessor will be the first node that has its
			// left child that isn't also an ancestor of the base node
			predecessor = node->parent;
			while (node != _root && node == predecessor->left)
			{
				node = predecessor;
				predecessor = predecessor->parent;
			}

			// If node is _root then successor is NULL
			return predecessor;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x162bd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x16560
movq %rax, -0x8(%rbp)
jmp 0x16315
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
je 0x162ee
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x162f7
jmp 0x1630d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x162c9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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>>>::maximum(ft::red_black_tree_node<int>*) const
node_pointer
		maximum(node_pointer node) const
		{
			if (empty())
				return NULL;

			while (node->right != _nil)
				node = node->right;

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xdcc0
testb $0x1, %al
jne 0x16583
jmp 0x1658d
movq $0x0, -0x8(%rbp)
jmp 0x165b7
jmp 0x1658f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x165af
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1658f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jne 0x18348
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x183e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x18360
movq -0x10(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x18420
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/bidirectional_iterator.hpp
// Function: ft::bidirectional_iterator<ft::red_black_tree_node<int>>::predecessor(ft::red_black_tree_node<int>*)
node_pointer
		predecessor(node_pointer node)
		{
			node_pointer predecessor;

			// If node has a left child, it's predecessor is the maximum
			// of its left subtree
			if (node->left != _nil)
				return maximum(node->left);

			// If not, we need to go look for it in it's parent left side
			// The predecessor will be the first node that has its
			// left child that isn't also an ancestor of the base node
			predecessor = node->parent;
			while (node->parent != NULL && node == predecessor->left)
			{
				node = predecessor;
				predecessor = predecessor->parent;
			}

			// If node is _root then successor is NULL
			if (!predecessor)
				return _nil;
			else
				return predecessor;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x18(%rcx), %rax
je 0x1845d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x183e0
movq %rax, -0x8(%rbp)
jmp 0x184c7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x29(%rbp)
je 0x1848b
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x18494
jmp 0x184aa
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x18469
cmpq $0x0, -0x20(%rbp)
jne 0x184bf
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x184c7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xdcc0
testb $0x1, %al
jne 0x1a6ae
jmp 0x1a6bd
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x1a5f0
jmp 0x1a715
movq -0x48(%rbp), %rdi
callq 0xdc50
movq %rax, %rsi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x9230
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1a260
jmp 0x1a6f1
leaq -0x30(%rbp), %rdi
callq 0x8600
jmp 0x1a715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8600
jmp 0x1a713
jmp 0x1a71f
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110