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

	for (int i = 0; i < 20; i++)
	{
		if (i % 2 == 0)
			set.insert(i);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %r15
xorl %eax, %eax
movl %eax, (%r15)
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq -0x2c(%rbp), %rbx
movl %eax, (%rbx)
leaq -0x60(%rbp), %r14
testb $0x1, %al
jne 0x9146
movq %r14, %rdi
movq %rbx, %rsi
callq 0x724a
movl -0x2c(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x13, %eax
movl %ecx, %eax
jl 0x9134
xorl %r14d, %r14d
leaq 0x1d246(%rip), %r12     # 0x263a3
leaq 0x1d23a(%rip), %r13     # 0x2639e
movq 0x2ae65(%rip), %rbx     # 0x33fd0
movq -0x50(%rbp), %rdi
movq %r15, %r8
testq %rdi, %rdi
je 0x91b7
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %r14d, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x917a
movq %r15, %r8
cmpq %r15, %rdx
je 0x91b7
cmpl %r14d, %esi
cmovlq %rax, %rcx
cmpl 0x20(%rcx), %r14d
cmovlq %r15, %rdx
movq %rdx, %r8
xorl %eax, %eax
cmpq %r15, %r8
sete %al
movq %r13, %rsi
cmoveq %r12, %rsi
leaq 0x4(,%rax,4), %rdx
movq %rbx, %rdi
callq 0x2230
incl %r14d
cmpl $0x14, %r14d
jne 0x916b
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2add3(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0x3602
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9226
jmp 0x9226
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_lower_upper_bound()
void
test_set_operations_lower_upper_bound()
{
	ft::set<int> set;
	ft::set<int>::iterator itlow, itup;

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

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

	print_set_info(set);

	set.erase(itlow, itup);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movl $0xa, %r12d
leaq -0x58(%rbp), %r14
leaq -0x24(%rbp), %r15
movl %r12d, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e54
addl $0xa, %r12d
cmpl $0x64, %r12d
jne 0x97fd
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x9855
movq %rax, %rcx
movq %rbx, %r14
xorl %edx, %edx
cmpl $0x1e, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %r14
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x9825
xorl %ecx, %ecx
cmpl $0x3d, 0x20(%rax)
setl %cl
cmovgeq %rax, %rbx
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x983c
jmp 0x9858
movq %rbx, %r14
leaq -0x58(%rbp), %rdi
callq 0x419b
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x740a
movq %r15, %rdi
callq 0x419b
leaq -0x58(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9893
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_equal_range_match()
void
test_set_operations_equal_range_match()
{
	ft::set<int> set;
	typedef ft::set<int>::const_iterator const_iterator;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movl $0xa, %r15d
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
movl %r15d, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e54
addl $0xa, %r15d
cmpl $0x3c, %r15d
jne 0x98de
leaq -0x1c(%rbp), %rsi
movl $0x1e, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x7388
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a6b9(%rip), %rdi     # 0x33fd0
leaq 0x1ca94(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a69d(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a67d(%rip), %rdi     # 0x33fd0
leaq 0x1ca74(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a662(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
leaq -0x50(%rbp), %rdi
callq 0x3602
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x999f
jmp 0x999f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_equal_range_no_match()
void
test_set_operations_equal_range_no_match()
{
	ft::set<int> set;
	typedef ft::set<int>::const_iterator const_iterator;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movl $0xa, %r15d
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
movl %r15d, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e54
addl $0xa, %r15d
cmpl $0x3c, %r15d
jne 0x99ea
leaq -0x1c(%rbp), %rsi
movl $0x19, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x7388
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a5ad(%rip), %rdi     # 0x33fd0
leaq 0x1c988(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a591(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a571(%rip), %rdi     # 0x33fd0
leaq 0x1c968(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a556(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
leaq -0x1c(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x50(%rbp), %rdi
callq 0x7388
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a51d(%rip), %rdi     # 0x33fd0
leaq 0x1c8f8(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a501(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a4e1(%rip), %rdi     # 0x33fd0
leaq 0x1c8d8(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a4c6(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
leaq -0x50(%rbp), %rdi
callq 0x3602
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b3d
jmp 0x9b3d
jmp 0x9b3d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_observers.cpp
// Function: test_set_observers_key_comp()
void
test_set_observers_key_comp()
{
	ft::set<int> myset;
	int highest;

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

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

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

	highest = *myset.rbegin();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x24(%rbp), %r14
movl %eax, (%r14)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x724a
movl -0x24(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x5, %eax
jl 0x9dd2
movq 0x2a1de(%rip), %rdi     # 0x33fd0
leaq 0x1c33e(%rip), %rsi     # 0x26137
movl $0xf, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x2a1b6(%rip), %rbx     # 0x33fd0
leaq -0x24(%rbp), %r14
movb $0x20, -0x24(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x2330
movq %r15, %rdi
callq 0x2240
movq %rax, %r15
cmpl %r12d, 0x20(%rax)
jl 0x9e1e
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2a163(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e96
jmp 0x9e96
jmp 0x9e96
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_observers.cpp
// Function: test_set_observers_value_comp()
void
test_set_observers_value_comp()
{
	ft::set<int> myset;
	int highest;

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

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

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

	highest = *myset.rbegin();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x24(%rbp), %r14
movl %eax, (%r14)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x724a
movl -0x24(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x5, %eax
jl 0x9edc
movq 0x2a0d4(%rip), %rdi     # 0x33fd0
leaq 0x1c234(%rip), %rsi     # 0x26137
movl $0xf, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x2a0ac(%rip), %rbx     # 0x33fd0
leaq -0x24(%rbp), %r14
movb $0x20, -0x24(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x2330
movq %r15, %rdi
callq 0x2240
movq %rax, %r15
cmpl %r12d, 0x20(%rax)
jl 0x9f28
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2a059(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9fa0
jmp 0x9fa0
jmp 0x9fa0
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_non_member_overloads.cpp
// Function: test_set_non_member_overloads_swap()
void
test_set_non_member_overloads_swap()
{
	int myints[] = {12, 75, 10, 32, 20, 25};
	ft::set<int> first(myints, myints + 3);
	ft::set<int> second(myints + 3, myints+ 6);

	print_set_info(first);
	print_set_info(second);

	swap(first, second);

	print_set_info(first);
	print_set_info(second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movaps 0x1c1a2(%rip), %xmm0    # 0x26520
leaq -0x74(%rbp), %rbx
movaps %xmm0, -0xc(%rbx)
movabsq $0x1900000014, %rax     # imm = 0x1900000014
movq %rax, 0x4(%rbx)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %rbx, %rdx
callq 0x718a
leaq -0x68(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x718a
leaq -0x68(%rbp), %rdi
callq 0x419b
leaq -0x38(%rbp), %rdi
callq 0x419b
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
testq %rcx, %rcx
je 0xa416
testq %rax, %rax
je 0xa441
leaq -0x60(%rbp), %rdx
movq %rax, 0x8(%rdx)
leaq -0x30(%rbp), %rsi
movq %rcx, 0x8(%rsi)
movups 0x10(%rdx), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdx)
movups %xmm0, 0x10(%rsi)
movq %rdx, 0x8(%rax)
movq 0x8(%rsi), %rax
movq %rsi, 0x8(%rax)
movq 0x20(%rdx), %rax
movq 0x20(%rsi), %rcx
movq %rcx, 0x20(%rdx)
movq %rax, 0x20(%rsi)
jmp 0xa477
testq %rax, %rax
je 0xa477
leaq -0x60(%rbp), %rcx
leaq -0x30(%rbp), %rdx
movl (%rdx), %esi
movl %esi, (%rcx)
movq %rax, 0x8(%rcx)
movups 0x10(%rdx), %xmm0
movups %xmm0, 0x10(%rcx)
movq %rcx, 0x8(%rax)
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rcx)
jmp 0xa465
leaq -0x30(%rbp), %rax
leaq -0x60(%rbp), %rdx
movl (%rdx), %esi
movl %esi, (%rax)
movq %rcx, 0x8(%rax)
movups 0x10(%rdx), %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, 0x8(%rcx)
movq 0x20(%rdx), %rcx
movq %rcx, 0x20(%rax)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rax, 0x20(%rdx)
leaq -0x68(%rbp), %rdi
callq 0x419b
leaq -0x38(%rbp), %rdi
callq 0x419b
leaq -0x38(%rbp), %rdi
callq 0x3602
leaq -0x68(%rbp), %rdi
callq 0x3602
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0xa4b3
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3602
leaq -0x68(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/test_containers.cpp
// Function: test_containers()
void
test_containers()
{
	//test_wrapper(test_subject, "subject");
	subsection_wrapper(test_vector, "vector");
	subsection_wrapper(test_stack, "stack");
	subsection_wrapper(test_map, "map");
	subsection_wrapper(test_set, "set");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1c369(%rip), %rsi     # 0x269c6
leaq 0x1c368(%rip), %rdx     # 0x269cc
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0xe55a(%rip), %rdi      # 0x18bd4
movq %rbx, %rsi
callq 0x25cb3
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xa693
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1be96(%rip), %rsi     # 0x26538
leaq 0x1be94(%rip), %rdx     # 0x2653d
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0xc829(%rip), %rdi      # 0x16ee5
movq %rbx, %rsi
callq 0x25cb3
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0xa6d2
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bf7a(%rip), %rsi     # 0x2665b
leaq 0x1bf76(%rip), %rdx     # 0x2665e
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x5add(%rip), %rdi      # 0x101d8
movq %rbx, %rsi
callq 0x25cb3
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa711
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bc4f(%rip), %rsi     # 0x2636f
leaq 0x1bc4b(%rip), %rdx     # 0x26372
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x323e(%rip), %rdi     # 0x74fc
movq %rbx, %rsi
callq 0x25cb3
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xa750
callq 0x21b0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0xa781
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0xa781
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0xa781
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xa78b
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_operations.cpp
// Function: test_map_operations_find()
void
test_map_operations_find()
{
	ft::map<char, int> map;
	ft::map<char, int>::iterator it;

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

	print_map_info(map);

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

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

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

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
movw $0x3030, %r12w          # imm = 0x3030
leaq -0x58(%rbp), %rbx
leaq -0x22(%rbp), %r14
movw %r12w, -0x22(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd03a
addl $0x101, %r12d           # imm = 0x101
movzwl %r12w, %eax
cmpl $0x3a3a, %eax           # imm = 0x3A3A
jne 0xbae5
leaq -0x58(%rbp), %rdi
callq 0xcdf9
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xbc06
movq %rax, %r8
movq %r15, %rsi
movq %rsi, %rcx
movq %r8, %rdx
movb 0x20(%r8), %dil
xorl %r8d, %r8d
cmpb $0x34, %dil
setl %r8b
movq %rdx, %rsi
cmovlq %rcx, %rsi
movq 0x10(%rdx,%r8,8), %r8
testq %r8, %r8
jne 0xbb23
cmpq %r15, %rsi
je 0xbb69
cmpb $0x34, %dil
cmovlq %rcx, %rdx
cmpb $0x34, 0x20(%rdx)
jg 0xbb69
leaq -0x58(%rbp), %rdi
callq 0xd180
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xbc06
movq %rax, %r8
movq %r15, %rsi
movq %rsi, %rcx
movq %r8, %rdx
movb 0x20(%r8), %dil
xorl %r8d, %r8d
cmpb $0x34, %dil
setl %r8b
movq %rdx, %rsi
cmovlq %rcx, %rsi
movq 0x10(%rdx,%r8,8), %r8
testq %r8, %r8
jne 0xbb78
cmpq %r15, %rsi
je 0xbbbe
cmpb $0x34, %dil
cmovlq %rcx, %rdx
cmpb $0x34, 0x20(%rdx)
jg 0xbbbe
leaq -0x58(%rbp), %rdi
callq 0xd180
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xbc06
movq %r15, %rsi
movq %rsi, %rcx
movq %rax, %rdx
movb 0x20(%rax), %dil
xorl %eax, %eax
cmpb $0x32, %dil
setl %al
movq %rdx, %rsi
cmovlq %rcx, %rsi
movq 0x10(%rdx,%rax,8), %rax
testq %rax, %rax
jne 0xbbc6
cmpq %r15, %rsi
je 0xbc06
cmpb $0x32, %dil
cmovlq %rcx, %rdx
cmpb $0x32, 0x20(%rdx)
jg 0xbc06
leaq -0x58(%rbp), %rdi
callq 0xd180
leaq -0x58(%rbp), %rdi
callq 0xcdf9
leaq -0x58(%rbp), %rdi
callq 0xcfe2
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc27
movq %rax, %rbx
leaq -0x58(%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_operations.cpp
// Function: test_map_operations_count()
void
test_map_operations_count()
{
	ft::map<int, int> map;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %r15
movl $0x0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %r12, 0x20(%r15)
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
xorl %ebx, %ebx
testb $0x1, %bl
jne 0xbc8f
movq %r12, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0xb43c
incq %rbx
addq %r13, %r12
cmpq $0x14, %rbx
jne 0xbc7a
xorl %r14d, %r14d
leaq 0x1a6fe(%rip), %r12     # 0x263a3
leaq 0x1a6f2(%rip), %r13     # 0x2639e
movq 0x2831d(%rip), %rbx     # 0x33fd0
movq -0x50(%rbp), %rdi
movq %r15, %r8
testq %rdi, %rdi
je 0xbcff
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %r14d, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0xbcc2
movq %r15, %r8
cmpq %r15, %rdx
je 0xbcff
cmpl %r14d, %esi
cmovlq %rax, %rcx
cmpl 0x20(%rcx), %r14d
cmovlq %r15, %rdx
movq %rdx, %r8
xorl %eax, %eax
cmpq %r15, %r8
sete %al
movq %r13, %rsi
cmoveq %r12, %rsi
leaq 0x4(,%rax,4), %rdx
movq %rbx, %rdi
callq 0x2230
incl %r14d
cmpl $0x14, %r14d
jne 0xbcb3
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2828b(%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 0xbd6e
jmp 0xbd6e
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_operations.cpp
// Function: test_map_operations_lower_upper_bound()
void
test_map_operations_lower_upper_bound()
{
	ft::map<char, int> mymap;
	ft::map<char, int>::iterator itlow, itup;

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

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

	print_map_info(mymap);

	mymap.erase(itlow, itup);

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x19(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x14, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x28, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x3c, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x50, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x65, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x64, (%rax)
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xc64e
movq %rax, %rcx
movq %rbx, %r14
xorl %edx, %edx
cmpb $0x62, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %r14
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xc61e
xorl %ecx, %ecx
cmpb $0x65, 0x20(%rax)
setl %cl
cmovgeq %rax, %rbx
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0xc635
jmp 0xc651
movq %rbx, %r14
leaq -0x50(%rbp), %rdi
callq 0xcdf9
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd318
movq %r15, %rdi
callq 0xcdf9
leaq -0x50(%rbp), %rdi
callq 0xcfe2
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc692
jmp 0xc692
jmp 0xc692
jmp 0xc692
jmp 0xc692
movq %rax, %rbx
leaq -0x50(%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_operations.cpp
// Function: test_map_operations_equal_range_match()
void
test_map_operations_equal_range_match()
{
	ft::map<char, int> mymap;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %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 -0x19(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0xa, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x14, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xcf7a
movl $0x1e, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xd3d2
movq %rax, %r14
movq %rdx, %rbx
movq 0x278a2(%rip), %rdi     # 0x33fd0
leaq 0x19c81(%rip), %rsi     # 0x263b6
movl $0x17, %edx
callq 0x2230
movq 0x2788a(%rip), %rdi     # 0x33fd0
leaq 0x19eea(%rip), %rsi     # 0x26637
movl $0x2, %edx
callq 0x2230
movb 0x20(%r14), %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
movq 0x27868(%rip), %rdi     # 0x33fd0
movl $0x1, %edx
callq 0x2230
movq %rax, %r15
leaq 0x19ebe(%rip), %rsi     # 0x2663a
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movl 0x24(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq 0x2780a(%rip), %rdi     # 0x33fd0
leaq 0x19c05(%rip), %rsi     # 0x263d2
movl $0x17, %edx
callq 0x2230
movq 0x277f2(%rip), %rdi     # 0x33fd0
leaq 0x19e52(%rip), %rsi     # 0x26637
movl $0x2, %edx
callq 0x2230
movb 0x20(%rbx), %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
movq 0x277d1(%rip), %rdi     # 0x33fd0
movl $0x1, %edx
callq 0x2230
movq %rax, %r14
leaq 0x19e27(%rip), %rsi     # 0x2663a
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movl 0x24(%rbx), %esi
movq %r14, %rdi
callq 0x2330
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 0xcfe2
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc871
jmp 0xc871
jmp 0xc871
jmp 0xc871
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xcfe2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_map_info<std::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<char>, std::allocator<std::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<char>, std::allocator<std::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
void
print_map_info(Map const& map)
{
	std::cout << "Size: " << map.size() << std::endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1f7e3(%rip), %r14     # 0x33fd0
leaq 0x118b7(%rip), %rsi     # 0x260ab
movl $0x6, %edx
movq %r14, %rdi
callq 0x2230
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq $0x0, 0x28(%rbx)
je 0x14911
movq 0x1f787(%rip), %rdi     # 0x33fd0
leaq 0x1186f(%rip), %rsi     # 0x260bf
movl $0x8, %edx
callq 0x2230
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x148d4
movq 0x1f762(%rip), %r12     # 0x33fd0
leaq 0x11dc5(%rip), %r13     # 0x2663a
movl $0x2, %edx
movq %r12, %rdi
leaq 0x11db3(%rip), %rsi     # 0x26637
callq 0x2230
movb 0x20(%r15), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r12, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2230
movq %rax, %r14
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rdi
callq 0x2230
movq %r15, %rdi
callq 0x2240
movq %rax, %r15
cmpq %rbx, %rax
jne 0x14875
movq 0x1f6f5(%rip), %rbx     # 0x33fd0
movq (%rbx), %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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1179a(%rip), %rsi     # 0x260b2
movl $0xc, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_constructors_base()
void
test_map_reverse_iterators_constructors_base()
{
	ft::map<int, char> map;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
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 0xd4a3
movq 0x26b0f(%rip), %rbx     # 0x33fd0
leaq 0x19fce(%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 0x26add(%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 0xd51a
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_reverse_iterators.cpp
// Function: test_map_reverse_iterators_operator_star()
void
test_map_reverse_iterators_operator_star()
{
	ft::map<int, char> map;

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

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

	iter_type until(map.end());

	rev_iter_type rev_from(until);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %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, %r12     # imm = 0x3000000030
movl $0xa, %r13d
leaq -0x60(%rbp), %r14
leaq -0x30(%rbp), %r15
movabsq $0x100000001, %rbx      # imm = 0x100000001
movq %r12, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe1f0
addq %rbx, %r12
decq %r13
jne 0xd57d
movq 0x26a35(%rip), %rdi     # 0x33fd0
leaq 0x19096(%rip), %rsi     # 0x26638
movl $0x1, %edx
callq 0x2230
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x2220
movl 0x20(%rax), %esi
movq 0x26a0e(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %r14
leaq 0x19069(%rip), %rsi     # 0x2663a
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movb 0x24(%rax), %al
leaq -0x30(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %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 0xd640
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_reverse_iterators.cpp
// Function: test_map_reverse_iterators_operator_increment()
void
test_map_reverse_iterators_operator_increment()
{
	ft::map<int, char> map;

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

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


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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movabsq $0x3000000030, %r12     # imm = 0x3000000030
movl $0xa, %r13d
leaq -0x30(%rbp), %r15
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r12, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0xe1f0
addq %r14, %r12
decq %r13
jne 0xd69f
movq -0x48(%rbp), %r13
movq 0x2690e(%rip), %rdi     # 0x33fd0
leaq 0x18f77(%rip), %rsi     # 0x26640
movl $0x6, %edx
callq 0x2230
cmpq %r13, %rbx
je 0xd781
movq 0x268ed(%rip), %r15     # 0x33fd0
leaq -0x30(%rbp), %r14
movl $0x1, %edx
movq %r15, %rdi
leaq 0x18f42(%rip), %rsi     # 0x26638
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
leaq 0x18f1a(%rip), %rsi     # 0x2663a
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movb 0x24(%rax), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2230
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
movq %rax, %rbx
cmpq %r13, %rax
jne 0xd6e7
movq 0x26848(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2682d(%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 0xd7cc
jmp 0xd7cc
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_reverse_iterators.cpp
// Function: test_map_reverse_iterators_empty_maps()
void
test_map_reverse_iterators_empty_maps()
{
	ft::map<int, int> map;
	ft::map<int, int> const const_map;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %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 0x2658a(%rip), %rbx     # 0x33fd0
leaq 0x186e2(%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 0x26558(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq -0x28(%rbp), %r14
jne 0xdad1
movq 0x2653e(%rip), %rbx     # 0x33fd0
leaq 0x18696(%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 0x2650c(%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
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_reverse_iterators.cpp
// Function: test_map_reverse_iterators_100_size_map()
void
test_map_reverse_iterators_100_size_map()
{
	typedef ft::map<int, int>::reverse_iterator reverse_iterator;

	ft::map<int, int> map;

	srand(g_seed);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rbx
movl $0x0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x266a2(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %r14
leaq -0x30(%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, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0x64, %r12
jne 0xdb4d
cmpq -0x48(%rbp), %rbx
je 0xdc09
movq 0x2642f(%rip), %r14     # 0x33fd0
leaq 0x18a8f(%rip), %r15     # 0x26637
leaq 0x18a8b(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2220
movq %rax, %rbx
cmpq -0x48(%rbp), %rax
jne 0xdbaf
movq 0x263c0(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x263a5(%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 0xdc54
jmp 0xdc54
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_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
movl $0x0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x26543(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %r14
leaq -0x30(%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, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0x64, %r12
jne 0xdcac
cmpq -0x48(%rbp), %rbx
je 0xdd68
movq 0x262d0(%rip), %r14     # 0x33fd0
leaq 0x18930(%rip), %r15     # 0x26637
leaq 0x1892c(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq -0x48(%rbp), %rax
jne 0xdd0e
movq 0x26261(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x26246(%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 0xddb3
jmp 0xddb3
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_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
movl $0x0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x263e4(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %r14
leaq -0x30(%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, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb43c
incq %r12
cmpq $0xa, %r12
jne 0xde0b
cmpq -0x48(%rbp), %rbx
je 0xdec7
movq 0x26171(%rip), %r14     # 0x33fd0
leaq 0x187d1(%rip), %r15     # 0x26637
leaq 0x187cd(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x24(%rax), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq -0x48(%rbp), %rax
jne 0xde6d
leaq -0x60(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdee1
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_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 %r14
pushq %rbx
subq $0x30, %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)
movl $0x28, %edi
callq 0x2200
movq %rax, %rbx
movq 0x25545(%rip), %rdi     # 0x33fd0
leaq 0x17be1(%rip), %rsi     # 0x26673
movl $0x22, %edx
callq 0x2230
movq 0x2552d(%rip), %rdi     # 0x33fd0
movl $0x28, %esi
callq 0x2330
movq %rax, %r14
leaq 0x17bdf(%rip), %rsi     # 0x26696
movl $0x7, %edx
movq %rax, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
leaq -0x40(%rbp), %rdi
callq 0xcfe2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xeb07
movq %rax, %rbx
leaq -0x40(%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_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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x10(%rbp), %rsi
movb $0x7a, 0x4(%rsi)
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0xf136
leaq -0x10(%rbp), %rsi
movb $0x64, 0x4(%rsi)
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xf136
leaq -0x10(%rbp), %rsi
movb $0x61, 0x4(%rsi)
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xf136
leaq -0x40(%rbp), %rdi
callq 0xed72
leaq -0x40(%rbp), %rdi
callq 0xf040
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xeba4
jmp 0xeba4
jmp 0xeba4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xf040
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x174a3(%rip), %rax     # 0x26087
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x17831(%rip), %rax     # 0x26423
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xf27a
leaq 0x17be8(%rip), %rax     # 0x267ee
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x17a8a(%rip), %rax     # 0x2669e
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xf27a
leaq 0x17465(%rip), %rax     # 0x2608d
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x17940(%rip), %rax     # 0x26576
movq %rax, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xf27a
leaq -0x48(%rbp), %rdi
callq 0xeef3
leaq -0x48(%rbp), %rdi
callq 0xf098
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0xec62
jmp 0xec62
jmp 0xec62
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xf098
movq %rbx, %rdi
callq 0x2340