LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_lower_bound()
void
test_set_operations_lower_bound()
{
	ft::set<int> set;
	//ft::set<int>::iterator it;
	ft::set<int>::const_iterator const_it;

	for (int i = 0; i < 10; i++)
		set.insert(i * 10);

	const_it = set.lower_bound(20);
	if (const_it != set.end())
		std::cout << *const_it << std::endl;
	else
		std::cout << "end()" << std::endl;

	const_it = set.lower_bound(42);
	if (const_it != set.end())
		std::cout << *const_it << std::endl;
	else
		std::cout << "end()" << std::endl;

	const_it = set.lower_bound(142);
	if (const_it != set.end())
		std::cout << *const_it << std::endl;
	else
		std::cout << "end()" << std::endl;

	const_it = set.lower_bound(-42);
	if (const_it != set.end())
		std::cout << *const_it << std::endl;
	else
		std::cout << "end()" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r15
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
andq $0x0, 0x20(%r15)
xorl %r12d, %r12d
leaq -0x58(%rbp), %rbx
leaq -0x24(%rbp), %r14
cmpl $0x64, %r12d
je 0x8f24
movl %r12d, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r12d
jmp 0x8f09
leaq -0x24(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x9756
cmpq %r15, %rax
je 0x8f4d
movl 0x20(%rax), %esi
movq 0x29072(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x8f60
movq 0x29064(%rip), %rdi     # 0x31fb8
leaq 0x18411(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x9756
cmpq %r15, %rax
je 0x8f91
movl 0x20(%rax), %esi
movq 0x2902e(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x8fa4
movq 0x29020(%rip), %rdi     # 0x31fb8
leaq 0x183cd(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0x8e, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x9756
cmpq %r15, %rax
je 0x8fd5
movl 0x20(%rax), %esi
movq 0x28fea(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x8fe8
movq 0x28fdc(%rip), %rdi     # 0x31fb8
leaq 0x18389(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x58(%rbp), %rdi
callq 0x9756
cmpq %r15, %rax
je 0x9019
movl 0x20(%rax), %esi
movq 0x28fa6(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x902c
movq 0x28f98(%rip), %rdi     # 0x31fb8
leaq 0x18345(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9054
jmp 0x9054
jmp 0x9054
jmp 0x9054
jmp 0x9054
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_upper_bound()
void
test_set_operations_upper_bound()
{
	ft::set<int> set;
	ft::set<int>::iterator it;

	for (int i = 0; i < 10; i++)
		set.insert(i * 10);

	it = set.upper_bound(20);
	if (it != set.end())
		std::cout << *it << std::endl;
	else
		std::cout << "end()" << std::endl;

	it = set.upper_bound(42);
	if (it != set.end())
		std::cout << *it << std::endl;
	else
		std::cout << "end()" << std::endl;

	it = set.upper_bound(142);
	if (it != set.end())
		std::cout << *it << std::endl;
	else
		std::cout << "end()" << std::endl;

	it = set.upper_bound(-42);
	if (it != set.end())
		std::cout << *it << std::endl;
	else
		std::cout << "end()" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r15
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
andq $0x0, 0x20(%r15)
xorl %r12d, %r12d
leaq -0x58(%rbp), %rbx
leaq -0x24(%rbp), %r14
cmpl $0x64, %r12d
je 0x90b7
movl %r12d, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r12d
jmp 0x909c
leaq -0x24(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x976c
cmpq %r15, %rax
je 0x90e0
movl 0x20(%rax), %esi
movq 0x28edf(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x90f3
movq 0x28ed1(%rip), %rdi     # 0x31fb8
leaq 0x1827e(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x976c
cmpq %r15, %rax
je 0x9124
movl 0x20(%rax), %esi
movq 0x28e9b(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x9137
movq 0x28e8d(%rip), %rdi     # 0x31fb8
leaq 0x1823a(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0x8e, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x976c
cmpq %r15, %rax
je 0x9168
movl 0x20(%rax), %esi
movq 0x28e57(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x917b
movq 0x28e49(%rip), %rdi     # 0x31fb8
leaq 0x181f6(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x24(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x58(%rbp), %rdi
callq 0x976c
cmpq %r15, %rax
je 0x91ac
movl 0x20(%rax), %esi
movq 0x28e13(%rip), %rdi     # 0x31fb8
callq 0x3320
jmp 0x91bf
movq 0x28e05(%rip), %rdi     # 0x31fb8
leaq 0x181b2(%rip), %rsi     # 0x2136c
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x91e7
jmp 0x91e7
jmp 0x91e7
jmp 0x91e7
jmp 0x91e7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_lower_upper_bound()
void
test_set_operations_lower_upper_bound()
{
	ft::set<int> set;
	ft::set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
		set.insert(i * 10);

	itlow = set.lower_bound(30);
	itup = set.upper_bound(60);

	print_set_info(set);

	set.erase(itlow, itup);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
cmpl $0x64, %r15d
je 0x9248
movl %r15d, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r15d
jmp 0x922d
leaq -0x1c(%rbp), %rsi
movl $0x1e, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x9756
movq %rax, %rbx
leaq -0x1c(%rbp), %rsi
movl $0x3c, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x976c
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4ccd
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7648
movq %r15, %rdi
callq 0x4ccd
leaq -0x50(%rbp), %rdi
callq 0x4202
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x92b1
jmp 0x92b1
jmp 0x92b1
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_equal_range_match()
void
test_set_operations_equal_range_match()
{
	ft::set<int> set;
	typedef ft::set<int>::const_iterator const_iterator;

	for (int i = 1; i <= 5; i++)
		set.insert(i * 10);

	ft::pair<const_iterator, const_iterator> ret;
	ret = set.equal_range(30);

	std::cout << "the lower bound points to: " << *ret.first << '\n';
	std::cout << "the upper bound points to: " << *ret.second << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
cmpl $0x3c, %r15d
je 0x9312
movl %r15d, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r15d
jmp 0x92f7
leaq -0x1c(%rbp), %rsi
movl $0x1e, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x75b8
movq %rax, %r14
movq %rdx, %rbx
movq 0x28c86(%rip), %rdi     # 0x31fb8
leaq 0x18039(%rip), %rsi     # 0x21372
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
movq 0x28c5c(%rip), %rdi     # 0x31fb8
leaq 0x1802b(%rip), %rsi     # 0x2138e
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
leaq -0x50(%rbp), %rdi
callq 0x4202
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9396
jmp 0x9396
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_equal_range_no_match()
void
test_set_operations_equal_range_no_match()
{
	ft::set<int> set;
	typedef ft::set<int>::const_iterator const_iterator;

	for (int i = 1; i <= 5; i++)
		set.insert(i * 10);

	ft::pair<const_iterator, const_iterator> ret;
	ret = set.equal_range(25);
	std::cout << "the lower bound points to: " << *ret.first << '\n';
	std::cout << "the upper bound points to: " << *ret.second << '\n';

	ret = set.equal_range(-42);
	std::cout << "the lower bound points to: " << *ret.first << '\n';
	std::cout << "the upper bound points to: " << *ret.second << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
cmpl $0x3c, %r15d
je 0x93f7
movl %r15d, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r15d
jmp 0x93dc
leaq -0x1c(%rbp), %rsi
movl $0x19, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x75b8
movq %rax, %r14
movq %rdx, %rbx
movq 0x28ba1(%rip), %rdi     # 0x31fb8
leaq 0x17f54(%rip), %rsi     # 0x21372
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
movq 0x28b77(%rip), %rdi     # 0x31fb8
leaq 0x17f46(%rip), %rsi     # 0x2138e
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
leaq -0x1c(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x50(%rbp), %rdi
callq 0x75b8
movq %rax, %r14
movq %rdx, %rbx
movq 0x28b35(%rip), %rdi     # 0x31fb8
leaq 0x17ee8(%rip), %rsi     # 0x21372
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
movq 0x28b0b(%rip), %rdi     # 0x31fb8
leaq 0x17eda(%rip), %rsi     # 0x2138e
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3210
leaq -0x50(%rbp), %rdi
callq 0x4202
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x94e9
jmp 0x94e9
jmp 0x94e9
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations()
void
test_set_operations()
{
	test_wrapper(test_set_operations_find, "find");
	test_wrapper(test_set_operations_count, "count");
	test_wrapper(test_set_operations_lower_bound, "lower_bound");
	test_wrapper(test_set_operations_upper_bound, "upper_bound");
	test_wrapper(test_set_operations_lower_upper_bound, "lower_upper_bound");
	test_wrapper(test_set_operations_equal_range_match, "equal_range_match");
	test_wrapper(test_set_operations_equal_range_no_match, "equal_range_no_match");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
leaq 0x17e9a(%rip), %rsi     # 0x213aa
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x827(%rip), %rdi      # 0x8d00
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0x17e69(%rip), %rsi     # 0x213af
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x763(%rip), %rdi      # 0x8dfa
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x17e39(%rip), %rsi     # 0x213b5
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x6be(%rip), %rdi      # 0x8ed5
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x17e15(%rip), %rsi     # 0x213c7
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x561(%rip), %rdi      # 0x9068
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x17dd9(%rip), %rsi     # 0x213c1
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x401(%rip), %rdi      # 0x91fb
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x17dbe(%rip), %rsi     # 0x213d3
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x364(%rip), %rdi      # 0x92c5
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x17da3(%rip), %rsi     # 0x213e5
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x2ac(%rip), %rdi      # 0x93aa
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x96c7
jmp 0x96ce
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x30d0
jmp 0x96d1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_observers.cpp
// Function: test_set_observers_key_comp()
void
test_set_observers_key_comp()
{
	ft::set<int> myset;
	int highest;

	ft::set<int>::key_compare mycomp = myset.key_comp();

	for (int i = 0; i <= 5; i++)
		myset.insert(i);

	std::cout << "myset contains:";

	highest = *myset.rbegin();

	ft::set<int>::iterator it = myset.begin();
	do
	{
		std::cout << ' ' << *it;
	} while (mycomp(*(++it), highest));

	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
xorl %eax, %eax
leaq -0x58(%rbp), %r14
leaq -0x24(%rbp), %r15
movl %eax, -0x24(%rbp)
cmpl $0x6, %eax
jge 0x97d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x73c8
movl -0x24(%rbp), %eax
incl %eax
jmp 0x97b6
movq 0x287e1(%rip), %rdi     # 0x31fb8
leaq 0x17917(%rip), %rsi     # 0x210f5
callq 0x31d0
movq %rbx, %rdi
callq 0x3130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x287be(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x3320
movq %r15, %rdi
callq 0x3200
movq %rax, %r15
cmpl %r12d, 0x20(%rax)
jl 0x97fe
movq 0x2878b(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x984e
jmp 0x984e
jmp 0x984e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_observers.cpp
// Function: test_set_observers_value_comp()
void
test_set_observers_value_comp()
{
	ft::set<int> myset;
	int highest;

	ft::set<int>::value_compare mycomp = myset.value_comp();

	for (int i = 0; i <= 5; i++)
		myset.insert(i);

	std::cout << "myset contains:";

	highest = *myset.rbegin();

	ft::set<int>::iterator it = myset.begin();
	do
	{
		std::cout << ' ' << *it;
	} while (mycomp(*(++it), highest));

	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
xorl %eax, %eax
leaq -0x58(%rbp), %r14
leaq -0x24(%rbp), %r15
movl %eax, -0x24(%rbp)
cmpl $0x6, %eax
jge 0x98ae
movq %r14, %rdi
movq %r15, %rsi
callq 0x73c8
movl -0x24(%rbp), %eax
incl %eax
jmp 0x9894
movq 0x28703(%rip), %rdi     # 0x31fb8
leaq 0x17839(%rip), %rsi     # 0x210f5
callq 0x31d0
movq %rbx, %rdi
callq 0x3130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x286e0(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x3320
movq %r15, %rdi
callq 0x3200
movq %rax, %r15
cmpl %r12d, 0x20(%rax)
jl 0x98dc
movq 0x286ad(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x992c
jmp 0x992c
jmp 0x992c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_non_member_overloads.cpp
// Function: test_set_non_member_overloads_relation_operators()
void
test_set_non_member_overloads_relation_operators()
{
	ft::set<int> foo, bar;

	foo.insert(10);
	bar.insert(20);
	bar.insert(30);
	foo.insert(40);

	// foo ({10,40}) vs bar ({20,30}):
	if (foo == bar) std::cout << "foo and bar are equal" << std::endl;
	if (foo != bar) std::cout << "foo and bar are not equal" << std::endl;
	if (foo < bar) std::cout << "foo is less than bar" << std::endl;
	if (foo > bar) std::cout << "foo is greater than bar" << std::endl;
	if (foo <= bar) std::cout << "foo is less than or equal to bar" << std::endl;
	if (foo >= bar) std::cout << "foo is greater than or equal to bar" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0x1e, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0x28, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0x5824
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9d0f
testb %al, %al
je 0x9a83
movq 0x28549(%rip), %rdi     # 0x31fb8
leaq 0x179ac(%rip), %rsi     # 0x21422
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9cdf
testb %al, %al
je 0x9aaf
movq 0x2851d(%rip), %rdi     # 0x31fb8
leaq 0x17996(%rip), %rsi     # 0x21438
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9d85
testb %al, %al
je 0x9adb
movq 0x284f1(%rip), %rdi     # 0x31fb8
leaq 0x17984(%rip), %rsi     # 0x21452
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9d85
testb %al, %al
je 0x9b07
movq 0x284c5(%rip), %rdi     # 0x31fb8
leaq 0x1796d(%rip), %rsi     # 0x21467
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9cec
testb %al, %al
je 0x9b33
movq 0x28499(%rip), %rdi     # 0x31fb8
leaq 0x17959(%rip), %rsi     # 0x2147f
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9d02
testb %al, %al
je 0x9b5f
movq 0x2846d(%rip), %rdi     # 0x31fb8
leaq 0x1794e(%rip), %rsi     # 0x214a0
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0x4202
leaq -0x70(%rbp), %rdi
callq 0x4202
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x9b80
jmp 0x9b80
jmp 0x9b80
jmp 0x9b80
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4202
leaq -0x70(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_non_member_overloads.cpp
// Function: test_set_non_member_overloads_swap()
void
test_set_non_member_overloads_swap()
{
	int myints[] = {12, 75, 10, 32, 20, 25};
	ft::set<int> first(myints, myints + 3);
	ft::set<int> second(myints + 3, myints+ 6);

	print_set_info(first);
	print_set_info(second);

	swap(first, second);

	print_set_info(first);
	print_set_info(second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movaps 0x17933(%rip), %xmm0    # 0x214e0
leaq -0x14(%rbp), %rbx
movaps %xmm0, -0xc(%rbx)
movabsq $0x1900000014, %rax     # imm = 0x1900000014
movq %rax, 0x4(%rbx)
leaq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rbx, %rdx
callq 0x72ce
leaq -0x8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x72ce
leaq -0x80(%rbp), %rdi
callq 0x4ccd
leaq -0x50(%rbp), %rdi
callq 0x4ccd
leaq -0x80(%rbp), %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x7704
movq %rbx, %rdi
callq 0x4ccd
leaq -0x50(%rbp), %rdi
callq 0x4ccd
leaq -0x50(%rbp), %rdi
callq 0x4202
leaq -0x80(%rbp), %rdi
callq 0x4202
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x9c40
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
leaq -0x80(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/test_containers.cpp
// Function: test_containers()
void
test_containers()
{
	//test_wrapper(test_subject, "subject");
	subsection_wrapper(test_vector, "vector");
	subsection_wrapper(test_stack, "stack");
	subsection_wrapper(test_map, "map");
	subsection_wrapper(test_set, "set");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
leaq 0x17bae(%rip), %rsi     # 0x219c9
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0xc386(%rip), %rdi      # 0x161b8
leaq -0x90(%rbp), %rsi
callq 0x20c00
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x176a7(%rip), %rsi     # 0x214f8
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0xa5cd(%rip), %rdi      # 0x14432
leaq -0x70(%rbp), %rsi
callq 0x20c00
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x177af(%rip), %rsi     # 0x2162d
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x50f6(%rip), %rdi      # 0xef88
leaq -0x50(%rbp), %rsi
callq 0x20c00
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x17484(%rip), %rsi     # 0x2132f
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x26af(%rip), %rdi     # 0x7810
leaq -0x30(%rbp), %rsi
callq 0x20c00
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x9f06
jmp 0x9f0d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x9f06
jmp 0x9f0d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x9f06
jmp 0x9f0d
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x30d0
jmp 0x9f10
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations_find()
void
test_map_operations_find()
{
	ft::map<char, int> map;
	ft::map<char, int>::iterator it;

	for (char i = '0'; i <= '9'; i++)
		map.insert(ft::make_pair(i, i));

	print_map_info(map);

	if ((it = map.find('4')) != map.end())
		map.erase(it);

	if ((it = map.find('4')) != map.end())
		map.erase(it);

	if ((it = map.find('2')) != map.end())
		map.erase(it);

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r15
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
andq $0x0, 0x20(%r15)
movw $0x3030, %r12w          # imm = 0x3030
leaq -0x58(%rbp), %rbx
leaq -0x22(%rbp), %r14
cmpw $0x3a3a, %r12w          # imm = 0x3A3A
je 0xb52f
movw %r12w, -0x22(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc346
addl $0x101, %r12d           # imm = 0x101
jmp 0xb50e
leaq -0x58(%rbp), %rdi
callq 0xc1a3
leaq -0x22(%rbp), %rsi
movb $0x34, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0xc4f0
cmpq %r15, %rax
je 0xb559
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc548
leaq -0x22(%rbp), %rsi
movb $0x34, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0xc4f0
cmpq %r15, %rax
je 0xb57a
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc548
leaq -0x22(%rbp), %rsi
movb $0x32, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0xc4f0
cmpq %r15, %rax
je 0xb59b
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc548
leaq -0x58(%rbp), %rdi
callq 0xc1a3
leaq -0x58(%rbp), %rdi
callq 0xc2f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb5c2
jmp 0xb5c2
jmp 0xb5c2
jmp 0xb5c2
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations_count()
void
test_map_operations_count()
{
	ft::map<int, int> map;

	for (int i = 0; i < 20; i++)
	{
		if (i % 2 == 0)
			map.insert(ft::make_pair(i, i));
	}

	for (int i = 0; i < 20; i++)
		std::cout << (map.count(i) == 1 ? " In " : " Not in ");
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %r15d, %r15d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r12      # imm = 0x100000001
xorl %r13d, %r13d
cmpq $0x14, %r13
je 0xb63b
testb $0x1, %r13b
jne 0xb633
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r13
addq %r12, %r15
jmp 0xb618
xorl %eax, %eax
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
leaq 0x15d12(%rip), %r12     # 0x2135e
leaq 0x15d10(%rip), %r13     # 0x21363
movq 0x2695e(%rip), %r15     # 0x31fb8
movl %eax, -0x30(%rbp)
cmpl $0x14, %eax
jge 0xb688
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc27a
movq %r12, %rsi
cmpq $0x1, %rax
je 0xb679
movq %r13, %rsi
movq %r15, %rdi
callq 0x31d0
movl -0x30(%rbp), %eax
incl %eax
jmp 0xb65a
movq 0x26929(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb6b0
jmp 0xb6b0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations_lower_upper_bound()
void
test_map_operations_lower_upper_bound()
{
	ft::map<char, int> mymap;
	ft::map<char, int>::iterator itlow, itup;

	mymap['a'] = 20;
	mymap['b'] = 40;
	mymap['c'] = 60;
	mymap['d'] = 80;
	mymap['e'] = 100;

	itlow = mymap.lower_bound('b');
	itup = mymap.upper_bound('d');

	print_map_info(mymap);

	mymap.erase(itlow, itup);

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x19(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc29e
movl $0x14, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc29e
movl $0x28, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc29e
movl $0x3c, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc29e
movl $0x50, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x65, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc29e
movl $0x64, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc600
movq %rax, %rbx
leaq -0x19(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xc616
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xc1a3
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc7ba
movq %r15, %rdi
callq 0xc1a3
leaq -0x50(%rbp), %rdi
callq 0xc2f0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc49
jmp 0xbc49
jmp 0xbc49
jmp 0xbc49
jmp 0xbc49
jmp 0xbc49
jmp 0xbc49
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations_equal_range_match()
void
test_map_operations_equal_range_match()
{
	ft::map<char, int> mymap;

	mymap['a'] = 10;
	mymap['b'] = 20;
	mymap['d'] = 30;

	ft::pair<ft::map<char, int>::iterator, ft::map<char, int>::iterator> ret;
	ret = mymap.equal_range('b');

	std::cout << "lower bound points to: ";
	std::cout << " [" << ret.first->first << "] = " << ret.first->second << std::endl;

	std::cout << "upper bound points to: ";
	std::cout << " [" << ret.second->first << "] = " << ret.second->second << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x11(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xc29e
movl $0xa, (%rax)
leaq -0x11(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xc29e
movl $0x14, (%rax)
leaq -0x11(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xc29e
movl $0x1e, (%rax)
leaq -0x11(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xc852
movq %rax, %r14
movq %rdx, %rbx
movq 0x262d8(%rip), %rdi     # 0x31fb8
leaq 0x1568f(%rip), %rsi     # 0x21376
callq 0x31d0
movq 0x262c5(%rip), %rdi     # 0x31fb8
leaq 0x1590f(%rip), %rsi     # 0x21609
callq 0x31d0
movsbl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3210
leaq 0x158f9(%rip), %rsi     # 0x2160c
movq %rax, %rdi
callq 0x31d0
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq 0x26282(%rip), %rdi     # 0x31fb8
leaq 0x15655(%rip), %rsi     # 0x21392
callq 0x31d0
movq 0x2626f(%rip), %rdi     # 0x31fb8
leaq 0x158b9(%rip), %rsi     # 0x21609
callq 0x31d0
movsbl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3210
leaq 0x158a4(%rip), %rsi     # 0x2160c
movq %rax, %rdi
callq 0x31d0
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
callq 0xc2f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xbd9d
jmp 0xbd9d
jmp 0xbd9d
jmp 0xbd9d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations()
void
test_map_operations()
{
	test_wrapper(test_map_operations_find, "find");
	test_wrapper(test_map_operations_count, "count");
	test_wrapper(test_map_operations_lower_bound, "lower_bound");
	test_wrapper(test_map_operations_upper_bound, "upper_bound");
	test_wrapper(test_map_operations_lower_upper_bound, "lower_upper_bound");
	test_wrapper(test_map_operations_equal_range_match, "equal_range_match");
	test_wrapper(test_map_operations_equal_range_no_match, "equal_range_no_match");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
leaq 0x153d0(%rip), %rsi     # 0x213aa
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0xb19(%rip), %rdi      # 0xb4d8
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0x1539f(%rip), %rsi     # 0x213af
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0xa51(%rip), %rdi      # 0xb5d6
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x1536f(%rip), %rsi     # 0x213b5
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x999(%rip), %rdi      # 0xb6c4
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x1534b(%rip), %rsi     # 0x213c7
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x78c(%rip), %rdi      # 0xb907
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x1530f(%rip), %rsi     # 0x213c1
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x57c(%rip), %rdi      # 0xbb4a
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x152f4(%rip), %rsi     # 0x213d3
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x496(%rip), %rdi      # 0xbc5d
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x152d9(%rip), %rsi     # 0x213e5
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x36f(%rip), %rdi      # 0xbdb1
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0xc191
jmp 0xc198
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x30d0
jmp 0xc19b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_map_info<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
void
print_map_info(Map const& map)
{
	std::cout << "Size: " << map.size() << std::endl;

	if (map.empty())
		std::cout << "Set is empty" << std::endl;
	else
	{
		std::cout << "Values: ";
		for (typename Map::const_iterator it = map.begin(); it != map.end(); it++)
			std::cout << " [" << it->first << "] = " << it->second;
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x24142(%rip), %rbx     # 0x31fb8
leaq 0x13204(%rip), %rsi     # 0x21081
movq %rbx, %rdi
callq 0x31d0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
cmpq $0x0, 0x28(%r14)
je 0xdf07
leaq 0x131ee(%rip), %rsi     # 0x21095
movq %rbx, %rdi
callq 0x31d0
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x1374b(%rip), %r15     # 0x21609
leaq 0x13747(%rip), %r13     # 0x2160c
cmpq %r14, %r12
je 0xdf1d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
leaq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x3190
movq %r12, %rdi
callq 0x3200
movq %rax, %r12
jmp 0xdec5
movq 0x240aa(%rip), %rdi     # 0x31fb8
leaq 0x13173(%rip), %rsi     # 0x21088
callq 0x31d0
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_constructors_base()
void
test_map_reverse_iterators_constructors_base()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;
	typedef ft::map<int, char>::reverse_iterator rev_iter_type;

	iter_type from(map.begin());
	iter_type until(map.end());

	rev_iter_type rev_until(from);
	rev_iter_type rev_from(until);

	iter_type it_end = rev_until.base();
	iter_type it_begin = rev_from.base();

	if (it_end == from && it_begin == until)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0xc948
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0xc92e
movq 0x25669(%rip), %rdi     # 0x31fb8
leaq 0x15b87(%rip), %rsi     # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc97d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_operator_star()
void
test_map_reverse_iterators_operator_star()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;
	typedef ft::map<int, char>::reverse_iterator rev_iter_type;

	iter_type until(map.end());

	rev_iter_type rev_from(until);

	std::cout << "[" << rev_from->first << "] = " << rev_from->second << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r12
movabsq $0x3000000030, %r13     # imm = 0x3000000030
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
movabsq $0x100000001, %rbx      # imm = 0x100000001
subq $0x1, %r12
jb 0xc9f5
movq %r13, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd392
addq %rbx, %r13
jmp 0xc9db
movq 0x255bc(%rip), %rdi     # 0x31fb8
leaq 0x14c07(%rip), %rsi     # 0x2160a
callq 0x31d0
leaq -0x58(%rbp), %rbx
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x3320
leaq 0x14be3(%rip), %rsi     # 0x2160c
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movsbl 0x24(%rax), %esi
movq %r14, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xca6a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_operator_increment()
void
test_map_reverse_iterators_operator_increment()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;


	iter_type from(map.begin());
	iter_type until(map.end());

	ft::reverse_iterator<iter_type> rev_until(from);
	ft::reverse_iterator<iter_type> rev_from(until);

	std::cout << "mymap:";
	while (rev_from != rev_until)
	{
		std::cout << "[" << rev_from->first << "] = " << rev_from->second << std::endl;
		++rev_from;
	}

	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
pushq $0xa
popq %r12
movabsq $0x3000000030, %r13     # imm = 0x3000000030
leaq -0x30(%rbp), %r15
movabsq $0x100000001, %r14      # imm = 0x100000001
subq $0x1, %r12
jb 0xcadf
movq %r13, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0xd392
addq %r14, %r13
jmp 0xcac4
movq -0x48(%rbp), %r14
movq 0x254ce(%rip), %rdi     # 0x31fb8
leaq 0x14b21(%rip), %rsi     # 0x21612
callq 0x31d0
leaq 0x14b0d(%rip), %r15     # 0x2160a
leaq 0x14b08(%rip), %r12     # 0x2160c
cmpq %r14, %rbx
je 0xcb65
movq 0x254a8(%rip), %rdi     # 0x31fb8
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movsbl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rbx
jmp 0xcb04
movq 0x2544c(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcb8d
jmp 0xcb8d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_operator_decrement()
void
test_map_reverse_iterators_operator_decrement()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	ft::reverse_iterator<iter_type> rev_begin(map.end());
	ft::reverse_iterator<iter_type> rev_end(map.begin());

	ft::reverse_iterator<iter_type> rev_iterator = rev_begin;

	while (rev_iterator != rev_end)
		std::cout << "[" << rev_iterator->first << "] = " << (rev_iterator++)->second << std::endl;
	std::cout << std::endl;

	while (rev_iterator != rev_begin)
		std::cout << " [" << (--rev_iterator)->first << "] = " << rev_iterator->second;
	std::cout << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0xcc05
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0xcbeb
movq -0x48(%rbp), %r14
leaq 0x149fa(%rip), %r15     # 0x2160a
leaq 0x149f5(%rip), %r12     # 0x2160c
leaq -0x58(%rbp), %rbx
cmpq %r14, %rbx
je 0xcc74
movq 0x25391(%rip), %rdi     # 0x31fb8
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rbx
movsbl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x30e0
jmp 0xcc1b
movq 0x2533d(%rip), %rdi     # 0x31fb8
callq 0x30e0
movq 0x25331(%rip), %r14     # 0x31fb8
leaq 0x1497b(%rip), %r15     # 0x21609
leaq 0x14977(%rip), %r12     # 0x2160c
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0xccee
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3150
movq %rax, %rbx
movq %rax, %rdi
callq 0x31f0
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movsbl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3210
jmp 0xcc95
movq 0x252c3(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd1a
jmp 0xcd1a
jmp 0xcd1a
jmp 0xcd1a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_empty_maps()
void
test_map_reverse_iterators_empty_maps()
{
	ft::map<int, int> map;
	ft::map<int, int> const const_map;

	if (map.rbegin() == map.rend())
		std::cout << "correct" << std::endl;

	if (const_map.rbegin() == const_map.rend())
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x60(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x30(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq 0x25248(%rip), %rdi     # 0x31fb8
leaq 0x14376(%rip), %rsi     # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
cmpq -0x20(%rbp), %rbx
jne 0xcda5
movq 0x25227(%rip), %rdi     # 0x31fb8
leaq 0x14355(%rip), %rsi     # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x38(%rbp), %rdi
callq 0xa648
leaq -0x68(%rbp), %rdi
callq 0xa648
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa648
leaq -0x68(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_100_size_map()
void
test_map_reverse_iterators_100_size_map()
{
	typedef ft::map<int, int>::reverse_iterator reverse_iterator;

	ft::map<int, int> map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	for (reverse_iterator it = map.rbegin(); it != map.rend(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x253cc(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0x64, %r12
je 0xce4f
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xce22
movq 0x25162(%rip), %r14     # 0x31fb8
leaq 0x147ac(%rip), %r15     # 0x21609
leaq 0x147a8(%rip), %r12     # 0x2160c
cmpq -0x48(%rbp), %rbx
je 0xceb9
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rbx
jmp 0xce64
movq 0x250f8(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcee1
jmp 0xcee1
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330