LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_element_access.cpp
// Function: test_map_element_access_at()
void
test_map_element_access_at()
{
	ft::map<std::string, int> mymap;
	mymap.insert(ft::make_pair("alpha", 0));
	mymap.insert(ft::make_pair("beta", 0));
	mymap.insert(ft::make_pair("gamma", 0));

	mymap.at("alpha") = 10;
	mymap.at("beta") = 20;
	mymap.at("gamma") = 30;

	print_map_info(mymap);

	mymap.at("delta") = 30;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x58(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x16f3d(%rip), %rax     # 0x26716
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xff82
leaq 0x16f29(%rip), %rax     # 0x2671c
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl $0x0, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xff82
leaq 0x16f10(%rip), %rax     # 0x26721
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl $0x0, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xff82
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16edf(%rip), %rsi     # 0x26716
leaq 0x16edd(%rip), %rdx     # 0x2671b
leaq -0x30(%rbp), %rdi
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfa8c
movl $0xa, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xf868
callq 0x21b0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x16ea6(%rip), %rsi     # 0x2671c
leaq 0x16ea3(%rip), %rdx     # 0x26720
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfa8c
movl $0x14, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xf8a3
callq 0x21b0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x16e70(%rip), %rsi     # 0x26721
leaq 0x16e6e(%rip), %rdx     # 0x26726
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfa8c
movl $0x1e, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xf8de
callq 0x21b0
leaq -0x60(%rbp), %rdi
callq 0xfaea
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x16e32(%rip), %rsi     # 0x26727
leaq 0x16e30(%rip), %rdx     # 0x2672c
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfa8c
movl $0x1e, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xf922
callq 0x21b0
leaq -0x60(%rbp), %rdi
callq 0xfcc8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xf942
jmp 0xf95b
jmp 0xf95b
jmp 0xf942
jmp 0xf95b
jmp 0xf942
jmp 0xf95b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xf95e
callq 0x21b0
jmp 0xf95e
jmp 0xf95b
jmp 0xf95b
jmp 0xf95b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xfcc8
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq -0x80(%rbp), %rbx
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x1300e
leaq -0x88(%rbp), %rdi
callq 0x129cf
leaq -0x58(%rbp), %rdi
callq 0x129cf
leaq 0x232ae(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
xorl %r12d, %r12d
leaq -0x88(%rbp), %r14
leaq -0x28(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0x64, %r12
jne 0x10f47
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rbx, %rdx
callq 0x1300e
leaq -0x88(%rbp), %rdi
callq 0x129cf
leaq -0x58(%rbp), %rdi
callq 0x129cf
leaq -0x58(%rbp), %rdi
callq 0xaf10
leaq -0x88(%rbp), %rdi
callq 0xaf10
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10fd7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xaf10
leaq -0x88(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq -0x30(%rbp), %rsi
movq $0x2a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xb43c
movq -0x50(%rbp), %rdi
movq %r15, %r12
testq %rdi, %rdi
je 0x11085
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x2a, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x11048
movq %r15, %r12
cmpq %r15, %rdx
je 0x11085
cmpl $0x2a, %esi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovgeq %r15, %rdx
movq %rdx, %r12
xorl %r13d, %r13d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r13, %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r13
cmpq $0x14, %r13
jne 0x11090
leaq -0x60(%rbp), %rdi
callq 0x129cf
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x11123
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x2a, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x110ec
cmpq %r15, %rdx
je 0x11123
cmpl $0x2a, %esi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovlq %rdx, %r15
cmpq %r15, %r12
jne 0x1116e
movq 0x22ea1(%rip), %rbx     # 0x33fd0
leaq 0x14ff9(%rip), %rsi     # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x22e6f(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1118a
jmp 0x1118a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x48(%rbp), %rbx
movl $0x0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x22e2c(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x50(%rbp), %r14
leaq -0x58(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x58(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0x64, %r12
jne 0x113c3
leaq -0x50(%rbp), %rdi
callq 0x129cf
movq -0x40(%rbp), %r8
movq %rbx, %rsi
testq %r8, %r8
je 0x11460
movq %rbx, %rdx
movq %rdx, %rax
movq %r8, %rcx
movl 0x20(%r8), %edi
xorl %esi, %esi
cmpl $0x2a, %edi
setl %sil
movq %r8, %rdx
cmovlq %rax, %rdx
movq 0x10(%r8,%rsi,8), %r8
testq %r8, %r8
jne 0x11422
movq %rbx, %rsi
cmpq %rbx, %rdx
je 0x11460
cmpl $0x2a, %edi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovgeq %rbx, %rdx
movq %rdx, %rsi
leaq -0x50(%rbp), %rdi
callq 0x13372
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x114ac
movq %rbx, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x14, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x11475
cmpq %rbx, %rdx
je 0x114ac
cmpl $0x14, %esi
cmovlq %rax, %rcx
cmpl $0x15, 0x20(%rcx)
cmovlq %rdx, %rbx
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x13372
leaq -0x50(%rbp), %rdi
callq 0x129cf
leaq -0x50(%rbp), %rbx
cmpq $0x0, -0x28(%rbp)
je 0x114da
movq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x13372
jmp 0x114c5
leaq -0x50(%rbp), %rdi
callq 0x129cf
leaq -0x50(%rbp), %rdi
callq 0xaf10
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11501
jmp 0x11501
jmp 0x11501
jmp 0x11501
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_value()
void
test_map_modifiers_erase_value()
{
	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);

	std::cout << map.erase(4) << std::endl;
	std::cout << map.erase(4) << std::endl;
	std::cout << map.erase(2) << std::endl;

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r15, 0x20(%rax)
leaq 0x22c9a(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x50(%rbp), %rbx
leaq -0x20(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r15
cmpq $0x64, %r15
jne 0x11555
leaq -0x50(%rbp), %rdi
callq 0x129cf
leaq -0x20(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x133b4
leaq -0x50(%rbp), %rbx
movq 0x28(%rbx), %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13436
subq 0x28(%rbx), %r14
movq 0x229fa(%rip), %rdi     # 0x33fd0
movq %r14, %rsi
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x20(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x133b4
leaq -0x50(%rbp), %rbx
movq 0x28(%rbx), %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13436
subq 0x28(%rbx), %r14
movq 0x22997(%rip), %rdi     # 0x33fd0
movq %r14, %rsi
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x20(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x133b4
leaq -0x50(%rbp), %rbx
movq 0x28(%rbx), %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13436
subq 0x28(%rbx), %r14
movq 0x22934(%rip), %rdi     # 0x33fd0
movq %r14, %rsi
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x50(%rbp), %rdi
callq 0x129cf
leaq -0x50(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x116f3
jmp 0x116f3
jmp 0x116f3
jmp 0x116f3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_range()
void
test_map_modifiers_erase_range()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator it;

	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.end());

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
movl $0x0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x22aa6(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x58(%rbp), %r14
leaq -0x28(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0x64, %r12
jne 0x11749
leaq -0x58(%rbp), %rdi
callq 0x129cf
movq -0x48(%rbp), %r8
movq %rbx, %rsi
testq %r8, %r8
je 0x117e6
movq %rbx, %rdx
movq %rdx, %rax
movq %r8, %rcx
movl 0x20(%r8), %edi
xorl %esi, %esi
cmpl $0x2a, %edi
setl %sil
movq %r8, %rdx
cmovlq %rax, %rdx
movq 0x10(%r8,%rsi,8), %r8
testq %r8, %r8
jne 0x117a8
movq %rbx, %rsi
cmpq %rbx, %rdx
je 0x117e6
cmpl $0x2a, %edi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovgeq %rbx, %rdx
movq %rdx, %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13436
movq %r14, %rdi
callq 0x129cf
leaq -0x58(%rbp), %rdi
callq 0xaf10
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11815
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_iterators_validity()
void
test_map_modifiers_erase_iterators_validity()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator it;

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

	print_map_info(map);

	it = map.find(9);

	for (int i = 0; i < 9; i++)
		map.erase(i);

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

	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
movl $0x0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %r12, 0x20(%r15)
leaq -0x58(%rbp), %rbx
leaq -0x28(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x28(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r12
cmpq $0xa, %r12
jne 0x1185e
leaq -0x58(%rbp), %rdi
callq 0x129cf
movq -0x48(%rbp), %rdi
movq %r15, %r12
testq %rdi, %rdi
je 0x118fa
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x9, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x118bd
movq %r15, %r12
cmpq %r15, %rdx
je 0x118fa
cmpl $0x9, %esi
cmovlq %rax, %rcx
cmpl $0xa, 0x20(%rcx)
cmovgeq %r15, %rdx
movq %rdx, %r12
leaq -0x28(%rbp), %rbx
movl $0x0, (%rbx)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x133b4
movq %r14, %rdi
movq %rax, %rsi
callq 0x13436
movl -0x28(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x8, %eax
jl 0x11908
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1196f
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x9, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x11938
cmpq %r15, %rdx
je 0x1196f
cmpl $0x9, %esi
cmovlq %rax, %rcx
cmpl $0xa, 0x20(%rcx)
cmovlq %rdx, %r15
cmpq %r15, %r12
jne 0x119ba
movq 0x22655(%rip), %rbx     # 0x33fd0
leaq 0x147ad(%rip), %rsi     # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x22623(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x129cf
leaq -0x58(%rbp), %rdi
callq 0xaf10
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x119dd
jmp 0x119dd
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_clear_int()
void
test_map_modifiers_clear_int()
{
	ft::map<int, int> mymap;

	mymap[42] = 42;
	mymap[0] = 3;
	mymap[-42] = 100;

	print_map_info(mymap);

	mymap.clear();

	print_map_info(mymap);

	mymap[-42] = 42;
	mymap[-1] = 3;

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12c5e
movl $0x2a, (%rax)
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12c5e
movl $0x3, (%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x12c5e
movl $0x64, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x129cf
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x134b8
movq %rbx, %rdi
callq 0x129cf
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x12c5e
movl $0x2a, (%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
callq 0x12c5e
movl $0x3, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x129cf
leaq -0x40(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x12361
jmp 0x12361
jmp 0x12361
jmp 0x12361
jmp 0x12361
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_clear_string()
void
test_map_modifiers_clear_string()
{
	ft::map<int, std::string> mymap;

	mymap[42] = "test";
	mymap[0] = "hello";
	mymap[-42] = "world";

	print_map_info(mymap);

	mymap.clear();

	print_map_info(mymap);

	mymap[-42] = "hi";
	mymap[-1] = "there";

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12cc6
movq 0x8(%rax), %rdx
leaq 0x13d99(%rip), %rcx     # 0x26151
movl $0x4, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x22c0
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12cc6
movq 0x8(%rax), %rdx
leaq 0x13ca1(%rip), %rcx     # 0x26087
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x22c0
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x12cc6
movq 0x8(%rax), %rdx
leaq 0x143da(%rip), %rcx     # 0x267ee
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x22c0
leaq -0x40(%rbp), %rdi
callq 0x12b14
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x13708
movq %rbx, %rdi
callq 0x12b14
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x12cc6
movq 0x8(%rax), %rdx
leaq 0x143c8(%rip), %rcx     # 0x26827
movl $0x2, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x22c0
leaq -0xc(%rbp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
callq 0x12cc6
movq 0x8(%rax), %rdx
leaq 0x1439d(%rip), %rcx     # 0x2682a
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x22c0
leaq -0x40(%rbp), %rdi
callq 0x12b14
leaq -0x40(%rbp), %rdi
callq 0x12d2e
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x124c0
jmp 0x124c0
jmp 0x124c0
jmp 0x124c0
jmp 0x124c0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x12d2e
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_observers.cpp
// Function: test_map_observers_key_comp()
void
test_map_observers_key_comp()
{
	ft::map<char, int> mymap;

	ft::map<char, int>::key_compare mycomp = mymap.key_comp();

	mymap['a'] = 100;
	mymap['b'] = 200;
	mymap['c'] = 300;

	std::cout << "mymap contains:";

	char highest = mymap.rbegin()->first;

	ft::map<char, int>::iterator it = mymap.begin();
	do
	{
		std::cout << " [" << it->first << "] = " << it->second;
	} while (mycomp((*it++).first, highest));
	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
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0x64, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0xc8, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0x12c, (%rax)          # imm = 0x12C
movq 0x2081a(%rip), %rdi     # 0x33fd0
leaq 0x13074(%rip), %rsi     # 0x26831
movl $0xf, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movb 0x20(%rax), %r12b
movq -0x48(%rbp), %r14
movq 0x207f2(%rip), %rbx     # 0x33fd0
leaq 0x12e55(%rip), %r13     # 0x2663a
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x12e43(%rip), %rsi     # 0x26637
callq 0x2230
movb 0x20(%r14), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2230
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movl 0x24(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %r14, %rdi
callq 0x2160
cmpb %r12b, 0x20(%r14)
movq %rax, %r14
jl 0x137e5
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x20771(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xcfe2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1388e
jmp 0x1388e
jmp 0x1388e
jmp 0x1388e
jmp 0x1388e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_observers.cpp
// Function: test_map_observers_value_comp()
void
test_map_observers_value_comp()
{
	ft::map<char, int> mymap;

	mymap['x'] = 1001;
	mymap['y'] = 2002;
	mymap['z'] = 3003;

	std::cout << "mymap contains:\n";

	ft::pair<char, int> highest = *mymap.rbegin();          // last element

	ft::map<char, int>::iterator it = mymap.begin();
	do {
		std::cout << " [" << it->first << "] = " << it->second;
	} while ( mymap.value_comp()(*it++, highest) );
	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
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x78, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0x3e9, (%rax)          # imm = 0x3E9
leaq -0x29(%rbp), %rsi
movb $0x79, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0x7d2, (%rax)          # imm = 0x7D2
leaq -0x29(%rbp), %rsi
movb $0x7a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xcf7a
movl $0xbbb, (%rax)          # imm = 0xBBB
movq 0x206b8(%rip), %rdi     # 0x33fd0
leaq 0x12f22(%rip), %rsi     # 0x26841
movl $0x10, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movb 0x20(%rax), %r12b
movq -0x48(%rbp), %r14
movq 0x20690(%rip), %rbx     # 0x33fd0
leaq 0x12cf3(%rip), %r13     # 0x2663a
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x12ce1(%rip), %rsi     # 0x26637
callq 0x2230
movb 0x20(%r14), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2230
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movl 0x24(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %r14, %rdi
callq 0x2160
cmpb %r12b, 0x20(%r14)
movq %rax, %r14
jl 0x13947
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2060f(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xcfe2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x139f0
jmp 0x139f0
jmp 0x139f0
jmp 0x139f0
jmp 0x139f0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_range()
void
test_map_constructors_range()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	ft::map<char, int> range(map.begin(), map.end());

	print_map_info(map);
	print_map_info(range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x78(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x203cf(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r12d
leaq -0x80(%rbp), %r14
leaq -0x50(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x13126
incq %r12
cmpq $0x7b, %r12
jne 0x13e26
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x14792
leaq -0x80(%rbp), %rdi
callq 0xcdf9
leaq -0x50(%rbp), %rdi
callq 0xcdf9
leaq -0x50(%rbp), %rdi
callq 0xcfe2
leaq -0x80(%rbp), %rdi
callq 0xcfe2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ec3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xcfe2
jmp 0x13ec6
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_int()
void
test_map_constructors_copy_int()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	{
		ft::map<char, int> cpy1(map);
		ft::map<char, int> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq -0x40(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x202d6(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r15d
leaq -0x48(%rbp), %rbx
leaq -0x78(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x78(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13126
incq %r15
cmpq $0x7b, %r15
jne 0x13f1f
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14c60
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14c60
leaq -0x48(%rbp), %rdi
callq 0xcdf9
leaq -0x78(%rbp), %rdi
callq 0xcdf9
leaq -0xa8(%rbp), %rdi
callq 0xcdf9
leaq -0xa8(%rbp), %rdi
callq 0xcfe2
leaq -0x78(%rbp), %rdi
callq 0xcfe2
leaq -0x48(%rbp), %rdi
callq 0xcfe2
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13fe8
jmp 0x13ff3
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0xcfe2
leaq -0x78(%rbp), %rdi
callq 0xcfe2
jmp 0x13ff6
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_string()
void
test_map_constructors_copy_string()
{
	ft::map<char, std::string> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, ft_itoa(rand() % 10000 - 10000 / 2)));

	{
		ft::map<char, std::string> cpy1(map);
		ft::map<char, std::string> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq -0xb0(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x2019f(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x70(%rbp), %r13
movb $0x61, %bl
leaq -0x48(%rbp), %r12
leaq -0xb8(%rbp), %r14
leaq -0x88(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
leaq -0x58(%rbp), %rdi
callq 0x42b2
movb %bl, -0x88(%rbp)
movq %r13, -0x80(%rbp)
movq -0x58(%rbp), %rax
cmpq %r12, %rax
je 0x140b6
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x140c0
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %r12, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x151c0
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x140f1
callq 0x21b0
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x140ff
callq 0x21b0
incb %bl
cmpb $0x7b, %bl
jne 0x14060
leaq -0x88(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x14e04
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x14e04
leaq -0xb8(%rbp), %rdi
callq 0x147d5
leaq -0x88(%rbp), %rdi
callq 0x147d5
leaq -0x58(%rbp), %rdi
callq 0x147d5
leaq -0x58(%rbp), %rdi
callq 0xfc34
leaq -0x88(%rbp), %rdi
callq 0xfc34
leaq -0xb8(%rbp), %rdi
callq 0xfc34
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14194
jmp 0x141a2
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xfc34
leaq -0x88(%rbp), %rdi
callq 0xfc34
jmp 0x141c6
movq %rax, %rbx
jmp 0x141c6
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x141b8
callq 0x21b0
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x141c6
callq 0x21b0
leaq -0xb8(%rbp), %rdi
callq 0xfc34
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_char()
void
test_map_constructors_custom_compare_char()
{
	ft::map<char, int, greater<char> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1ffd6(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r15d
leaq -0x50(%rbp), %rbx
leaq -0x20(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x152be
incq %r15
cmpq $0x7b, %r15
jne 0x1421f
leaq -0x50(%rbp), %rdi
callq 0x1495a
leaq -0x50(%rbp), %rdi
callq 0x15024
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1428a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x15024
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_string()
void
test_map_constructors_custom_compare_string()
{
	ft::map<std::string, char, greater<std::string> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(ft_itoa(rand() % 10000 - 10000 / 2), i));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x98(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1ff0b(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %r13
movb $0x61, %bl
leaq -0x38(%rbp), %r12
leaq -0xa0(%rbp), %r14
leaq -0x70(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
leaq -0x48(%rbp), %rdi
callq 0x42b2
movq %r13, -0x70(%rbp)
movq -0x48(%rbp), %rax
cmpq %r12, %rax
je 0x14341
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x1434b
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %r12, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movb %bl, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x15402
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x1437f
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1438d
callq 0x21b0
incb %bl
cmpb $0x7b, %bl
jne 0x142f1
leaq -0xa0(%rbp), %rdi
callq 0x14adb
leaq -0xa0(%rbp), %rdi
callq 0x1507c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x143c1
movq %rax, %rbx
jmp 0x143e5
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x143d7
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x143e5
callq 0x21b0
leaq -0xa0(%rbp), %rdi
callq 0x1507c
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_cplusplus()
void
test_map_constructors_cplusplus()
{
	ft::map<char, int> first;

	first['a'] = 10;
	first['b'] = 30;
	first['c'] = 50;
	first['d'] = 70;

	ft::map<char, int> second(first.begin(), first.end());

	ft::map<char, int> third(second);

	ft::map<char, int, classcomp> fourth;

	bool(*fn_pt)(char, char) = fncomp;
	ft::map<char, int, bool(*)(char, char)> fifth(fn_pt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xf8, %rsp
leaq -0x60(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x38(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xcf7a
movl $0xa, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xcf7a
movl $0x1e, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xcf7a
movl $0x32, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xcf7a
movl $0x46, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x14792
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14c60
leaq -0xc0(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x71b(%rip), %rax      # 0x13da0
leaq -0x90(%rbp), %rdx
movq %rax, -0x8(%rdx)
movl %ecx, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rcx, 0x20(%rdx)
leaq -0x98(%rbp), %rdi
callq 0x15110
leaq -0xc8(%rbp), %rdi
callq 0x15168
leaq -0xf8(%rbp), %rdi
callq 0xcfe2
leaq -0x38(%rbp), %rdi
callq 0xcfe2
leaq -0x68(%rbp), %rdi
callq 0xcfe2
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xcfe2
jmp 0x14531
jmp 0x1452e
jmp 0x1452e
jmp 0x1452e
jmp 0x1452e
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_constructors_base()
void
test_map_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;

	iter_type from(map.begin());
	iter_type cpy(from);

	if (from == cpy)
		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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1f0
addq %r13, %r15
decq %r12
jne 0x15643
movq 0x1e96f(%rip), %rbx     # 0x33fd0
leaq 0x11e2e(%rip), %rsi     # 0x27496
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e93d(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe198
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x156ba
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe198
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_star()
void
test_map_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;

	iter_type from(map.begin());

	std::cout << "[" << from->first << "] = " << 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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1f0
addq %r13, %r15
decq %r12
jne 0x1571d
movq -0x48(%rbp), %r14
movq 0x1e891(%rip), %rdi     # 0x33fd0
leaq 0x10ef2(%rip), %rsi     # 0x26638
movl $0x1, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x1e875(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
leaq 0x10ed0(%rip), %rsi     # 0x2663a
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movb 0x24(%r14), %al
leaq -0x30(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2230
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe198
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x157d2
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe198
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_increment()
void
test_map_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());

	std::cout << "map:";
	while (from != until)
	{
		std::cout << " [" << from->first << "] = " << from->second;
		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), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1f0
addq %r13, %r15
decq %r12
jne 0x15835
movq -0x48(%rbp), %r14
movq 0x1e779(%rip), %rdi     # 0x33fd0
leaq 0x10de4(%rip), %rsi     # 0x26642
movl $0x4, %edx
callq 0x2230
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
je 0x158e1
movq 0x1e758(%rip), %r15     # 0x33fd0
leaq 0x10dbb(%rip), %r13     # 0x2663a
leaq -0x30(%rbp), %rbx
movl $0x2, %edx
movq %r15, %rdi
leaq 0x10da5(%rip), %rsi     # 0x26637
callq 0x2230
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movb 0x24(%r14), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
jne 0x15883
movq 0x1e6e8(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e6cd(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe198
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1592c
jmp 0x1592c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe198
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_decrement()
void
test_map_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;

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

	iter_type it(begin);
	while (it != end)
		std::cout << " [" << it->first << "] = " << (it++)->second;
	std::cout << std::endl;

	while (it != begin)
		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), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1f0
addq %r13, %r15
decq %r12
jne 0x1598f
movq -0x48(%rbp), %r13
movq %r13, %r12
leaq -0x58(%rbp), %rax
cmpq %rax, %r13
je 0x15a24
movq 0x1e613(%rip), %r14     # 0x33fd0
movq %r13, %rbx
movl $0x2, %edx
movq %r14, %rdi
leaq 0x10c68(%rip), %rsi     # 0x26637
callq 0x2230
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0x10c49(%rip), %rsi     # 0x2663a
callq 0x2230
movq %rbx, %rdi
callq 0x2160
movq %rax, %r12
movb 0x24(%rbx), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2230
movq %r12, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %r12
jne 0x159c0
movq 0x1e5a5(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e58a(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r13, %r12
je 0x15ac1
movq 0x1e571(%rip), %r15     # 0x33fd0
leaq -0x30(%rbp), %r14
movl $0x2, %edx
movq %r15, %rdi
leaq 0x10bc5(%rip), %rsi     # 0x26637
callq 0x2230
movq %r12, %rdi
callq 0x2220
movq %rax, %r12
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0x10b9b(%rip), %rsi     # 0x2663a
callq 0x2230
movb 0x24(%r12), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
cmpq %r13, %r12
jne 0x15a63
movq 0x1e508(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e4ed(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe198
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15b10
jmp 0x15b10
jmp 0x15b10
jmp 0x15b10
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe198
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_empty_maps()
void
test_map_iterators_empty_maps()
{
	ft::map<int, int> map;
	ft::map<int, int> const const_map;

	if (map.begin() == map.end())
		std::cout << "correct" << std::endl;

	if (const_map.begin() == const_map.end())
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x68(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x38(%rbp), %r14
movl %ecx, (%r14)
movq %rcx, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rcx, 0x20(%r14)
movq 0x1e46b(%rip), %rbx     # 0x33fd0
leaq 0x105c3(%rip), %rsi     # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e439(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r14, -0x28(%rbp)
jne 0x15bf0
movq 0x1e41f(%rip), %rbx     # 0x33fd0
leaq 0x10577(%rip), %rsi     # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e3ed(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x40(%rbp), %rdi
callq 0xaf10
leaq -0x70(%rbp), %rdi
callq 0xaf10
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xaf10
leaq -0x70(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340