LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::swap_nodes(ft::red_black_tree_node<int>*, ft::red_black_tree_node<int>*)
void
		swap_nodes(node_pointer a, node_pointer b)
		{
			node_type		tmp = *b;
			node_pointer	old_root = _root;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rdx), %r8
movq 0x10(%rdx), %rcx
movq 0x18(%rdx), %rax
leaq 0x8(%rdi), %r9
movq 0x8(%rdi), %r10
cmpq %rsi, %r10
je 0xd30c
movq 0x8(%rsi), %r11
cmpq %rsi, 0x10(%r11)
je 0xd318
cmpq %rsi, 0x18(%r11)
jne 0xd31c
movq %rdx, 0x18(%r11)
jmp 0xd31c
movq %rdx, (%r9)
movq 0x8(%rsi), %r11
movq %rdx, %rbx
jmp 0xd31f
movq %rdx, 0x10(%r11)
movq %r10, %rbx
movq %r11, 0x8(%rdx)
xorq %rbx, %r10
xorq %rdx, %rbx
orq %r10, %rbx
je 0xd344
cmpq %rdx, 0x10(%r8)
je 0xd340
cmpq %rdx, 0x18(%r8)
jne 0xd347
leaq 0x18(%r8), %r9
jmp 0xd344
leaq 0x10(%r8), %r9
movq %rsi, (%r9)
movq %r8, 0x8(%rsi)
movq 0x10(%rsi), %r8
movq %r8, 0x10(%rdx)
movq 0x10(%rdi), %rdi
cmpq %rdi, %r8
je 0xd360
movq %rdx, 0x8(%r8)
movq 0x18(%rsi), %r8
movq %r8, 0x18(%rdx)
cmpq %rdi, %r8
je 0xd371
movq %rdx, 0x8(%r8)
movq %rcx, 0x10(%rsi)
cmpq %rdi, %rcx
je 0xd37e
movq %rsi, 0x8(%rcx)
movq %rax, 0x18(%rsi)
cmpq %rdi, %rax
je 0xd38b
movq %rsi, 0x8(%rax)
movl 0x20(%rdx), %eax
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdx)
movl %eax, 0x20(%rsi)
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/bidirectional_iterator.hpp
// Function: ft::bidirectional_iterator<ft::red_black_tree_node<int>>::operator--()
bidirectional_iterator&
		operator--()
		{
			if (_ptr == _nil)
				_ptr = maximum(_root);
			else
				_ptr = predecessor(_ptr);

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rcx
cmpq %rcx, %rdx
je 0xe6b4
movq 0x10(%rdx), %rdi
cmpq %rcx, %rdi
je 0xe6a6
movq %rdi, %rsi
movq 0x18(%rdi), %rdi
cmpq %rcx, %rdi
jne 0xe68f
jmp 0xe6c4
cmpq 0x10(%rsi), %rdx
movq %rsi, %rdx
jne 0xe6c4
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
jne 0xe69d
movq %rcx, %rsi
jmp 0xe6c4
movq 0x10(%rax), %rcx
movq %rcx, %rsi
movq 0x18(%rcx), %rcx
cmpq %rdx, %rcx
jne 0xe6b8
movq %rsi, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::lower_bound(int const&)
iterator
		lower_bound(key_type const& k)
		{
			iterator begin = this->begin();
			iterator end = this->end();

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

			return end;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
cmpq $0x0, 0x18(%rsi)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
je 0x10d09
movq %rsi, %rbx
movq %r15, %rax
movq %rax, %r14
movq 0x10(%rax), %rax
cmpq %r12, %rax
jne 0x10c42
movq %r12, %rdx
cmpq %r12, %r14
je 0x10d0b
leaq 0x3638f(%rip), %r13     # 0x46ff0
movq %r13, -0x78(%rbp)
movq %r14, -0x70(%rbp)
movq %r15, -0x68(%rbp)
movq %r12, -0x60(%rbp)
movq (%rbx), %rax
movq %rbx, %rdi
leaq -0x78(%rbp), %rsi
callq *0x18(%rax)
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
cmpl %eax, %ecx
jl 0x10d34
movq %r13, -0x58(%rbp)
movq %r14, -0x50(%rbp)
movq %r15, %r13
movq %r15, -0x48(%rbp)
movq %r12, -0x40(%rbp)
movq (%rbx), %rax
movq %rbx, %rdi
leaq -0x58(%rbp), %rsi
movl %ecx, %r15d
callq *0x18(%rax)
cmpl %eax, %r15d
je 0x10d39
cmpq %r12, %r14
je 0x10ceb
movq 0x18(%r14), %rcx
cmpq %r12, %rcx
movq %r13, %r15
je 0x10cd7
movq %rcx, %rax
movq 0x10(%rcx), %rcx
cmpq %r12, %rcx
jne 0x10cc9
jmp 0x10cf1
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x10d04
cmpq 0x18(%rax), %r14
movq %rax, %r14
je 0x10cd7
jmp 0x10cf1
movq %r14, %rax
movq %r13, %r15
movq %rax, %r14
cmpq %r12, %rax
leaq 0x362f2(%rip), %r13     # 0x46ff0
jne 0x10c61
movq %r12, %rdx
jmp 0x10d0b
xorl %edx, %edx
leaq 0x362de(%rip), %rcx     # 0x46ff0
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r12, 0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdx
jmp 0x10d0b
movq %r14, %rdx
movq %r13, %r15
jmp 0x10d0b
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::upper_bound(int const&)
iterator
		upper_bound(key_type const& k)
		{
			iterator begin = this->begin();
			iterator end = this->end();

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

			return end;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r12
je 0x10df3
movq %rsi, %r15
movq %r13, %rax
movq %rax, %r14
movq 0x10(%rax), %rax
cmpq %r12, %rax
jne 0x10d73
movq %r12, %rax
cmpq %r12, %r14
je 0x10df5
leaq 0x36262(%rip), %rax     # 0x46ff0
movq %rax, -0x50(%rbp)
movq %r14, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movq %r12, -0x38(%rbp)
movq (%r15), %rax
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
callq *0x18(%rax)
movq -0x30(%rbp), %rcx
cmpl %eax, (%rcx)
jl 0x10e1d
cmpq %r12, %r14
je 0x10de3
movq 0x18(%r14), %rcx
cmpq %r12, %rcx
je 0x10dcf
movq %rcx, %rax
movq 0x10(%rcx), %rcx
cmpq %r12, %rcx
jne 0x10dc1
jmp 0x10de6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x10dee
cmpq 0x18(%rax), %r14
movq %rax, %r14
je 0x10dcf
jmp 0x10de6
movq %r14, %rax
movq %rax, %r14
cmpq %r12, %rax
jne 0x10d87
movq %r12, %rax
jmp 0x10df5
xorl %eax, %eax
leaq 0x361f4(%rip), %rcx     # 0x46ff0
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
jmp 0x10df5
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/set.hpp
// Function: bool ft::operator<<int, ft::less<int>, std::allocator<int>>(ft::set<int, ft::less<int>, std::allocator<int>> const&, ft::set<int, ft::less<int>, std::allocator<int>> const&)
bool
	operator<(set<T, Compare, Alloc> const& lhs, set<T, Compare, Alloc> const& rhs)
	{
		return lexicographical_compare(lhs.begin(),
										lhs.end(),
										rhs.begin(),
										rhs.end());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
cmpq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
je 0x1191c
movq %rcx, %rax
movq %rax, %r8
movq 0x10(%rax), %rax
cmpq %rdx, %rax
jne 0x1190b
movq %rdx, %rdi
jmp 0x11921
xorl %edi, %edi
xorl %r8d, %r8d
leaq 0x359e8(%rip), %rax     # 0x47310
movq %rax, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
cmpq $0x0, 0x18(%rsi)
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
je 0x1196b
movq %rdi, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
jne 0x1195a
movq %rsi, %r8
jmp 0x11970
xorl %r8d, %r8d
xorl %ecx, %ecx
leaq -0x80(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
movq %rsi, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq %r8, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11a4a
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/equal.hpp
// Function: bool ft::equal<ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>, ft::bidirectional_iterator<ft::red_black_tree_node<int> const>)
bool
	equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
	{
		while (first1 != last1)
		{
			if (*first1 != *first2)
				return false;
			first1++;
			first2++;
		}

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
je 0x119f4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rax), %eax
movq 0x8(%rbx), %rcx
cmpl (%rcx), %eax
sete %r12b
jne 0x119f7
movq %r15, %rdi
callq 0x11a04
movq %rbx, %rdi
callq 0x11a04
movq 0x8(%r15), %rax
cmpq 0x8(%r14), %rax
jne 0x119ca
jmp 0x119f7
movb $0x1, %r12b
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/lexicographical_compare.hpp
// Function: bool ft::lexicographical_compare<ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>>(ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>, ft::bidirectional_iterator<ft::red_black_tree_node<ft::pair<char const, int>> const>)
bool
	lexicographical_compare(InputIterator1 first1,
							InputIterator1 last1,
							InputIterator2 first2,
							InputIterator2 last2)
	{
		// Parse 1st container
		while (first1 != last1)
		{
			// Return false if reach end of 2nd container or
			// if 2nd elem < 1st elem
			if (first2 == last2 || *first2 < *first1)
				return false;
			// Return true if 1st elem < 2nd elem
			else if (*first1 < *first2)
				return true;
			first1++;
			first2++;
		}
		// Reached end of 1st container

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
je 0x17ff0
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
je 0x17ffd
movb (%rdx), %al
movb (%rcx), %sil
cmpb %sil, %al
jl 0x17ffd
movb $0x1, %al
jg 0x17fff
movl 0x4(%rdx), %esi
cmpl 0x4(%rcx), %esi
jl 0x17ffd
movl 0x4(%rcx), %ecx
cmpl 0x4(%rdx), %ecx
jl 0x17fff
movq %r12, %rdi
callq 0x17f3c
movq %r14, %rdi
callq 0x17f3c
movq 0x8(%r12), %rcx
cmpq 0x8(%r15), %rcx
jne 0x17fad
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
setne %al
jmp 0x17fff
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::~vector()
virtual
		~vector()
		{
			clear();
			if (_capacity != 0)
				_allocator.deallocate(_start, _capacity);
			_capacity = 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x350a0(%rip), %rax     # 0x47370
movq %rax, (%rdi)
cmpq $0x0, 0x18(%rdi)
je 0x122e2
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x122f2
movq 0x8(%rbx), %rdi
callq 0x5190
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
		push_back(value_type const& val)
		{
			if (empty())
				reserve(1);
			else if (_size == _capacity)
				reserve(_capacity * 2);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x30ab3
cmpq 0x20(%rbx), %rsi
jne 0x30ac0
addq %rsi, %rsi
jmp 0x30ab8
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27124
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x71e4
incq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: ft::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<char>, std::allocator<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::operator[](char const&)
mapped_type&
		operator[] (key_type const& k)
		{
			node_pointer position = this->find_helper(k, this->_root);

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

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

				iterator it = pr.first;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rdx
callq 0x1a672
movq %rax, %r15
testq %rax, %rax
jne 0x19fa5
movb (%rbx), %al
leaq -0x88(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq -0x48(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x71e4
movb -0x50(%rbp), %al
leaq -0x70(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x71e4
leaq -0xc0(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x1a6d2
movq -0xb8(%rbp), %r15
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x19f86
callq 0x5190
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x19f94
callq 0x5190
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x19fa5
callq 0x5190
addq $0x8, %r15
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x19fd4
callq 0x5190
jmp 0x19fd4
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x19fe7
callq 0x5190
jmp 0x19fe7
movq %rax, %r14
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x19ff8
callq 0x5190
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::operator=(ft::vector<int, std::allocator<int>> const&)
vector&
		operator=(vector const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			this->~vector();

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

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

			return *this;
		}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
shrq $0x3a, %rax
jne 0x271cb
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x20(%rdi)
jae 0x271bc
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2724a
movq %rax, %r15
movq 0x18(%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x271a4
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq (%r15,%r13), %rdi
movq 0x8(%r14), %rax
leaq (%r15,%r13), %rcx
addq $0x10, %rcx
movq %rcx, (%r15,%r13)
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
addq %rsi, %rdx
callq 0x71e4
incq %r12
addq $0x20, %r13
cmpq 0x18(%r14), %r12
jb 0x27172
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, 0x8(%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r14)
movq %rbx, 0x20(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x50e0
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xe92b(%rip), %rsi      # 0x35b12
leaq 0xe956(%rip), %rdx      # 0x35b44
leaq -0x50(%rbp), %rdi
callq 0x5fc8
movb $0x1, %r12b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r12d, %r12d
movq 0x20db8(%rip), %rsi     # 0x47fc8
movq 0x20d99(%rip), %rdx     # 0x47fb0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x27230
callq 0x5190
testb %r12b, %r12b
jne 0x2723a
jmp 0x27242
movq %rax, %r14
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: void ft::vector<int, std::allocator<int>>::assign<ft::random_access_iterator<int const>>(ft::random_access_iterator<int const>, ft::random_access_iterator<int const>, ft::enable_if<!ft::is_integral<ft::random_access_iterator<int const>>::value, ft::random_access_iterator<int const>>::type*)
void
		assign(InputIterator first,
				InputIterator last,
				typename ft::enable_if<!ft::is_integral<InputIterator>::value,
					InputIterator>::type* = NULL)
		{
			// Destroy existing elements
			clear();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x12891
movq $0x0, 0x18(%rbx)
movq (%r14), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x12778
movq 0x8(%rbx), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq (%r15), %rax
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
movq (%r14), %rax
leaq -0x20(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x128f6
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: bool ft::operator<<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>>(ft::map<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>> const&, ft::map<char, int, ft::less<char>, std::allocator<ft::pair<char const, int>>> const&)
bool
	operator<(map<Key, T, Compare, Alloc> const& lhs, map<Key, T, Compare, Alloc> const& rhs)
	{
		return lexicographical_compare(lhs.begin(),
										lhs.end(),
										rhs.begin(),
										rhs.end());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
cmpq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
je 0x17e3f
movq %rcx, %rax
movq %rax, %r8
movq 0x10(%rax), %rax
cmpq %rdx, %rax
jne 0x17e2e
movq %rdx, %rdi
jmp 0x17e44
xorl %edi, %edi
xorl %r8d, %r8d
leaq 0x2f8cd(%rip), %rax     # 0x47718
movq %rax, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
cmpq $0x0, 0x18(%rsi)
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
je 0x17e8e
movq %rdi, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
jne 0x17e7d
movq %rsi, %r8
jmp 0x17e93
xorl %r8d, %r8d
xorl %ecx, %ecx
leaq -0x80(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
movq %rsi, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq %r8, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17f8c
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/map.hpp
// Function: ft::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<ft::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mapped_type&
		at(key_type const& k)
		{
			node_pointer position = this->find_helper(k, this->_root);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rdi), %rdx
callq 0x1af2e
testq %rax, %rax
je 0x1a236
addq $0x20, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x50e0
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b8f3(%rip), %rsi     # 0x35b45
leaq 0x1b903(%rip), %rdx     # 0x35b5c
leaq -0x40(%rbp), %rdi
callq 0x5fc8
movb $0x1, %r12b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x5240
xorl %r12d, %r12d
movq 0x2dd55(%rip), %rsi     # 0x47fd0
movq 0x2dd3e(%rip), %rdx     # 0x47fc0
movq %rbx, %rdi
callq 0x52d0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1a29b
callq 0x5190
testb %r12b, %r12b
jne 0x1a2a5
jmp 0x1a2ad
movq %rax, %r14
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::vector(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
explicit
		vector(size_type n,
				value_type const& val = value_type(),
				allocator_type const& alloc = allocator_type()) :
			_start(NULL),
			_allocator(alloc),
			_size(0),
			_capacity(0)
		{
			reserve(n);

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

			_size = n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x203f0(%rip), %rax     # 0x47340
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
callq 0x27124
testq %r12, %r12
je 0x26fa5
xorl %r13d, %r13d
movq %r12, %rbx
movq 0x8(%r15), %rdi
leaq (%rdi,%r13), %rax
addq $0x10, %rax
addq %r13, %rdi
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x71e4
addq $0x20, %r13
decq %rbx
jne 0x26f7a
movq -0x30(%rbp), %rax
movq %r12, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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>>>>::resize(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r12
cmpq %rsi, %r12
jbe 0x28281
movq %rbx, %r15
shlq $0x5, %r15
orq $0x10, %r15
movq %rbx, %r13
movq 0x8(%r14), %rax
movq -0x10(%rax,%r15), %rdi
addq %r15, %rax
cmpq %rdi, %rax
je 0x2826f
callq 0x5190
movq 0x18(%r14), %r12
incq %r13
addq $0x20, %r15
cmpq %r12, %r13
jb 0x28255
movq %rbx, 0x18(%r14)
jmp 0x282e7
jae 0x282e7
movq %rdx, %r15
movq 0x20(%r14), %rax
cmpq %rbx, %rax
jae 0x282ae
movq %rbx, %rsi
testq %rax, %rax
je 0x282a2
movq %rax, %rsi
addq %rax, %rax
cmpq %rbx, %rsi
jb 0x28297
movq %r14, %rdi
callq 0x27124
movq 0x18(%r14), %r12
movq %rbx, %r13
subq %r12, %r13
jbe 0x2827b
shlq $0x5, %r12
movq 0x8(%r14), %rdi
leaq (%rdi,%r12), %rax
addq $0x10, %rax
addq %r12, %rdi
movq %rax, -0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x71e4
addq $0x20, %r12
decq %r13
jne 0x282ba
jmp 0x2827b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::vector<ft::random_access_iterator<int>>(ft::random_access_iterator<int>, ft::random_access_iterator<int>, std::allocator<int> const&, ft::enable_if<!ft::is_integral<ft::random_access_iterator<int>>::value, ft::random_access_iterator<int>>::type*)
vector(InputIterator first,
				InputIterator last,
				allocator_type const& alloc = allocator_type(),
				typename ft::enable_if<!ft::is_integral<InputIterator>::value,
										InputIterator>::type* = NULL) :
			_start(NULL),
			_allocator(alloc),
			_size(0),
			_capacity(0)
		{
			reserve(ft::distance(first, last));

			for (iterator it_arg = first; it_arg != last; it_arg++)
			{
				_allocator.construct(_start + _size, *it_arg);
				_size++;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1d8d6(%rip), %rax     # 0x47370
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq (%rdx), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
callq 0x12778
movq (%r15), %rax
movq (%r14), %rcx
cmpq %rcx, %rax
je 0x29ae8
leaq 0x18(%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
movl (%rax), %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x29ad2
movq %rsi, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::assign(unsigned long, int 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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x2ff90
movq $0x0, 0x18(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x12778
movq 0x8(%r15), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30408
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>>>>::erase(ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
iterator
		erase(iterator position)
		{
			// Destroy the element at position
			_allocator.destroy(&*position);

			// Offset all the elements by one to fill the gap
			for (iterator it = position; it + 1 != end(); it++)
			{
				_allocator.construct(&*it, *(it + 1));
				_allocator.destroy(&*(it + 1));
			}

			_size--;

			return position;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq (%rax), %rdi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdi
je 0x30939
callq 0x5190
movq (%r15), %rax
leaq 0x20(%rax), %r12
movq 0x18(%r14), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
addq 0x8(%r14), %rdx
cmpq %rdx, %r12
je 0x3099f
leaq -0x20(%r12), %rdi
leaq -0x10(%r12), %rax
movq %rax, -0x20(%r12)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x71e4
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rdi, %rax
je 0x30984
callq 0x5190
addq $0x20, %r12
movq 0x18(%r14), %rcx
movq %rcx, %rax
shlq $0x5, %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x30951
movq (%r15), %rax
decq %rcx
movq %rcx, 0x18(%r14)
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>>>>::erase(ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
iterator
		erase(iterator first, iterator last)
		{
			difference_type	distance = ft::distance(first, last);
			iterator save_first = first;

			// Destroy the range of elements
			while (first != last)
				_allocator.destroy(&*first++);

			// Offset all the elements by distance to fill the gap
			for (iterator it = save_first; it + distance != end(); it++)
			{
				_allocator.construct(&*it, *(it + distance));
				_allocator.destroy(&*(it + distance));
			}

			_size -= distance;

			return save_first;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdx), %r15
movq (%rcx), %r14
movq %r14, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %r15, (%rdi)
subq %r15, %r14
je 0x30a0f
movq %rcx, %r12
movq %rdx, %r13
movq %r15, %rcx
leaq 0x20(%rcx), %rax
movq %rax, (%r13)
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x30a06
callq 0x5190
movq (%r13), %rax
movq %rax, %rcx
cmpq (%r12), %rax
jne 0x309e9
movq 0x18(%rbx), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, -0x30(%rbp)
je 0x30a73
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq (%r15,%r14), %r12
addq $0x10, %r12
movq -0x10(%r12), %rsi
movq -0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x71e4
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x30a57
callq 0x5190
addq $0x20, %r15
movq 0x18(%rbx), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%rbx), %rcx
addq $0x10, %r12
cmpq %rcx, %r12
jne 0x30a24
sarq $0x5, %r14
subq %r14, %rax
movq %rax, 0x18(%rbx)
movq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yy_stack_print(short*, short*)
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18967(%rip), %r12     # 0x1cfd0
movq (%r12), %rcx
leaq 0x11c8b(%rip), %rdi     # 0x162ff
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x45e0
cmpq %rbx, %r14
ja 0x46a6
leaq 0x11c7e(%rip), %r15     # 0x16309
movswl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4470
addq $0x2, %r14
cmpq %rbx, %r14
jbe 0x468b
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq 0x16a34(%rip), %rbx     # 0x1cff0
leaq 0xebea(%rip), %rsi      # 0x151ad
movq %rbx, %rdi
callq 0x42b0
leaq 0xec23(%rip), %rsi      # 0x151f5
movq %rbx, %rdi
callq 0x42b0
leaq 0xec41(%rip), %rsi      # 0x15222
movq %rbx, %rdi
callq 0x42b0
leaq 0xec44(%rip), %rsi      # 0x15234
movq %rbx, %rdi
callq 0x42b0
movl $0x1, %edi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/nrt2xml.cpp
// Function: get_specfilename[abi:cxx11](NrtInfo*)
string get_specfilename(NrtInfo *nrtinfo)
{
    ostringstream    spec_filename;

    spec_filename << nrtinfo->type();
    spec_filename << setw(2) << setfill('0') << nrtinfo->version();
    spec_filename << setw(2) << setfill('0') << nrtinfo->release();
    spec_filename << ".asn";

    return get_specdir(spec_filename.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4420
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7b06
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x4340
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x665a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x6697
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x7afe
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x66f0
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x7b02
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
leaq 0xe966(%rip), %rsi      # 0x15079
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
callq 0x4340
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x44e0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x67db
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6750
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x16869(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x67a1
jmp 0x67b5
jmp 0x67b2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x67b5
jmp 0x67b2
movq %rax, %rbx
movq 0x16804(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/nrt2xml.cpp
// Function: get_specdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string get_specdir(const string &filename)
{

    vector<string>::iterator    vii;
    FILE *tmp;

    for (vii=specdir_list.begin();vii!=specdir_list.end();vii++)
    {
        if ((tmp=fopen(((*vii)+"/"+filename).c_str(),"rb")) != NULL)
        {
            fclose(tmp);
            return ((*vii)+"/"+filename);
        }
    }

    return string (filename);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq 0x16b88(%rip), %r12     # 0x1d380
cmpq 0x16b89(%rip), %r12     # 0x1d388
je 0x68e0
leaq 0x38(%rsp), %r13
leaq 0x10(%rsp), %rbx
leaq 0x28(%rsp), %r15
movq %r13, 0x28(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6c00
movq %r15, %rdi
leaq 0x10982(%rip), %rsi     # 0x171b9
callq 0x45d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x40f0
movq %rbx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x686c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6872
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
leaq 0xe9b1(%rip), %rsi      # 0x15246
callq 0x4360
movq %rax, %rbp
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x68b3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x68ca
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
testq %rbp, %rbp
jne 0x6903
addq $0x20, %r12
cmpq 0x16aae(%rip), %r12     # 0x1d388
jne 0x6814
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6c00
jmp 0x699d
movq %rbp, %rdi
callq 0x42c0
movq %rsp, %r15
movq %rbx, (%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6c00
leaq 0x1088d(%rip), %rsi     # 0x171b9
movq %r15, %rdi
callq 0x45d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rsp, %rdi
callq 0x40f0
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rdx
movq %rdx, (%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x696a
movq %rsi, (%r15)
movq (%rcx), %rdx
movq %rdx, 0x10(%r15)
jmp 0x6970
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x699d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x69b1
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x69e0
movq 0x10(%rsp), %rsi
jmp 0x69d8
jmp 0x69c6
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x69e0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yytnamerr(char*, char const*)
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYSIZE_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            /* Fall through.  */
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (! yyres)
    return yystrlen (yystr);

  return yystpcpy (yyres, yystr) - yyres;
}

// Assembly:
cmpb $0x22, (%rsi)
jne 0xa044
xorl %eax, %eax
movq %rsi, %r8
leaq 0x1(%r8), %rdx
movb 0x1(%r8), %cl
movzbl %cl, %r9d
cmpl $0x5b, %r9d
jle 0xa022
cmpl $0x5c, %r9d
jne 0xa034
cmpb $0x5c, 0x2(%r8)
jne 0xa044
addq $0x2, %r8
movq %r8, %rdx
jmp 0xa034
cmpl $0x22, %r9d
je 0xa077
cmpl $0x27, %r9d
je 0xa044
cmpl $0x2c, %r9d
je 0xa044
testq %rdi, %rdi
je 0xa03c
movb %cl, (%rdi,%rax)
incq %rax
movq %rdx, %r8
jmp 0x9ffa
testq %rdi, %rdi
je 0xa061
movq $-0x1, %rax
movb 0x1(%rsi,%rax), %cl
movb %cl, 0x1(%rdi,%rax)
incq %rax
testb %cl, %cl
jne 0xa050
jmp 0xa076
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xa068
retq
testq %rdi, %rdi
je 0xa076
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: bcd2dec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2dec(const string &str)
{
    ostringstream value_str;
    unsigned long long value=0;
    /* int sign; */

    string::const_iterator cii;

    /* sign=str.at(0)>>7 ? -1 : 1; */

    for (cii=str.begin();cii!=str.end();cii++)
    {
        value<<=8;
        value+=(int)(uchar)*cii;
        
    }

    /* We'll skip there's no sign on TAP/NRT
    if (sign == -1)
        value-=(int)(0x01<<(8*str.size()));

    */

    value_str << value;

    return value_str.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc559
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
shlq $0x8, %rsi
movzbl (%rcx,%rdx), %edi
orq %rdi, %rsi
incq %rdx
cmpq %rdx, %rax
jne 0xc544
jmp 0xc55b
xorl %esi, %esi
movq %rsp, %rdi
callq 0x41c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x10a49(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10a1f(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: dec2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string dec2bcd(const string &str)
{
    ostringstream bcd, rbcd;
    unsigned long long intstr, msb;
    string bcd_str;


    /* Note: For the moment we will not support numbers bigger than 2**31 */

    intstr=atoll(str.c_str());

    do
    {

        bcd << (uchar)(intstr&0xFF);
        msb=intstr&0x80;
        intstr>>=8;
        
    } while (intstr>0);

    if (msb && ( atoll(str.c_str()) > 0))
        bcd << (uchar)0x00;

    if (!msb && ( atoll(str.c_str()) < 0))
        bcd << (uchar)0xFF;

    bcd_str=bcd.str();
    
    string::reverse_iterator rii=bcd_str.rbegin();
    while (rii!=bcd_str.rend())
    {
        rbcd << *rii++;
    }

    return rbcd.str();
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4420
leaq 0x1c0(%rsp), %rdi
callq 0x4420
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq (%r14), %rdi
callq 0x4230
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rax, %rbp
movb %bpl, 0x8(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4340
movq %rbp, %rax
shrq $0x8, %rax
cmpq $0xff, %rbp
ja 0xc611
movq (%r14), %rdi
callq 0x4230
cmpq $0x80, %rbp
jae 0xc668
testq %rax, %rax
jns 0xc684
leaq 0x8(%rsp), %rsi
movb $-0x1, (%rsi)
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x4340
jmp 0xc684
testq %rax, %rax
jle 0xc684
leaq 0x8(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x4340
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x43a0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc6bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rsp), %r12
testq %r12, %r12
je 0xc6fe
addq 0x28(%rsp), %r12
leaq 0x1c0(%rsp), %r14
leaq 0x8(%rsp), %r15
movb -0x1(%r12), %al
movb %al, 0x8(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4340
decq %r12
cmpq 0x28(%rsp), %r12
jne 0xc6db
leaq 0x1c8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xc725
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x10894(%rip), %r14     # 0x1cfc0
leaq 0x1c0(%rsp), %rdi
movq %r14, %rsi
callq 0x4170
leaq 0x230(%rsp), %rdi
callq 0x4100
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4170
leaq 0xb8(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc785
jmp 0xc785
jmp 0xc785
movq %rax, %rbx
jmp 0xc7c0
jmp 0xc785
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xc79f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x1081a(%rip), %rsi     # 0x1cfc0
leaq 0x1c0(%rsp), %rdi
callq 0x4170
leaq 0x230(%rsp), %rdi
callq 0x4100
movq 0x107f9(%rip), %rsi     # 0x1cfc0
leaq 0x48(%rsp), %rdi
callq 0x4170
leaq 0xb8(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: bcd2hexa(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2hexa(const string &str)
{

    ostringstream value;


    string::const_iterator cii;
    for (cii=str.begin();cii!=str.end();cii++)
    {
        value << hex << setw(2) << setfill('0') << (int)(uchar)*cii;
    }


    return value.str();

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4420
cmpq $0x0, 0x8(%r14)
je 0xc88b
movq (%r14), %r13
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x20(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x20(%rsp,%rcx)
movq -0x18(%rax), %rcx
movq $0x2, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
addq $0x8, %r12
cmpb $0x0, 0xe1(%r12)
jne 0xc866
movq %r12, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movzbl (%r13), %esi
movq %r15, %rdi
callq 0x4560
incq %r13
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r13
jne 0xc815
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x10721(%rip), %rsi     # 0x1cfc0
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc8c9
movq %rax, %rbx
movq 0x106ed(%rip), %rsi     # 0x1cfc0
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590