LLM4Binary/decompile-bench-makefile huggingface dataset:
// 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() const
const_reverse_iterator
		rend() const
		{
			if (empty())
				return rbegin();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x1a89e
jmp 0x1a8ad
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x1a7e0
jmp 0x1a905
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 0x9c80
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1add0
jmp 0x1a8e1
leaq -0x30(%rbp), %rdi
callq 0x9be0
jmp 0x1a905
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9be0
jmp 0x1a903
jmp 0x1a90f
movq -0x50(%rbp), %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>>>::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
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc350
movq -0xb8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc3a0
jmp 0x1d62e
jmp 0x1d630
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9010
testb $0x1, %al
jne 0x1d646
jmp 0x1d75a
movq -0xb8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x90e0
jmp 0x1d675
movq -0xb8(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x88(%rbp), %rsi
callq *%rax
movl %eax, -0xdc(%rbp)
jmp 0x1d694
movq -0xd0(%rbp), %rsi
movq -0xd8(%rbp), %rdi
movl -0xdc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x68(%rbp), %rdx
callq 0x93b0
movb %al, -0xdd(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8600
jmp 0x1d6c8
movb -0xdd(%rbp), %al
testb $0x1, %al
jne 0x1d6d4
jmp 0x1d733
movq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x90e0
jmp 0x1d6e6
movl $0x1, -0x8c(%rbp)
jmp 0x1d776
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1d7a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1d79a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8600
jmp 0x1d731
jmp 0x1d79a
leaq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0xdda0
jmp 0x1d747
leaq -0xb0(%rbp), %rdi
callq 0x8600
jmp 0x1d755
jmp 0x1d630
movq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x90e0
jmp 0x1d76c
movl $0x1, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8600
jmp 0x1d781
leaq -0x38(%rbp), %rdi
callq 0x8600
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x8600
jmp 0x1d7a5
jmp 0x1d7a7
leaq -0x38(%rbp), %rdi
callq 0x8600
jmp 0x1d7b2
jmp 0x1d7b4
movq -0x60(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
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>>>::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
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 0xe1c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1dac1
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xdfe0
jmp 0x1dada
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0x9c80
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xdf90
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xdfe0
jmp 0x1e94f
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xdf90
jmp 0x1e95e
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xdfe0
jmp 0x1e970
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x1ebc0
movb %al, -0xa1(%rbp)
jmp 0x1e990
leaq -0xa0(%rbp), %rdi
callq 0x9be0
jmp 0x1e99e
leaq -0x80(%rbp), %rdi
callq 0x9be0
jmp 0x1e9a9
leaq -0x50(%rbp), %rdi
callq 0x9be0
jmp 0x1e9b4
leaq -0x30(%rbp), %rdi
callq 0x9be0
movb -0xa1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1ea2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1ea21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1ea14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x9be0
jmp 0x1ea12
jmp 0x1ea14
leaq -0x80(%rbp), %rdi
callq 0x9be0
jmp 0x1ea1f
jmp 0x1ea21
leaq -0x50(%rbp), %rdi
callq 0x9be0
jmp 0x1ea2c
jmp 0x1ea2e
leaq -0x30(%rbp), %rdi
callq 0x9be0
jmp 0x1ea39
jmp 0x1ea3b
movq -0x58(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/equal.hpp
// Function: bool ft::equal<ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>)
bool
	equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
	{
		while (first1 != last1)
		{
			if (*first1 != *first2)
				return false;
			first1++;
			first2++;
		}

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x9b50
testb $0x1, %al
jne 0x1eb46
jmp 0x1eb9f
movq -0x78(%rbp), %rdi
callq 0x8bc0
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
callq 0x8bc0
movq %rax, %rcx
movl -0x7c(%rbp), %eax
cmpl (%rcx), %eax
je 0x1eb6d
movb $0x0, -0x1(%rbp)
jmp 0x1eba3
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x9bf0
leaq -0x40(%rbp), %rdi
callq 0x9be0
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
callq 0x9bf0
leaq -0x60(%rbp), %rdi
callq 0x9be0
jmp 0x1eb33
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/lexicographical_compare.hpp
// Function: bool ft::lexicographical_compare<ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<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
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rsi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x9b50
testb $0x1, %al
jne 0x1ec07
jmp 0x1ecb2
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x18370
testb $0x1, %al
jne 0x1ec42
movq -0x78(%rbp), %rdi
callq 0x8bc0
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
callq 0x8bc0
movq %rax, %rcx
movl -0x8c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1ec48
movb $0x0, -0x1(%rbp)
jmp 0x1ecc4
movq -0x88(%rbp), %rdi
callq 0x8bc0
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x90(%rbp)
callq 0x8bc0
movq %rax, %rcx
movl -0x90(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1ec78
movb $0x1, -0x1(%rbp)
jmp 0x1ecc4
jmp 0x1ec7a
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x9bf0
leaq -0x48(%rbp), %rdi
callq 0x9be0
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
xorl %edx, %edx
callq 0x9bf0
leaq -0x68(%rbp), %rdi
callq 0x9be0
jmp 0x1ebee
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x9b50
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/distance.hpp
// Function: ft::iterator_traits<ft::random_access_iterator<int const>>::difference_type ft::distance<ft::random_access_iterator<int const>>(ft::random_access_iterator<int const>, ft::random_access_iterator<int const>)
static typename ft::iterator_traits<InputIterator>::difference_type
	distance(InputIterator first, InputIterator last)
	{

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

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

			return diff;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x78809(%rip), %rdi     # 0x98068
leaq 0x7881a(%rip), %rsi     # 0x98080
callq 0x21b90
testb $0x1, %al
jne 0x1f871
jmp 0x1f89e
movl $0x8, %edi
callq 0x60f0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x21c00
movq -0x58(%rbp), %rdi
movq 0x7972e(%rip), %rsi     # 0x98fc0
movq 0x79757(%rip), %rdx     # 0x98ff0
callq 0x62f0
leaq 0x787c3(%rip), %rsi     # 0x98068
movq %rsi, %rdi
callq 0x21b90
testb $0x1, %al
jne 0x1f8b3
jmp 0x1f8c9
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x21c20
movq %rax, -0x8(%rbp)
jmp 0x1f94f
movq -0x50(%rbp), %rsi
movq $0x0, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21170
movq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x21c50
movb %al, -0x59(%rbp)
jmp 0x1f8f0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x1f91b
jmp 0x1f8f9
leaq -0x28(%rbp), %rdi
callq 0x21140
jmp 0x1f947
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21140
jmp 0x1f945
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x21c80
jmp 0x1f938
leaq -0x40(%rbp), %rdi
callq 0x21140
jmp 0x1f943
jmp 0x1f8de
jmp 0x1f959
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x7845d(%rip), %rax     # 0x98008
movq %rax, (%rdi)
callq 0x20b20
jmp 0x1fbb5
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1fbf7
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0x7a60
jmp 0x1fbda
jmp 0x1fbf7
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
addq $0x10, %rdi
callq 0x7980
jmp 0x1fc12
movq -0x20(%rbp), %rdi
movq $0x0, 0x20(%rdi)
addq $0x10, %rdi
callq 0x7980
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6310
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<Buffer, std::allocator<Buffer>>::push_back(Buffer const&)
void
		push_back(value_type const& val)
		{
			if (empty())
				reserve(1);
			else if (_size == _capacity)
				reserve(_capacity * 2);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x226b0
testb $0x1, %al
jne 0x1fe93
jmp 0x1fea3
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x247b0
jmp 0x1fec3
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
cmpq 0x20(%rcx), %rax
jne 0x1fec1
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rsi
shlq %rsi
callq 0x247b0
jmp 0x1fec3
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
imulq $0x1004, 0x18(%rax), %rax # imm = 0x1004
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x24970
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<Buffer, std::allocator<Buffer>>::swap(ft::vector<Buffer, std::allocator<Buffer>>&)
void
		swap(vector& rhs)
		{
			// Swap start
			pointer tmp_start = _start;
			_start = rhs._start;
			rhs._start = tmp_start;

			// Swap size
			size_type tmp_size = _size;
			_size = rhs._size;
			rhs._size = tmp_size;

			// Swap capacity
			size_type tmp_capacity = _capacity;
			_capacity = rhs._capacity;
			rhs._capacity = tmp_capacity;
		}

// 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 0x18(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x20(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x118(%rbp)
movq -0x18(%rbp), %rsi
movq %rdi, %rdx
addq $0x8, %rdx
callq 0x38410
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x371aa
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x37349
leaq -0x48(%rbp), %rdi
callq 0x38500
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x119(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x6260
jmp 0x371cd
movb -0x119(%rbp), %al
movsbl %al, %esi
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0x38890
jmp 0x371eb
leaq -0x98(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x388c0
jmp 0x37200
movq -0x118(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x38530
jmp 0x37219
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x38900
jmp 0x37228
leaq -0x70(%rbp), %rdi
callq 0x38940
jmp 0x37233
leaq -0x98(%rbp), %rdi
callq 0x380c0
jmp 0x37241
leaq -0xc0(%rbp), %rdi
callq 0x38960
jmp 0x3724f
leaq -0xe0(%rbp), %rdi
callq 0x6130
jmp 0x3725d
leaq -0x110(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38980
jmp 0x3726f
movq -0x108(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x389d0
jmp 0x37331
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x3733c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x37321
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x37311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x37301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x38940
jmp 0x372ff
jmp 0x37301
leaq -0x98(%rbp), %rdi
callq 0x380c0
jmp 0x3730f
jmp 0x37311
leaq -0xc0(%rbp), %rdi
callq 0x38960
jmp 0x3731f
jmp 0x37321
leaq -0xe0(%rbp), %rdi
callq 0x6130
jmp 0x3732f
jmp 0x3733c
leaq -0x48(%rbp), %rdi
callq 0x38940
jmp 0x37349
leaq -0x48(%rbp), %rdi
callq 0x38940
jmp 0x37347
jmp 0x37356
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x20c8b
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x20d2d
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x20d50
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x210a0
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x210d0
jmp 0x20cc4
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x20f10
jmp 0x20cdb
leaq -0x28(%rbp), %rdi
callq 0x21140
jmp 0x20ce6
leaq -0x20(%rbp), %rdi
callq 0x21140
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x20d2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x20d20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21140
jmp 0x20d1e
jmp 0x20d20
leaq -0x20(%rbp), %rdi
callq 0x21140
jmp 0x20d2b
jmp 0x20d37
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x10, %rdi
callq 0x21150
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jbe 0x20e36
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x60f0
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6320
movq -0x78(%rbp), %rdx
leaq 0x51dac(%rip), %rsi     # 0x72b62
leaq -0x30(%rbp), %rdi
callq 0x6250
jmp 0x20dc1
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6350
jmp 0x20dd0
movq -0x80(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x781c1(%rip), %rsi     # 0x98fa0
movq 0x78192(%rip), %rdx     # 0x98f78
callq 0x62f0
jmp 0x20f03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x20e17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6130
jmp 0x20e15
jmp 0x20e17
leaq -0x31(%rbp), %rdi
callq 0x6200
testb $0x1, -0x45(%rbp)
jne 0x20e28
jmp 0x20e31
movq -0x80(%rbp), %rdi
callq 0x6150
jmp 0x20ef2
movq -0x70(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jbe 0x20ee7
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x79d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x20ec2
movq -0x70(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
movq -0x60(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x7a30
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x20e78
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x20ee9
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x20b20
movq -0x68(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x21170
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x21170
jmp 0x20f5c
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1f840
movq %rax, -0x78(%rbp)
jmp 0x20f6f
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x20d50
jmp 0x20f7e
leaq -0x30(%rbp), %rdi
callq 0x21140
jmp 0x20f89
leaq -0x28(%rbp), %rdi
callq 0x21140
movq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x21b50
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x21170
jmp 0x20fae
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x21170
jmp 0x20fbd
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x21190
jmp 0x20fd9
leaq -0x58(%rbp), %rdi
callq 0x21140
jmp 0x20fe4
leaq -0x50(%rbp), %rdi
callq 0x21140
jmp 0x20fef
leaq -0x48(%rbp), %rdi
callq 0x21b80
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21140
jmp 0x21026
jmp 0x21028
leaq -0x28(%rbp), %rdi
callq 0x21140
jmp 0x21033
jmp 0x21084
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2106a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x21140
jmp 0x21068
jmp 0x2106a
leaq -0x50(%rbp), %rdi
callq 0x21140
jmp 0x21075
jmp 0x21077
leaq -0x48(%rbp), %rdi
callq 0x21b80
jmp 0x21082
jmp 0x21084
movq -0x38(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw %cs:(%rax,%rax)
nop
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::get_new_capacity(unsigned long&)
size_type
		get_new_capacity(size_type& projected_size)
		{
			size_type new_capacity;

			// If the vector is empty, the new capcity is the size itself
			if (_capacity == 0)
				return projected_size;

			new_capacity = _capacity;

			while (projected_size > new_capacity)
				new_capacity *= 2;

			return new_capacity;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x21d28
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x21d56
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x21d4e
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x21d34
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/random_access_iterator.hpp
// Function: ft::random_access_iterator<int>::operator=(ft::random_access_iterator<int> const&)
random_access_iterator&
		operator=(random_access_iterator const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			_ptr = rhs._ptr;

			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 0x21d84
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21d96
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2be30
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2be80
jmp 0x3236f
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2be30
jmp 0x3237e
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x2be80
jmp 0x32390
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x326d0
movb %al, -0xa1(%rbp)
jmp 0x323b0
leaq -0xa0(%rbp), %rdi
callq 0x2aa30
jmp 0x323be
leaq -0x80(%rbp), %rdi
callq 0x2aa30
jmp 0x323c9
leaq -0x50(%rbp), %rdi
callq 0x2aa30
jmp 0x323d4
leaq -0x30(%rbp), %rdi
callq 0x2aa30
movb -0xa1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3244e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x32441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x32434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2aa30
jmp 0x32432
jmp 0x32434
leaq -0x80(%rbp), %rdi
callq 0x2aa30
jmp 0x3243f
jmp 0x32441
leaq -0x50(%rbp), %rdi
callq 0x2aa30
jmp 0x3244c
jmp 0x3244e
leaq -0x30(%rbp), %rdi
callq 0x2aa30
jmp 0x32459
jmp 0x3245b
movq -0x58(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rdi, %rdx
addq $0x8, %rdx
callq 0x3a020
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3794d
movq -0x18(%rbp), %rax
addq $0x20, %rax
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x60f0
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6320
movq -0x58(%rbp), %rdx
leaq 0x3b21e(%rip), %rsi     # 0x72b95
leaq -0x38(%rbp), %rdi
callq 0x6250
jmp 0x37982
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x62a0
jmp 0x37991
movq -0x60(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
movq 0x61608(%rip), %rsi     # 0x98fa8
movq 0x615f1(%rip), %rdx     # 0x98f98
callq 0x62f0
jmp 0x37a02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x379d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6130
jmp 0x379d3
jmp 0x379d5
leaq -0x39(%rbp), %rdi
callq 0x6200
testb $0x1, -0x4d(%rbp)
jne 0x379e6
jmp 0x379ef
movq -0x60(%rbp), %rdi
callq 0x6150
jmp 0x379f1
movq -0x48(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::vector(unsigned long, int const&, std::allocator<int> 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x4b4d1(%rip), %rax     # 0x98008
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
movq -0x20(%rbp), %rsi
callq 0x8770
movq -0x40(%rbp), %rdi
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq -0x10(%rbp), %rsi
callq 0x20d50
jmp 0x4cb72
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4cbcc
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x7a30
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4cb7a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7980
jmp 0x4cbde
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6310
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: bool ft::operator<<int, std::allocator<int>>(ft::vector<int, std::allocator<int>> const&, ft::vector<int, std::allocator<int>> const&)
bool
	operator<(vector<T, A> const& lhs, vector<T, A> const& rhs)
	{
		return lexicographical_compare(lhs.begin(),
										lhs.end(),
										rhs.begin(),
										rhs.end());

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x210a0
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x210d0
jmp 0x4f8fc
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x210a0
jmp 0x4f90b
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x210d0
jmp 0x4f91a
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x4f9f0
movb %al, -0x41(%rbp)
jmp 0x4f934
leaq -0x40(%rbp), %rdi
callq 0x21140
jmp 0x4f93f
leaq -0x38(%rbp), %rdi
callq 0x21140
jmp 0x4f94a
leaq -0x20(%rbp), %rdi
callq 0x21140
jmp 0x4f955
leaq -0x18(%rbp), %rdi
callq 0x21140
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x4f9c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x4f9b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x4f9ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21140
jmp 0x4f9aa
jmp 0x4f9ac
leaq -0x38(%rbp), %rdi
callq 0x21140
jmp 0x4f9b7
jmp 0x4f9b9
leaq -0x20(%rbp), %rdi
callq 0x21140
jmp 0x4f9c4
jmp 0x4f9c6
leaq -0x18(%rbp), %rdi
callq 0x21140
jmp 0x4f9d1
jmp 0x4f9d3
movq -0x28(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nopw %cs:(%rax,%rax)
nop
// File: DimitriDaSilva[P]42_ft_containers/containers/utils/reverse_iterator.hpp
// Function: ft::reverse_iterator<ft::random_access_iterator<int>>::operator=(ft::reverse_iterator<ft::random_access_iterator<int>> const&)
reverse_iterator&
		operator=(reverse_iterator const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			_it = rhs._it;

			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 0x51fc8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51fe5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x21d60
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::resize(unsigned long, int)
void
		resize(size_type n, value_type val = value_type())
		{
			// Reduced content to its first n elements
			if (n < _size)
			{
				// We also need to destroy items beyond size
				// Destroy doesn't deallocate item so we don't need to
				// change _capacity (or destroy beyond _size)
				for (size_type i = n; i < _size; i++)
					_allocator.destroy(&_start[i]);
				_size = n;
			}
			else if (n > _size)
			{
				if (n > _capacity)
					reserve(get_new_capacity(n));
				for (size_type i = _size; i < n; i++)
					_allocator.construct(&_start[i], val);
				_size = n;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x555e9
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x555d8
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x7a50
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5559d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x55673
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jbe 0x55671
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jbe 0x5561e
movq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x21d00
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x20d50
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x55665
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq -0x14(%rbp), %rdx
callq 0x7a30
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5562a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x55673
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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>>>>::assign(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
		assign(size_type n, value_type const& val)
		{
			// Destroy existing elements
			clear();

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

			// Setting new elements
			insert(begin(), n, val);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x209d0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x53ca0
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x564a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x64fc0
jmp 0x64746
leaq -0x20(%rbp), %rdi
callq 0x564d0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x564d0
jmp 0x6476c
jmp 0x6476e
movq -0x28(%rbp), %rdi
callq 0x6310
movq %rax, %rdi
callq 0x7110
nop
// File: pokorj54[P]Pathfinder-utilities/src/arithmancy.cpp
// Function: SumDigits(int)
int SumDigits(int n)
{
    while(n > 9)
    {
        int tmp = 0;
        while(n > 0)
        {
            tmp += n % 10;
            n /= 10;
        }
        n = tmp;
    }
    return n;
}

// Assembly:
movl %edi, -0x4(%rsp)
cmpl $0x9, -0x4(%rsp)
jle 0x2e6a
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
jle 0x2e60
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl -0x8(%rsp), %edx
movl %edx, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
jmp 0x2e33
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x2e24
movl -0x4(%rsp), %eax
retq
nop
// File: pokorj54[P]Pathfinder-utilities/src/arithmancy.cpp
// Function: GetDigitalRootOfSpell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int GetDigitalRootOfSpell(const string & spellName)
{
    int root = 0;
    for(char c : spellName)
    {
        if(c >= 'a' && c <= 'z')
        {
            root += LETTERVALUES[c - 'a'];
        }
        else if(c >= 'A' && c <= 'Z')
        {
            root += LETTERVALUES[c - 'A'];
        }
    }
    return SumDigits(root);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x21c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2300
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2f60
testb $0x1, %al
jne 0x2ec1
jmp 0x2f48
leaq 0x18(%rsp), %rdi
callq 0x2fa0
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x61, %eax
jl 0x2f04
movsbl 0xf(%rsp), %eax
cmpl $0x7a, %eax
jg 0x2f04
movsbl 0xf(%rsp), %eax
subl $0x61, %eax
movslq %eax, %rcx
leaq 0x51e9(%rip), %rax      # 0x80e0
movl (%rax,%rcx,4), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x2f37
movsbl 0xf(%rsp), %eax
cmpl $0x41, %eax
jl 0x2f35
movsbl 0xf(%rsp), %eax
cmpl $0x5a, %eax
jg 0x2f35
movsbl 0xf(%rsp), %eax
subl $0x41, %eax
movslq %eax, %rcx
leaq 0x51b6(%rip), %rax      # 0x80e0
movl (%rax,%rcx,4), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x2f37
jmp 0x2f39
leaq 0x18(%rsp), %rdi
callq 0x2fb0
jmp 0x2ea9
movl 0x2c(%rsp), %edi
callq 0x2e20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pokorj54[P]Pathfinder-utilities/src/dices.cpp
// Function: DiceRoller::RollDices(std::__cxx11::list<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
RollResult DiceRoller::RollDices(const list<pair<int, int>> & dices)
{
    RollResult rollResult;
    for(pair<int, int> group : dices)
    {
        for(int i = 0; i < group.first; ++i)
        {
            rollResult.AddDiceResult(RollDice(group.second));
        }
    }
    return rollResult;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x3090
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x38c0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x38f0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3920
testb $0x1, %al
jne 0x336a
jmp 0x33f8
leaq 0x58(%rsp), %rdi
callq 0x3940
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x33e7
movq 0x20(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x3290
movq %rax, 0x8(%rsp)
jmp 0x33a3
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x3c(%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x30c0
jmp 0x33be
jmp 0x33c0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3384
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x3990
jmp 0x341b
jmp 0x33e9
leaq 0x58(%rsp), %rdi
callq 0x3970
jmp 0x3352
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x340e
movq 0x10(%rsp), %rdi
callq 0x3990
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: pokorj54[P]Pathfinder-utilities/src/dices.cpp
// Function: DiceRoller::ParseDiceString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RollResult DiceRoller::ParseDiceString(const std::string & diceString)
{
    RollResult rollResult;
    stringstream ss(diceString);
    int amount, sides;
    ss >> amount;
    while(!ss.fail())
    {
        char c = 0;
        ss >> c;
        if(c == 'd')
        {
            ss >> sides;
            for(int i = 0; i < amount; ++i)
            {
                rollResult.AddDiceResult(RollDice(sides));
            }
            ss >> c;
        }
        else
        {
            rollResult.AddModifier(amount);
        }
        ss >> amount;
    }
    return rollResult;
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x1ef(%rsp)
callq 0x3090
movq 0x1f0(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x39a0
movl %eax, 0x38(%rsp)
jmp 0x3498
movl 0x38(%rsp), %edx
movq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x2280
jmp 0x34ad
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2120
jmp 0x34be
jmp 0x34c0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x60(%rsp,%rax), %rdi
callq 0x2030
movb %al, 0x17(%rsp)
jmp 0x34d9
movb 0x17(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x34e8
jmp 0x35d2
movb $0x0, 0x4b(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x4b(%rsp), %rsi
callq 0x2220
jmp 0x34fe
movsbl 0x4b(%rsp), %eax
cmpl $0x64, %eax
jne 0x35ae
leaq 0x60(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x2120
jmp 0x351d
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x359b
movq 0x28(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x3290
movq %rax, 0x8(%rsp)
jmp 0x3544
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x3c(%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x30c0
jmp 0x355f
jmp 0x3561
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3525
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x3605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2170
jmp 0x3605
leaq 0x60(%rsp), %rdi
leaq 0x4b(%rsp), %rsi
callq 0x2220
jmp 0x35ac
jmp 0x35bc
movq 0x18(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x3100
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2120
jmp 0x35cd
jmp 0x34c0
movb $0x1, 0x1ef(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2170
testb $0x1, 0x1ef(%rsp)
jne 0x35f8
movq 0x18(%rsp), %rdi
callq 0x3990
movq 0x20(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x18(%rsp), %rdi
callq 0x3990
movq 0x58(%rsp), %rdi
callq 0x22e0
nopl (%rax)
// File: tap3edit[P]tap3xml/nrt2xml.cpp
// Function: help()
void help()
{
    cerr << "Copyright (C) 2005-2018 Javier Gutierrez <https://github.com/tap3edit>\n";
    cerr << "Usage: nrt2xml -x|-a inputfile [outputfile]\n";
    cerr << "  -x: ASN -> XML\n";
    cerr << "  -a: XML -> ASN\n";
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2a22d(%rip), %rdi     # 0x30fe8
leaq 0x1d3eb(%rip), %rsi     # 0x241ad
callq 0x4340
movq 0x2a21a(%rip), %rdi     # 0x30fe8
leaq 0x1d420(%rip), %rsi     # 0x241f5
callq 0x4340
movq 0x2a207(%rip), %rdi     # 0x30fe8
leaq 0x1d43a(%rip), %rsi     # 0x24222
callq 0x4340
movq 0x2a1f4(%rip), %rdi     # 0x30fe8
leaq 0x1d439(%rip), %rsi     # 0x24234
callq 0x4340
movl $0x1, %edi
callq 0x4470
nopw (%rax,%rax)