LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_100_size_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x252b2(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0x64, %r12
je 0xcf69
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xcf3c
movq 0x25048(%rip), %r14     # 0x31fb8
leaq 0x14692(%rip), %r15     # 0x21609
leaq 0x1468e(%rip), %r12     # 0x2160c
cmpq -0x48(%rbp), %rbx
je 0xcfd3
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3130
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3130
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3130
movq %rax, %rbx
jmp 0xcf7e
movq 0x24fde(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcffb
jmp 0xcffb
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x25198(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0xa, %r12
je 0xd083
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xd056
movq 0x24f2e(%rip), %r14     # 0x31fb8
leaq 0x14578(%rip), %r15     # 0x21609
leaq 0x14574(%rip), %r12     # 0x2160c
cmpq -0x48(%rbp), %rbx
je 0xd0ed
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3130
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3130
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3130
movq %rax, %rbx
jmp 0xd098
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd107
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators()
void
test_map_reverse_iterators()
{
	test_wrapper(test_map_reverse_iterators_constructors_base, "constructors base");
	test_wrapper(test_map_reverse_iterators_operator_star, "operator*()");
	test_wrapper(test_map_reverse_iterators_operator_increment, "operator++()");
	test_wrapper(test_map_reverse_iterators_operator_decrement, "operator--()");
	test_wrapper(test_map_reverse_iterators_empty_maps, "empty maps");
	test_wrapper(test_map_reverse_iterators_100_size_map, "100 size map");
	test_wrapper(test_map_reverse_iterators_100_size_const_map, "100 size const map");
	test_wrapper(test_map_reverse_iterators_copy, "copy");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x141b5(%rip), %rsi     # 0x212e3
leaq -0x110(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x861(%rip), %rdi      # 0xc8e4
leaq -0x110(%rbp), %rsi
callq 0x20ca4
leaq -0x110(%rbp), %rdi
callq 0x30d0
leaq 0x14191(%rip), %rsi     # 0x212f5
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x7ea(%rip), %rdi      # 0xc991
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0x14167(%rip), %rsi     # 0x21301
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x733(%rip), %rdi      # 0xca7e
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x1413e(%rip), %rsi     # 0x2130e
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x646(%rip), %rdi      # 0xcba1
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x14413(%rip), %rsi     # 0x21619
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x4ef(%rip), %rdi      # 0xcd2e
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x143e8(%rip), %rsi     # 0x21624
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x475(%rip), %rdi      # 0xcddb
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x143c8(%rip), %rsi     # 0x21631
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x388(%rip), %rdi      # 0xcef5
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x140b0(%rip), %rsi     # 0x21346
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x29b(%rip), %rdi      # 0xd00f
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
jmp 0xd329
jmp 0xd330
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x30d0
jmp 0xd333
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_non_member_overloads.cpp
// Function: test_map_non_member_overloads_relation_operators()
void
test_map_non_member_overloads_relation_operators()
{
	ft::map<char, int> foo, bar;
	foo['a'] = 100;
	foo['b'] = 200;
	bar['a'] = 10;
	bar['z'] = 1000;

	if (foo == bar) std::cout << "foo and bar are equal" << std::endl;
	if (foo != bar) std::cout << "foo and bar are not equal" << std::endl;
	if (foo < bar) std::cout << "foo is less than bar" << std::endl;
	if (foo > bar) std::cout << "foo is greater than bar" << std::endl;
	if (foo <= bar) std::cout << "foo is less than or equal to bar" << std::endl;
	if (foo >= bar) std::cout << "foo is greater than or equal to bar" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0xc29e
movl $0x64, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0xc29e
movl $0xc8, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc29e
movl $0xa, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x7a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc29e
movl $0x3e8, (%rax)          # imm = 0x3E8
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd8fa
testb %al, %al
je 0xd5fb
movq 0x249d1(%rip), %rdi     # 0x31fb8
leaq 0x13e34(%rip), %rsi     # 0x21422
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd8ca
testb %al, %al
je 0xd627
movq 0x249a5(%rip), %rdi     # 0x31fb8
leaq 0x13e1e(%rip), %rsi     # 0x21438
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd979
testb %al, %al
je 0xd653
movq 0x24979(%rip), %rdi     # 0x31fb8
leaq 0x13e0c(%rip), %rsi     # 0x21452
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xd979
testb %al, %al
je 0xd67f
movq 0x2494d(%rip), %rdi     # 0x31fb8
leaq 0x13df5(%rip), %rsi     # 0x21467
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd8d7
testb %al, %al
je 0xd6ab
movq 0x24921(%rip), %rdi     # 0x31fb8
leaq 0x13de1(%rip), %rsi     # 0x2147f
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd8ed
testb %al, %al
je 0xd6d7
movq 0x248f5(%rip), %rdi     # 0x31fb8
leaq 0x13dd6(%rip), %rsi     # 0x214a0
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0xd6f8
jmp 0xd6f8
jmp 0xd6f8
jmp 0xd6f8
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
pushq %rbx
subq $0x68, %rsp
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x9(%rbp), %rsi
movb $0x78, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0xc29e
movl $0x64, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x79, (%rsi)
leaq -0x70(%rbp), %rdi
callq 0xc29e
movl $0xc8, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc29e
movl $0xb, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc29e
movl $0x16, (%rax)
leaq -0x9(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc29e
movl $0x21, (%rax)
leaq -0x70(%rbp), %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xda4a
movq %rbx, %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xda4a
movq %rbx, %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0xd81f
jmp 0xd81f
jmp 0xd81f
jmp 0xd81f
jmp 0xd81f
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
pushq %rbx
subq $0x38, %rsp
leaq -0x30(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0x28
popq %rdi
callq 0x31e0
movq %rax, %rbx
movq 0x244a4(%rip), %rdi     # 0x31fb8
leaq 0x13b2a(%rip), %rsi     # 0x21645
callq 0x31d0
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x3320
leaq 0x13b36(%rip), %rsi     # 0x21668
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x31a0
leaq -0x38(%rbp), %rdi
callq 0xc2f0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xdb5c
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x10(%rbp), %rsi
movb $0x7a, 0x4(%rsi)
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0xe022
leaq -0x10(%rbp), %rsi
movb $0x64, 0x4(%rsi)
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe022
leaq -0x10(%rbp), %rsi
movb $0x61, 0x4(%rsi)
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe022
leaq -0x40(%rbp), %rdi
callq 0xdd88
leaq -0x40(%rbp), %rdi
callq 0xdf34
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xdbf3
jmp 0xdbf3
jmp 0xdbf3
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xdf34
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x48, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x1342d(%rip), %rax     # 0x2105d
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x137a5(%rip), %rax     # 0x213e3
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xe178
leaq 0x13b6e(%rip), %rax     # 0x217c0
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x13a10(%rip), %rax     # 0x21670
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xe178
leaq 0x133ef(%rip), %rax     # 0x21063
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x138c6(%rip), %rax     # 0x21548
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xe178
leaq -0x48(%rbp), %rdi
callq 0xde5e
leaq -0x48(%rbp), %rdi
callq 0xdf8a
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0xdcae
jmp 0xdcae
jmp 0xdcae
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xdf8a
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_element_access.cpp
// Function: test_map_element_access_operator_brackets()
void
test_map_element_access_operator_brackets()
{
	ft::map<char, std::string> mymap;

	mymap['a'] = "an element";
	mymap['b'] = "another element";
	mymap['c'] = mymap['b'];

	std::cout << "mymap['a'] is " << mymap['a'] << std::endl;
	std::cout << "mymap['b'] is " << mymap['b'] << std::endl;
	std::cout << "mymap['c'] is " << mymap['c'] << std::endl;
	std::cout << "mymap['d'] is " << mymap['d'] << std::endl;

	std::cout << "mymap now contains " << mymap.size() << " elements." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
leaq 0x13285(%rip), %rsi     # 0x21672
movq %rax, %rdi
callq 0x3340
leaq -0x9(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
leaq 0x13271(%rip), %rsi     # 0x2167d
movq %rax, %rdi
callq 0x3340
leaq -0x9(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rax, %rbx
leaq -0xa(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3100
movq 0x23b6f(%rip), %rdi     # 0x31fb8
leaq 0x1323d(%rip), %rsi     # 0x2168d
callq 0x31d0
movq %rax, %rbx
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x23b36(%rip), %rdi     # 0x31fb8
leaq 0x13213(%rip), %rsi     # 0x2169c
callq 0x31d0
movq %rax, %rbx
leaq -0x9(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x23afd(%rip), %rdi     # 0x31fb8
leaq 0x131e9(%rip), %rsi     # 0x216ab
callq 0x31d0
movq %rax, %rbx
leaq -0x9(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x23ac4(%rip), %rdi     # 0x31fb8
leaq 0x131bf(%rip), %rsi     # 0x216ba
callq 0x31d0
movq %rax, %rbx
leaq -0x9(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xe7a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x23a8b(%rip), %rdi     # 0x31fb8
leaq 0x13195(%rip), %rsi     # 0x216c9
callq 0x31d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x3140
leaq 0x13191(%rip), %rsi     # 0x216dd
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xe916
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
jmp 0xe57c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xe916
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x1312f(%rip), %rax     # 0x216e8
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xecbe
leaq 0x1311a(%rip), %rax     # 0x216ee
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xecbe
leaq 0x13104(%rip), %rax     # 0x216f3
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
leaq -0x60(%rbp), %rdi
callq 0xecbe
leaq 0x130de(%rip), %rsi     # 0x216e8
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7f2
movl $0xa, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq 0x130b4(%rip), %rsi     # 0x216ee
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7f2
movl $0x14, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq 0x13089(%rip), %rsi     # 0x216f3
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7f2
movl $0x1e, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x60(%rbp), %rdi
callq 0xe841
leaq 0x13056(%rip), %rsi     # 0x216f9
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe7f2
movl $0x1e, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x60(%rbp), %rdi
callq 0xe98e
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0xe6ea
jmp 0xe6fe
jmp 0xe6fe
jmp 0xe6ea
jmp 0xe6fe
jmp 0xe6ea
jmp 0xe6fe
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0xe701
jmp 0xe6fe
jmp 0xe6fe
jmp 0xe6fe
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe98e
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_insert_with_hint()
void
test_map_modifiers_insert_with_hint()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator hint;
	ft::map<int, int>::iterator ret;

	map.insert(ft::make_pair(10, 42));
	map.insert(ft::make_pair(100, 42));
	map.insert(ft::make_pair(60, 42));

	hint = map.find(10);
	ret = map.insert(hint, ft::make_pair(42, -42));
	std::cout << "Return: " << "[" << ret->first << "] = " << ret->second << std::endl;
	print_map_info(map);

	ret = map.insert(map.begin(), ft::make_pair(0, 42));
	std::cout << "Return: " << "[" << ret->first << "] = " << ret->second << std::endl;
	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movabsq $0x2a00000000, %r14     # imm = 0x2A00000000
leaq 0xa(%r14), %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xad0a
leaq 0x64(%r14), %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xad0a
leaq 0x3c(%r14), %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0xad0a
leaq -0x18(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x110c8
movabsq $-0x29ffffffd6, %rcx    # imm = 0xFFFFFFD60000002A
leaq -0x18(%rbp), %rdx
movq %rcx, (%rdx)
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x110fc
movq %rax, %rbx
movq 0x227b3(%rip), %rdi     # 0x31fb8
leaq 0x118d0(%rip), %rsi     # 0x210dc
callq 0x31d0
leaq 0x11df2(%rip), %rsi     # 0x2160a
movq %rax, %rdi
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x11dda(%rip), %rsi     # 0x2160c
movq %rax, %rdi
callq 0x31d0
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
callq 0x10bd2
leaq -0x48(%rbp), %rdi
movq 0x18(%rdi), %rsi
leaq -0x18(%rbp), %rdx
movq %r14, (%rdx)
callq 0x110fc
movq %rax, %rbx
movq 0x22744(%rip), %rdi     # 0x31fb8
leaq 0x11861(%rip), %rsi     # 0x210dc
callq 0x31d0
leaq 0x11d83(%rip), %rsi     # 0x2160a
movq %rax, %rdi
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x11d6b(%rip), %rsi     # 0x2160c
movq %rax, %rdi
callq 0x31d0
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
callq 0x10bd2
leaq -0x48(%rbp), %rdi
callq 0xa648
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xf8e3
jmp 0xf8e3
jmp 0xf8e3
jmp 0xf8e3
jmp 0xf8e3
jmp 0xf8e3
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x88(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x11184
leaq -0x90(%rbp), %rdi
callq 0x10bd2
leaq -0x60(%rbp), %rdi
callq 0x10bd2
leaq 0x22870(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x90(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0x64, %r12
je 0xf9ae
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xf981
movq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rbx, %rdx
callq 0x11184
leaq -0x90(%rbp), %rdi
callq 0x10bd2
leaq -0x60(%rbp), %rdi
callq 0x10bd2
leaq -0x60(%rbp), %rdi
callq 0xa648
leaq -0x90(%rbp), %rdi
callq 0xa648
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf9f9
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
leaq -0x90(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x30(%rbp), %rsi
movq $0x2a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xad0a
leaq -0x30(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x110c8
movq %rax, %rbx
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0x14, %r12
je 0xfaa9
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xfa7c
leaq -0x60(%rbp), %rdi
callq 0x10bd2
leaq -0x30(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x110c8
cmpq %rax, %rbx
jne 0xfae5
movq 0x224e7(%rip), %rdi     # 0x31fb8
leaq 0x11615(%rip), %rsi     # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfb05
jmp 0xfb05
jmp 0xfb05
jmp 0xfb05
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_insert_cplusplus()
void
test_map_modifiers_insert_cplusplus()
{
	ft::map<char, int> mymap;

	// first insert function version (single parameter):
	mymap.insert(ft::pair<char, int>('a', 100) );
	mymap.insert(ft::pair<char, int>('z', 200) );

	ft::pair<ft::map<char, int>::iterator, bool> ret;

	ret = mymap.insert(ft::pair<char, int>('z', 500));
	if (ret.second == false)
	{
		std::cout << "element 'z' already existed";
		std::cout << " with a value of " << ret.first->second << std::endl;
	}

	// second insert function version (with hint position):
	ft::map<char, int>::iterator it = mymap.begin();
	mymap.insert(it, ft::pair<char, int>('b', 300));  // max efficiency inserting
	mymap.insert(it, ft::pair<char, int>('c', 400));  // no max efficiency inserting

	// third insert function version (range insertion):
	ft::map<char, int> anothermap;
	anothermap.insert(mymap.begin(), mymap.find('c'));

	print_map_info(mymap);
	print_map_info(anothermap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rsi
movb $0x61, (%rsi)
movl $0x64, 0x4(%rsi)
leaq -0x70(%rbp), %rdi
callq 0x112b4
leaq -0x40(%rbp), %rsi
movb $0x7a, (%rsi)
movl $0xc8, 0x4(%rsi)
leaq -0x70(%rbp), %rdi
callq 0x112b4
leaq -0x40(%rbp), %rsi
movb $0x7a, (%rsi)
movl $0x1f4, 0x4(%rsi)       # imm = 0x1F4
leaq -0x70(%rbp), %rdi
callq 0x112b4
testb %dl, %dl
jne 0xfbc0
movq %rax, %rbx
movq 0x2242a(%rip), %rdi     # 0x31fb8
leaq 0x11c31(%rip), %rsi     # 0x217c6
callq 0x31d0
movq 0x22417(%rip), %rdi     # 0x31fb8
leaq 0x11c3a(%rip), %rsi     # 0x217e2
callq 0x31d0
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x70(%rbp), %rdi
movq 0x18(%rdi), %rbx
leaq -0x40(%rbp), %rdx
movb $0x62, (%rdx)
movl $0x12c, 0x4(%rdx)       # imm = 0x12C
movq %rbx, %rsi
callq 0x1135a
leaq -0x40(%rbp), %rdx
movb $0x63, (%rdx)
movl $0x190, 0x4(%rdx)       # imm = 0x190
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x1135a
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x70(%rbp), %rdi
movq 0x18(%rdi), %rbx
leaq -0x9(%rbp), %rsi
movb $0x63, (%rsi)
callq 0xc4f0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x113e2
leaq -0x70(%rbp), %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rdi
callq 0xc1a3
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0xfc69
jmp 0xfc69
jmp 0xfc69
jmp 0xfc69
jmp 0xfc69
movq %rax, %rbx
jmp 0xfc7c
jmp 0xfc70
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc2f0
leaq -0x70(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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 -0x50(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2251c(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x58(%rbp), %rbx
leaq -0x28(%rbp), %r14
cmpq $0x64, %r15
je 0xfcff
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x28(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0xfcd2
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x28(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x110c8
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x11512
leaq -0x28(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x110c8
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x11512
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x58(%rbp), %rbx
cmpq $0x0, -0x30(%rbp)
je 0xfd68
movq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x11512
jmp 0xfd53
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x58(%rbp), %rdi
callq 0xa648
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfd8f
jmp 0xfd8f
jmp 0xfd8f
jmp 0xfd8f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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 %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x22406(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x58(%rbp), %rbx
leaq -0x28(%rbp), %r14
cmpq $0x64, %r15
je 0xfe15
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x28(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0xfde8
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x28(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x11572
movq 0x22180(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x11572
movq 0x22156(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x11572
movq 0x2212c(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x58(%rbp), %rdi
callq 0xa648
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfec3
jmp 0xfec3
jmp 0xfec3
jmp 0xfec3
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x222d0(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r12d, %r12d
pushq $0x64
popq %r13
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpq $0x64, %r12
je 0xff4b
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xad0a
incq %r12
jmp 0xff1e
leaq -0x60(%rbp), %rdi
callq 0x10bd2
leaq -0x30(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x110c8
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1162c
movq %r14, %rdi
callq 0x10bd2
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xff9d
jmp 0xff9d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x58(%rbp), %rbx
leaq -0x28(%rbp), %r14
cmpq $0xa, %r15
je 0x10015
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x28(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0xffe8
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x28(%rbp), %rsi
movl $0x9, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x110c8
movq %rax, %rbx
xorl %eax, %eax
leaq -0x58(%rbp), %r14
leaq -0x28(%rbp), %r15
movl %eax, -0x28(%rbp)
cmpl $0x9, %eax
jge 0x10058
movq %r14, %rdi
movq %r15, %rsi
callq 0x11572
movl -0x28(%rbp), %eax
incl %eax
jmp 0x1003e
leaq -0x28(%rbp), %rsi
movl $0x9, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x110c8
cmpq %rax, %rbx
jne 0x1008b
movq 0x21f41(%rip), %rdi     # 0x31fb8
leaq 0x1106f(%rip), %rsi     # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x58(%rbp), %rdi
callq 0x10bd2
leaq -0x58(%rbp), %rdi
callq 0xa648
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x100b2
jmp 0x100b2
jmp 0x100b2
jmp 0x100b2
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_cplusplus()
void
test_map_modifiers_erase_cplusplus()
{
	ft::map<char, int> mymap;
	ft::map<char, int>::iterator it;

	// insert some values:
	mymap['a'] = 10;
	mymap['b'] = 20;
	mymap['c'] = 30;
	mymap['d'] = 40;
	mymap['e'] = 50;
	mymap['f'] = 60;

	it = mymap.find('b');
	mymap.erase (it);                   // erasing by iterator

	mymap.erase ('c');                  // erasing by key

	it = mymap.find ('e');
	mymap.erase(it, mymap.end());    // erasing by range

	// show content:
	for (it = mymap.begin(); it != mymap.end(); ++it)
		std::cout << it->first << " => " << it->second << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0xa, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x14, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x1e, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x28, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x65, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x32, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x66, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x3c, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc4f0
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xc548
leaq -0x29(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x116e8
leaq -0x29(%rbp), %rsi
movb $0x65, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc4f0
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc7ba
movq 0x18(%r14), %r13
movq 0x21deb(%rip), %r14     # 0x31fb8
leaq 0x11620(%rip), %r15     # 0x217f4
pushq $0xa
popq %r12
cmpq %rbx, %r13
je 0x10219
movsbl 0x20(%r13), %esi
movq %r14, %rdi
callq 0x3210
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movl 0x24(%r13), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movl %r12d, %esi
callq 0x3210
movq %r13, %rdi
callq 0x3150
movq %rax, %r13
jmp 0x101d8
leaq -0x60(%rbp), %rdi
callq 0xc2f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10d7c
movl $0x2a, (%rax)
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10d7c
movl $0x3, (%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x10d7c
movl $0x64, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x10bd2
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x116b0
movq %rbx, %rdi
callq 0x10bd2
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x10d7c
movl $0x2a, (%rax)
leaq -0xc(%rbp), %rsi
orl $-0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10d7c
movl $0x3, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x10bd2
leaq -0x40(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x10687
jmp 0x10687
jmp 0x10687
jmp 0x10687
jmp 0x10687
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10dce
leaq 0x10a38(%rip), %rsi     # 0x2110f
movq %rax, %rdi
callq 0x3340
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10dce
leaq 0x10967(%rip), %rsi     # 0x2105d
movq %rax, %rdi
callq 0x3340
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x10dce
leaq 0x110a8(%rip), %rsi     # 0x217c0
movq %rax, %rdi
callq 0x3340
leaq -0x40(%rbp), %rdi
callq 0x10ca7
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x11978
movq %rbx, %rdi
callq 0x10ca7
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x10dce
leaq 0x110a2(%rip), %rsi     # 0x217f9
movq %rax, %rdi
callq 0x3340
leaq -0xc(%rbp), %rsi
orl $-0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x10dce
leaq 0x11086(%rip), %rsi     # 0x217fc
movq %rax, %rdi
callq 0x3340
leaq -0x40(%rbp), %rdi
callq 0x10ca7
leaq -0x40(%rbp), %rdi
callq 0x10e20
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x107a1
jmp 0x107a1
jmp 0x107a1
jmp 0x107a1
jmp 0x107a1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x10e20
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x64, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0xc8, (%rax)
leaq -0x29(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x12c, (%rax)          # imm = 0x12C
movq 0x20595(%rip), %rdi     # 0x31fb8
leaq 0xfdd9(%rip), %rsi      # 0x21803
callq 0x31d0
movq %rbx, %rdi
callq 0x31f0
movb 0x20(%rax), %r13b
movq -0x48(%rbp), %r14
movq 0x20572(%rip), %rbx     # 0x31fb8
leaq 0xfbbc(%rip), %r15      # 0x21609
leaq 0xfbb8(%rip), %r12      # 0x2160c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
movsbl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x3320
movq %r14, %rdi
callq 0x3150
cmpb %r13b, 0x20(%r14)
movq %rax, %r14
jl 0x11a54
movq 0x2051d(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xc2f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11ac2
jmp 0x11ac2
jmp 0x11ac2
jmp 0x11ac2
jmp 0x11ac2
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_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
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x78, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x3e9, (%rax)          # imm = 0x3E9
leaq -0x29(%rbp), %rsi
movb $0x79, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0x7d2, (%rax)          # imm = 0x7D2
leaq -0x29(%rbp), %rsi
movb $0x7a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc29e
movl $0xbbb, (%rax)          # imm = 0xBBB
movq 0x2046f(%rip), %rdi     # 0x31fb8
leaq 0xfcc3(%rip), %rsi      # 0x21813
callq 0x31d0
movq %rbx, %rdi
callq 0x31f0
movb 0x20(%rax), %r13b
movq -0x48(%rbp), %r14
movq 0x2044c(%rip), %rbx     # 0x31fb8
leaq 0xfa96(%rip), %r15      # 0x21609
leaq 0xfa92(%rip), %r12      # 0x2160c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
movsbl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x3320
movq %r14, %rdi
callq 0x3150
cmpb %r13b, 0x20(%r14)
movq %rax, %r14
jl 0x11b7a
movq 0x203f7(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xc2f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11be8
jmp 0x11be8
jmp 0x11be8
jmp 0x11be8
jmp 0x11be8
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330