LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xd0, %rsp
leaq -0x21(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3370
movq -0xb8(%rbp), %rdx
leaq 0x434de(%rip), %rsi     # 0x579d7
leaq -0x20(%rbp), %rdi
callq 0x3290
jmp 0x14504
leaq 0x26ec5(%rip), %rdi     # 0x3b3d0
leaq -0x20(%rbp), %rsi
callq 0x56330
jmp 0x14516
leaq -0x20(%rbp), %rdi
callq 0x3160
leaq -0x21(%rbp), %rdi
callq 0x3230
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3370
movq -0xc0(%rbp), %rdx
leaq 0x42fd2(%rip), %rsi     # 0x57518
leaq -0x58(%rbp), %rdi
callq 0x3290
jmp 0x14551
leaq 0x20a58(%rip), %rdi     # 0x34fb0
leaq -0x58(%rbp), %rsi
callq 0x56330
jmp 0x14563
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3230
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3370
movq -0xc8(%rbp), %rdx
leaq 0x430a5(%rip), %rsi     # 0x5763b
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x145a1
leaq 0x12c48(%rip), %rdi     # 0x271f0
leaq -0x80(%rbp), %rsi
callq 0x56330
jmp 0x145b3
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x3230
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3370
movq -0xd0(%rbp), %rdx
leaq 0x42d66(%rip), %rsi     # 0x5734f
leaq -0xa8(%rbp), %rdi
callq 0x3290
jmp 0x145f7
leaq -0x556e(%rip), %rdi     # 0xf090
leaq -0xa8(%rbp), %rsi
callq 0x56330
jmp 0x1460c
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0xa9(%rbp), %rdi
callq 0x3230
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x14650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3160
leaq -0x21(%rbp), %rdi
callq 0x3230
jmp 0x146ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x14681
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3230
jmp 0x146ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x146af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x3230
jmp 0x146ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x146e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0xa9(%rbp), %rdi
callq 0x3230
movq -0x30(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
movl $0x0, -0x34(%rbp)
cmpl $0x14, -0x34(%rbp)
jge 0x1a788
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1a77b
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x70(%rbp)
jmp 0x1a733
movq -0x70(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x1a751
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
jmp 0x1a77b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x1a80a
jmp 0x1a77d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1a70b
movl $0x0, -0x64(%rbp)
cmpl $0x14, -0x64(%rbp)
jge 0x1a7e3
leaq -0x30(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x1c280
movq %rax, -0x88(%rbp)
jmp 0x1a7ab
movq -0x88(%rbp), %rax
subq $0x1, %rax
leaq 0x3cbc1(%rip), %rax     # 0x5737e
leaq 0x3cbbf(%rip), %rsi     # 0x57383
cmoveq %rax, %rsi
movq 0x607e9(%rip), %rdi     # 0x7afb8
callq 0x31e0
jmp 0x1a7d6
jmp 0x1a7d8
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x1a78f
movq 0x607ce(%rip), %rdi     # 0x7afb8
movq 0x607a7(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1a7f8
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1bf70
leaq -0x38(%rbp), %rdi
callq 0x1bf90
leaq -0x40(%rbp), %rdi
callq 0x1bf90
movq -0xa0(%rbp), %rdi
movb $0x61, -0x41(%rbp)
leaq -0x41(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x98(%rbp)
jmp 0x1b3aa
movq -0x98(%rbp), %rax
movl $0x14, (%rax)
movb $0x62, -0x55(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x55(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xa8(%rbp)
jmp 0x1b3d1
movq -0xa8(%rbp), %rax
movl $0x28, (%rax)
movb $0x63, -0x56(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x56(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xb0(%rbp)
jmp 0x1b3f8
movq -0xb0(%rbp), %rax
movl $0x3c, (%rax)
movb $0x64, -0x57(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x57(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xb8(%rbp)
jmp 0x1b41f
movq -0xb8(%rbp), %rax
movl $0x50, (%rax)
movb $0x65, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xc0(%rbp)
jmp 0x1b446
movq -0xc0(%rbp), %rax
movl $0x64, (%rax)
movb $0x62, -0x61(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x61(%rbp), %rsi
callq 0x1c300
movq %rax, -0xc8(%rbp)
jmp 0x1b46d
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x64, -0x71(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x71(%rbp), %rsi
callq 0x1c3c0
movq %rax, -0xd0(%rbp)
jmp 0x1b49a
movq -0xd0(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c020
jmp 0x1b4b8
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c350
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c350
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1c4d0
movq %rax, -0xd8(%rbp)
jmp 0x1b4f2
movq -0xd8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c020
jmp 0x1b50b
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x50(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1bf70
movq -0x80(%rbp), %rdi
movb $0x61, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x78(%rbp)
jmp 0x1b56f
movq -0x78(%rbp), %rax
movl $0xa, (%rax)
movb $0x62, -0x45(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x45(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x88(%rbp)
jmp 0x1b593
movq -0x88(%rbp), %rax
movl $0x14, (%rax)
movb $0x64, -0x46(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x46(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x90(%rbp)
jmp 0x1b5ba
movq -0x90(%rbp), %rax
movl $0x1e, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x1c520
jmp 0x1b5d2
movb $0x62, -0x69(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x69(%rbp), %rsi
callq 0x1c550
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x1b5f3
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1c590
movq 0x5f99b(%rip), %rdi     # 0x7afb8
leaq 0x3bd72(%rip), %rsi     # 0x57396
callq 0x31e0
jmp 0x1b62b
movq 0x5f986(%rip), %rdi     # 0x7afb8
leaq 0x3bfde(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa8(%rbp)
jmp 0x1b647
leaq -0x58(%rbp), %rdi
callq 0x1c330
movq -0xa8(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3250
movq %rax, -0xb0(%rbp)
jmp 0x1b668
movq -0xb0(%rbp), %rdi
leaq 0x3bfa4(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x1b684
leaq -0x58(%rbp), %rdi
callq 0x1c330
movq -0xb8(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
movq %rax, -0xc0(%rbp)
jmp 0x1b6a5
movq -0xc0(%rbp), %rdi
movq 0x5f8e5(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1b6ba
movq 0x5f8f7(%rip), %rdi     # 0x7afb8
leaq 0x3bcea(%rip), %rsi     # 0x573b2
callq 0x31e0
jmp 0x1b6cf
movq 0x5f8e2(%rip), %rdi     # 0x7afb8
leaq 0x3bf3a(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xc8(%rbp)
jmp 0x1b6eb
leaq -0x50(%rbp), %rdi
callq 0x1c330
movq -0xc8(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3250
movq %rax, -0xd0(%rbp)
jmp 0x1b70c
movq -0xd0(%rbp), %rdi
leaq 0x3bf00(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xd8(%rbp)
jmp 0x1b728
leaq -0x50(%rbp), %rdi
callq 0x1c330
movq -0xd8(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
movq %rax, -0xe0(%rbp)
jmp 0x1b749
movq -0xe0(%rbp), %rdi
movq 0x5f841(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1b75e
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x40(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_map_info<std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int>>>>(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int>>> 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5ef85(%rip), %rdi     # 0x7afb8
leaq 0x3b047(%rip), %rsi     # 0x57081
callq 0x31e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d1d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3080
movq %rax, %rdi
movq 0x5ef36(%rip), %rsi     # 0x7af98
callq 0x3220
movq -0x8(%rbp), %rdi
callq 0x1d1f0
testb $0x1, %al
jne 0x1c076
jmp 0x1c09d
movq 0x5ef3b(%rip), %rdi     # 0x7afb8
leaq 0x3b004(%rip), %rsi     # 0x57088
callq 0x31e0
movq %rax, %rdi
movq 0x5ef05(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1c158
movq 0x5ef14(%rip), %rdi     # 0x7afb8
leaq 0x3afea(%rip), %rsi     # 0x57095
callq 0x31e0
movq -0x8(%rbp), %rdi
callq 0x1d210
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d240
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c370
testb $0x1, %al
jne 0x1c0dd
jmp 0x1c145
movq 0x5eed4(%rip), %rdi     # 0x7afb8
leaq 0x3b52c(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1c3a0
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3250
movq %rax, %rdi
leaq 0x3b507(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1c3a0
movq -0x30(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1d270
movq %rax, -0x20(%rbp)
jmp 0x1c0bd
movq 0x5ee6c(%rip), %rdi     # 0x7afb8
movq 0x5ee45(%rip), %rsi     # 0x7af98
callq 0x3220
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x1e546
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0xa8(%rbp)
jmp 0x1e4e6
movq -0xa8(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x1e50d
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e4cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x1e655
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1f9c0
movq -0xc0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x1f9f0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1fa20
jmp 0x1e581
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1fa20
jmp 0x1e5a1
leaq -0x78(%rbp), %rdi
callq 0x1fa40
movq %rax, -0xc8(%rbp)
jmp 0x1e5b3
movq -0xc8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1fa40
movq %rax, -0xd0(%rbp)
jmp 0x1e5d6
movq -0xd0(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1fa60
testb $0x1, %al
jne 0x1e5fa
jmp 0x1e643
leaq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1fa60
testb $0x1, %al
jne 0x1e610
jmp 0x1e643
movq 0x5c9a1(%rip), %rdi     # 0x7afb8
leaq 0x39ebf(%rip), %rsi     # 0x584dd
callq 0x31e0
movq %rax, -0xd8(%rbp)
jmp 0x1e62c
movq -0xd8(%rbp), %rdi
movq 0x5c95e(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1e641
jmp 0x1e643
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nop
// File: 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
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x1e6f0
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x80(%rbp)
jmp 0x1e693
movq -0x80(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x1e6b7
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e67b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x1e7d5
leaq -0x30(%rbp), %rdi
callq 0x1f9f0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1fa20
jmp 0x1e714
movq 0x5c89d(%rip), %rdi     # 0x7afb8
leaq 0x38ef6(%rip), %rsi     # 0x57618
callq 0x31e0
movq %rax, -0x98(%rbp)
jmp 0x1e730
leaq -0x70(%rbp), %rdi
callq 0x1fab0
movq %rax, -0xa0(%rbp)
jmp 0x1e742
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0xa8(%rbp)
jmp 0x1e760
movq -0xa8(%rbp), %rdi
leaq 0x38eac(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x1e77c
leaq -0x70(%rbp), %rdi
callq 0x1fab0
movq %rax, -0xb8(%rbp)
jmp 0x1e78e
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movsbl 0x4(%rax), %esi
callq 0x3250
movq %rax, -0xc0(%rbp)
jmp 0x1e7ae
movq -0xc0(%rbp), %rdi
movq 0x5c7dc(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1e7c3
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nop
// File: 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
subq $0xf0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x1e876
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x98(%rbp)
jmp 0x1e816
movq -0x98(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x1e83d
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e7fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x1e9fe
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1f9c0
movq -0xb0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x1f9f0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1fa20
jmp 0x1e8b1
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1fa20
jmp 0x1e8d1
movq 0x5c6e0(%rip), %rdi     # 0x7afb8
leaq 0x38d41(%rip), %rsi     # 0x57620
callq 0x31e0
jmp 0x1e8e6
jmp 0x1e8e8
leaq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1faf0
movb %al, -0xb1(%rbp)
jmp 0x1e900
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x1e90f
jmp 0x1e9d7
movq 0x5c6a2(%rip), %rdi     # 0x7afb8
leaq 0x38cfb(%rip), %rsi     # 0x57618
callq 0x31e0
movq %rax, -0xc0(%rbp)
jmp 0x1e92b
leaq -0x88(%rbp), %rdi
callq 0x1fab0
movq %rax, -0xc8(%rbp)
jmp 0x1e940
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0xd0(%rbp)
jmp 0x1e95e
movq -0xd0(%rbp), %rdi
leaq 0x38cae(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xd8(%rbp)
jmp 0x1e97a
leaq -0x88(%rbp), %rdi
callq 0x1fab0
movq %rax, -0xe0(%rbp)
jmp 0x1e98f
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movsbl 0x4(%rax), %esi
callq 0x3250
movq %rax, -0xe8(%rbp)
jmp 0x1e9af
movq -0xe8(%rbp), %rdi
movq 0x5c5db(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1e9c4
leaq -0x88(%rbp), %rdi
callq 0x1fb20
jmp 0x1e9d2
jmp 0x1e8e8
movq 0x5c5da(%rip), %rdi     # 0x7afb8
movq 0x5c5b3(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1e9ec
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: 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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x14da0
leaq -0x60(%rbp), %rdi
callq 0x14da0
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1fc20
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1fc50
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x1fbe0
movb %al, -0x91(%rbp)
jmp 0x1ed7d
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1ed89
jmp 0x1eddf
movq 0x5c228(%rip), %rdi     # 0x7afb8
leaq 0x38356(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x1eda5
movq -0xb8(%rbp), %rdi
movq 0x5c1e5(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1edba
jmp 0x1eddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x1ee8c
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x1fcc0
movq -0xd8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1fcf0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x1fc80
movb %al, -0xb9(%rbp)
jmp 0x1ee32
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x1ee3e
jmp 0x1ee71
movq 0x5c173(%rip), %rdi     # 0x7afb8
leaq 0x382a1(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xe0(%rbp)
jmp 0x1ee5a
movq -0xe0(%rbp), %rdi
movq 0x5c130(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1ee6f
jmp 0x1ee71
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xe0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x5c34d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x1ef74
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x80(%rbp)
jmp 0x1ef14
movq -0x80(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x1ef38
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1eec9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x1f08d
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fc20
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1fc50
movq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1fd50
movb %al, -0x8a(%rbp)
jmp 0x1efad
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x1efbc
jmp 0x1f066
movq 0x5bff5(%rip), %rdi     # 0x7afb8
leaq 0x3864d(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x1efd8
leaq -0x68(%rbp), %rdi
callq 0x1fd80
movq %rax, -0xa8(%rbp)
jmp 0x1efea
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0xb0(%rbp)
jmp 0x1f008
movq -0xb0(%rbp), %rdi
leaq 0x38604(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x1f024
leaq -0x68(%rbp), %rdi
callq 0x1fd80
movq %rax, -0xc0(%rbp)
jmp 0x1f036
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x1f04e
jmp 0x1f050
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
xorl %edx, %edx
callq 0x1fdc0
jmp 0x1f061
jmp 0x1ef81
movq 0x5bf4b(%rip), %rdi     # 0x7afb8
movq 0x5bf24(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1f07b
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_100_size_const_map()
void
test_map_reverse_iterators_100_size_const_map()
{
	typedef ft::map<int, int>::const_reverse_iterator const_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 (const_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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x5c14d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x1f17a
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x88(%rbp)
jmp 0x1f117
movq -0x88(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x1f13e
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1f0c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x1f2ae
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1fc20
movq -0xa0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1fe00
jmp 0x1f1a0
jmp 0x1f1a2
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1fc50
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1fe30
movb %al, -0xa1(%rbp)
jmp 0x1f1ce
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1f1dd
jmp 0x1f287
movq 0x5bdd4(%rip), %rdi     # 0x7afb8
leaq 0x3842c(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x1f1f9
leaq -0x68(%rbp), %rdi
callq 0x1fe80
movq %rax, -0xc0(%rbp)
jmp 0x1f20b
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0xc8(%rbp)
jmp 0x1f229
movq -0xc8(%rbp), %rdi
leaq 0x383e3(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xd0(%rbp)
jmp 0x1f245
leaq -0x68(%rbp), %rdi
callq 0x1fe80
movq %rax, -0xd8(%rbp)
jmp 0x1f257
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x1f26f
jmp 0x1f271
leaq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
xorl %edx, %edx
callq 0x1fec0
jmp 0x1f282
jmp 0x1f1a2
movq 0x5bd2a(%rip), %rdi     # 0x7afb8
movq 0x5bd03(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1f29c
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_copy()
void
test_map_reverse_iterators_copy()
{
	typedef ft::map<int, int>::reverse_iterator reverse_iterator;
	typedef ft::map<int, int>::const_reverse_iterator const_reverse_iterator;

	ft::map<int, int> map;

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

	reverse_iterator it(map.rbegin());
	const_reverse_iterator const_it(it);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x5bf2d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x1f39a
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x90(%rbp)
jmp 0x1f337
movq -0x90(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x1f35e
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1f2e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x1f4cb
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1fc20
movq -0xa8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1fe00
jmp 0x1f3c0
leaq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1ff00
jmp 0x1f3cf
jmp 0x1f3d1
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1fc50
movq -0xb8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1fe30
movb %al, -0xa9(%rbp)
jmp 0x1f3fd
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x1f40c
jmp 0x1f4b9
movq 0x5bba5(%rip), %rdi     # 0x7afb8
leaq 0x381fd(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xc0(%rbp)
jmp 0x1f428
leaq -0x78(%rbp), %rdi
callq 0x1fe80
movq %rax, -0xc8(%rbp)
jmp 0x1f43a
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0xd0(%rbp)
jmp 0x1f458
movq -0xd0(%rbp), %rdi
leaq 0x381b4(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xd8(%rbp)
jmp 0x1f474
leaq -0x78(%rbp), %rdi
callq 0x1fe80
movq %rax, -0xe0(%rbp)
jmp 0x1f486
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x1f49e
jmp 0x1f4a0
leaq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
xorl %edx, %edx
callq 0x1fec0
jmp 0x1f4b4
jmp 0x1f3d1
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_non_member_overloads.cpp
// Function: test_map_non_member_overloads_swap()
void
test_map_non_member_overloads_swap()
{
	ft::map<char, int> first, second;

	first['x'] = 100;
	first['y'] = 200;

	second['a'] = 11;
	second['b'] = 22;
	second['c'] = 33;

	first.swap(second);

	print_map_info(first);
	print_map_info(second);

	swap(first, second);

	print_map_info(first);
	print_map_info(second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1bf70
leaq -0x60(%rbp), %rdi
callq 0x1bf70
movq -0x88(%rbp), %rdi
movb $0x78, -0x61(%rbp)
leaq -0x61(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x80(%rbp)
jmp 0x2119e
movq -0x80(%rbp), %rax
movl $0x64, (%rax)
movb $0x79, -0x75(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x75(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x90(%rbp)
jmp 0x211c2
movq -0x90(%rbp), %rax
movl $0xc8, (%rax)
movb $0x61, -0x76(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x76(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x98(%rbp)
jmp 0x211e9
movq -0x98(%rbp), %rax
movl $0xb, (%rax)
movb $0x62, -0x77(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x77(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xa0(%rbp)
jmp 0x21210
movq -0xa0(%rbp), %rax
movl $0x16, (%rax)
movb $0x63, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0xa8(%rbp)
jmp 0x21237
movq -0xa8(%rbp), %rax
movl $0x21, (%rax)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x21500
movq -0xb0(%rbp), %rdi
callq 0x1c020
jmp 0x21266
leaq -0x60(%rbp), %rdi
callq 0x1c020
jmp 0x21271
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x21530
movq -0xb8(%rbp), %rdi
callq 0x1c020
jmp 0x21293
leaq -0x60(%rbp), %rdi
callq 0x1c020
jmp 0x2129e
leaq -0x60(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x70(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_allocator.cpp
// Function: test_map_allocator_cplusplus()
void
test_map_allocator_cplusplus()
{
	int psize;
	ft::map<char, int> mymap;
	ft::pair<char const,int>* p;

	// allocate an array of 5 elements using mymap's allocator:
	p=mymap.get_allocator().allocate(5);

	// assign some values to array
	psize = sizeof(ft::map<char, int>::value_type) * 5;

	std::cout << "The allocated array has a size of " << psize << " bytes." << std::endl;

	mymap.get_allocator().deallocate(p, 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1bf70
movq -0x70(%rbp), %rsi
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x22510
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x5, %esi
callq 0x22540
movq %rax, -0x60(%rbp)
jmp 0x21f21
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x225a0
movl $0x28, -0x4(%rbp)
movq 0x59078(%rip), %rdi     # 0x7afb8
leaq 0x3570c(%rip), %rsi     # 0x57653
callq 0x31e0
movq %rax, -0x78(%rbp)
jmp 0x21f52
movq -0x78(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x3350
movq %rax, -0x80(%rbp)
jmp 0x21f64
movq -0x80(%rbp), %rdi
leaq 0x35707(%rip), %rsi     # 0x57676
callq 0x31e0
movq %rax, -0x88(%rbp)
jmp 0x21f7d
movq -0x88(%rbp), %rdi
movq 0x5900d(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x21f92
leaq -0x55(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x22510
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x5, %edx
callq 0x225c0
jmp 0x21fbd
leaq -0x55(%rbp), %rdi
callq 0x225a0
leaq -0x38(%rbp), %rdi
callq 0x1c230
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x225a0
jmp 0x22012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x22012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x225a0
leaq -0x38(%rbp), %rdi
callq 0x1c230
movq -0x50(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_allocator.cpp
// Function: test_map_allocator_custom_allocator()
void
test_map_allocator_custom_allocator()
{
	ft::map<int, char, ft::less<int>, custom_allocator<ft::pair<int const, char> > > map;

	map.insert(ft::make_pair(-42, 'z'));
	map.insert(ft::make_pair(0, 'd'));
	map.insert(ft::make_pair(42, 'a'));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x225f0
movl $0xffffffd6, -0x3c(%rbp) # imm = 0xFFFFFFD6
movb $0x7a, -0x3d(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x3d(%rbp), %rsi
callq 0x22650
movq %rax, -0xa8(%rbp)
jmp 0x22065
movq -0xa8(%rbp), %rax
movl %eax, %ecx
movl %ecx, -0x38(%rbp)
shrq $0x20, %rax
movb %al, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22610
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x22094
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl $0x0, -0x6c(%rbp)
movb $0x64, -0x6d(%rbp)
leaq -0x6c(%rbp), %rdi
leaq -0x6d(%rbp), %rsi
callq 0x22650
movq %rax, -0xc0(%rbp)
jmp 0x220c9
movq -0xc0(%rbp), %rax
movl %eax, %ecx
movl %ecx, -0x68(%rbp)
shrq $0x20, %rax
movb %al, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x22610
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x220f8
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
movl $0x2a, -0x8c(%rbp)
movb $0x61, -0x8d(%rbp)
leaq -0x8c(%rbp), %rdi
leaq -0x8d(%rbp), %rsi
callq 0x22650
movq %rax, -0xd8(%rbp)
jmp 0x22139
movq -0xd8(%rbp), %rax
movl %eax, %ecx
movl %ecx, -0x88(%rbp)
shrq $0x20, %rax
movb %al, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x22610
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x22171
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22680
jmp 0x22196
leaq -0x30(%rbp), %rdi
callq 0x227c0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x227c0
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_allocator.cpp
// Function: test_map_allocator_strings_custom_allocator()
void
test_map_allocator_strings_custom_allocator()
{
	ft::map<std::string, std::string, ft::less<std::string>, custom_allocator<ft::pair<std::string const, std::string> > > map;

	map.insert(ft::make_pair("hello", "h"));
	map.insert(ft::make_pair("world", "w"));
	map.insert(ft::make_pair("! :)", "!"));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
leaq -0x30(%rbp), %rdi
callq 0x227e0
leaq 0x34e72(%rip), %rdi     # 0x5705d
leaq 0x35211(%rip), %rsi     # 0x57403
callq 0x22840
movq %rdx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x22207
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22800
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x22239
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
leaq 0x3557a(%rip), %rdi     # 0x577ce
leaq 0x35423(%rip), %rsi     # 0x5767e
callq 0x22840
movq %rdx, -0xd0(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x22270
movq -0xd0(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x22800
movb %dl, -0xd9(%rbp)
movq %rax, -0xd8(%rbp)
jmp 0x222a2
movb -0xd9(%rbp), %al
movq -0xd8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq 0x34da6(%rip), %rdi     # 0x57063
leaq 0x35292(%rip), %rsi     # 0x57556
callq 0x22880
movq %rdx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
jmp 0x222d9
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x22800
movb %dl, -0xf9(%rbp)
movq %rax, -0xf8(%rbp)
jmp 0x22314
movb -0xf9(%rbp), %al
movq -0xf8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x228c0
jmp 0x22339
leaq -0x30(%rbp), %rdi
callq 0x22a10
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22a10
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_insert_range()
void
test_map_modifiers_insert_range()
{
	ft::map<int, int> map1;
	ft::map<int, int> map2;

	map2.insert(map1.begin(), map1.end());

	print_map_info(map1);
	print_map_info(map2);

	srand(g_seed);

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

	map2.insert(map1.begin(), map1.end());

	print_map_info(map1);
	print_map_info(map2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x14da0
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x14da0
movq -0xc0(%rbp), %rdi
callq 0x2b0c0
movq -0xc0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x18830
movq -0xb8(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x2b0f0
jmp 0x28931
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2893c
leaq -0x60(%rbp), %rdi
callq 0x2abf0
jmp 0x28947
leaq 0x528ba(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x80(%rbp)
cmpl $0x64, -0x80(%rbp)
jge 0x28a25
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
callq 0x1fd20
movq %rax, -0xc8(%rbp)
jmp 0x289b0
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x14f10
movb %dl, -0xd1(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x289dd
movb -0xd1(%rbp), %al
movq -0xd0(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x2895c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x28a99
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x2b0c0
movq -0xe0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x18830
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x2b0f0
jmp 0x28a68
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x28a73
leaq -0x60(%rbp), %rdi
callq 0x2abf0
jmp 0x28a7e
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xe0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_insert_iterators_validity()
void
test_map_modifiers_insert_iterators_validity()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator it;

	map.insert(ft::make_pair(42, 0));
	it = map.find(42);

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

	print_map_info(map);

	if (it == map.find(42))
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq -0x38(%rbp), %rdi
callq 0x2b030
movl $0x2a, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
leaq -0x44(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14f50
movq %rax, -0xb0(%rbp)
jmp 0x28af1
movq -0xb0(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14f10
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x28b18
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movl $0x2a, -0x74(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x2b050
movq %rax, -0xc8(%rbp)
jmp 0x28b49
movq -0xc8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x78(%rbp)
cmpl $0x14, -0x78(%rbp)
jge 0x28c20
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x1fd20
movq %rax, -0xd0(%rbp)
jmp 0x28bb7
movq -0xd0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x14f10
movb %dl, -0xd9(%rbp)
movq %rax, -0xd8(%rbp)
jmp 0x28bde
movb -0xd9(%rbp), %al
movq -0xd8(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x28b63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x28cb7
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x28c2b
movl $0x2a, -0xa4(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
callq 0x2b050
movq %rax, -0xe8(%rbp)
jmp 0x28c4e
movq -0xe8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x186b0
testb $0x1, %al
jne 0x28c72
jmp 0x28ca5
movq 0x5233f(%rip), %rdi     # 0x7afb8
leaq 0x2e46d(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xf0(%rbp)
jmp 0x28c8e
movq -0xf0(%rbp), %rdi
movq 0x522fc(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x28ca3
jmp 0x28ca5
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_position()
void
test_map_modifiers_erase_position()
{
	ft::map<int, int> map;

	srand(g_seed);

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

	print_map_info(map);

	map.erase(map.find(42));
	map.erase(map.find(20));

	print_map_info(map);

	while (!map.empty())
		map.erase(map.begin());

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x5218d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x2913a
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0xa8(%rbp)
jmp 0x290d7
movq -0xa8(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x290fe
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x2925e
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x29145
movl $0x2a, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x2b050
movq %rax, -0xc0(%rbp)
jmp 0x29162
movq -0xc0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2b2b0
movq %rax, -0xc8(%rbp)
jmp 0x29183
movq -0xc8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x14, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x2b050
movq %rax, -0xd0(%rbp)
jmp 0x291b1
movq -0xd0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2b2b0
movq %rax, -0xd8(%rbp)
jmp 0x291d2
movq -0xd8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x291eb
jmp 0x291ed
leaq -0x30(%rbp), %rdi
callq 0x2b2f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x291fe
jmp 0x29241
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2b0c0
movq -0xe8(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rsi
callq 0x2b2b0
movq %rax, -0xe0(%rbp)
jmp 0x29231
movq -0xe0(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x291ed
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2924c
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)