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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x68(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x38(%rbp), %r14
movl %ecx, (%r14)
movq %rcx, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rcx, 0x20(%r14)
movq 0x2c424(%rip), %rbx     # 0x33fd0
leaq 0x1e57c(%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 0x2c3f2(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r14, -0x28(%rbp)
jne 0x7c37
movq 0x2c3d8(%rip), %rbx     # 0x33fd0
leaq 0x1e530(%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 0x2c3a6(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x40(%rbp), %rdi
callq 0x35fe
leaq -0x70(%rbp), %rdi
callq 0x35fe
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35fe
leaq -0x70(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_100_size_set()
void
test_set_iterators_100_size_set()
{
	typedef ft::set<int>::iterator iterator;

	ft::set<int> set;

	srand(g_seed);

	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

	for (iterator it = set.begin(); it != set.end(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x2c539(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r15d
leaq -0x58(%rbp), %rbx
leaq -0x24(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e76
decl %r15d
jne 0x7cbc
movq -0x40(%rbp), %rbx
cmpq %r12, %rbx
je 0x7d36
movq 0x2c2cc(%rip), %r14     # 0x33fd0
leaq 0x1f5ff(%rip), %r15     # 0x2730a
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
cmpq %r12, %rax
jne 0x7d0b
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7d4e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_100_size_const_set()
void
test_set_iterators_100_size_const_set()
{
	typedef ft::set<int>::const_iterator const_iterator;

	ft::set<int> set;

	srand(g_seed);
	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

	ft::set<int> const const_set(set.begin(), set.end());

	for (const_iterator it = const_set.begin(); it != const_set.end(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x78(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x2c44c(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r12d
leaq -0x80(%rbp), %r14
leaq -0x50(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e76
decl %r12d
jne 0x7da9
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x416c
leaq -0x48(%rbp), %r12
movq 0x10(%r12), %rbx
cmpq %r12, %rbx
je 0x7e38
movq 0x2c1ca(%rip), %r14     # 0x33fd0
leaq 0x1f4fd(%rip), %r15     # 0x2730a
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
cmpq %r12, %rax
jne 0x7e0d
leaq -0x50(%rbp), %rdi
callq 0x35fe
leaq -0x80(%rbp), %rdi
callq 0x35fe
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7e59
movq %rax, %rbx
jmp 0x7e6a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
leaq -0x80(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_copy()
void
test_set_iterators_copy()
{
	typedef ft::set<int>::iterator iterator;
	typedef ft::set<int>::const_iterator const_iterator;

	ft::set<int> set;

	srand(g_seed);
	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

	iterator it(set.begin());
	const_iterator const_it(it);

	for (const_iterator it = const_it; it != set.end(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x2c32d(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r15d
leaq -0x58(%rbp), %rbx
leaq -0x24(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e76
decl %r15d
jne 0x7ec8
movq -0x40(%rbp), %rbx
cmpq %r12, %rbx
je 0x7f42
movq 0x2c0c0(%rip), %r14     # 0x33fd0
leaq 0x1f3f3(%rip), %r15     # 0x2730a
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
cmpq %r12, %rax
jne 0x7f17
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f5a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_constructors_base()
void
test_set_reverse_iterators_constructors_base()
{
	ft::set<int> myset;

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

	typedef ft::set<int>::iterator iter_type;
	typedef ft::set<int>::reverse_iterator rev_iter_type;

	iter_type from(myset.begin());
	iter_type until(myset.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 %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%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 -0x14(%rbp), %rbx
movl %ecx, (%rbx)
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71ee
movl -0x14(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x9, %eax
jl 0x84bd
movq 0x2baf3(%rip), %rbx     # 0x33fd0
leaq 0x1efb2(%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 0x2bac1(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x48(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8530
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_operator_star()
void
test_set_reverse_iterators_operator_star()
{
	ft::set<int> myset;

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

	typedef ft::set<int>::iterator iter_type;
	typedef ft::set<int>::reverse_iterator rev_iter_type;

	iter_type until(myset.end());

	rev_iter_type rev_from(until);

	std::cout << *rev_from << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%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 -0x1c(%rbp), %r14
movl %eax, (%r14)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x71ee
movl -0x1c(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x9, %eax
jl 0x8574
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq 0x2ba31(%rip), %rdi     # 0x33fd0
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 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x85e4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_operator_increment()
void
test_set_reverse_iterators_operator_increment()
{
	ft::set<int> myset;

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

	typedef ft::set<int>::iterator iter_type;

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

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

	std::cout << "myset:";
	while (rev_from != rev_until)
	{
		std::cout << ' ' << *rev_from;
		++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
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x2c(%rbp), %r14
movl %eax, (%r14)
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x71ee
movl -0x2c(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x9, %eax
jl 0x862c
movq -0x48(%rbp), %r14
movq 0x2b980(%rip), %rdi     # 0x33fd0
leaq 0x1dcc5(%rip), %rsi     # 0x2631c
movl $0x6, %edx
callq 0x2230
cmpq %r14, %rbx
je 0x86ab
movq 0x2b963(%rip), %r15     # 0x33fd0
leaq -0x2c(%rbp), %r12
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq %rax, %r13
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq %r14, %rax
jne 0x8671
movq 0x2b91e(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2b903(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x86f6
jmp 0x86f6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_operator_decrement()
void
test_set_reverse_iterators_operator_decrement()
{
	ft::set<int> myset;

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

	typedef ft::set<int>::iterator iter_type;

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

	ft::reverse_iterator<iter_type> rev_iterator = rev_begin;
	while (rev_iterator != rev_end)
		std::cout << *rev_iterator++ << ' ';
	std::cout << std::endl;

	while (rev_iterator != rev_begin)
		std::cout << *(--rev_iterator) << ' ';
	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), %r13
xorl %eax, %eax
movl %eax, (%r13)
movq %rax, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
movq %rax, 0x20(%r13)
leaq -0x2c(%rbp), %rbx
movl %eax, (%rbx)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71ee
movl -0x2c(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x9, %eax
jl 0x873f
movq -0x48(%rbp), %r12
movq %r13, %rbx
cmpq %r12, %r13
je 0x87a1
movq 0x2b865(%rip), %r14     # 0x33fd0
leaq -0x2c(%rbp), %r15
movq %r13, %rbx
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
cmpq %r12, %rbx
jne 0x8772
movq 0x2b828(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2b80d(%rip), %r14     # 0x33fd0
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r13, %rbx
je 0x881a
movq 0x2b7f1(%rip), %r15     # 0x33fd0
leaq -0x2c(%rbp), %r12
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
cmpq %r13, %rbx
jne 0x87e3
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2b798(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8863
jmp 0x8863
jmp 0x8863
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_empty_sets()
void
test_set_reverse_iterators_empty_sets()
{
	ft::set<int> set;
	ft::set<int> const const_set;

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

	if (const_set.rbegin() == const_set.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 0x2b718(%rip), %rbx     # 0x33fd0
leaq 0x1d870(%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 0x2b6e6(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq -0x28(%rbp), %r14
jne 0x8943
movq 0x2b6cc(%rip), %rbx     # 0x33fd0
leaq 0x1d824(%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 0x2b69a(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x40(%rbp), %rdi
callq 0x35fe
leaq -0x70(%rbp), %rdi
callq 0x35fe
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35fe
leaq -0x70(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_100_size_set()
void
test_set_reverse_iterators_100_size_set()
{
	typedef ft::set<int>::reverse_iterator reverse_iterator;

	ft::set<int> set;

	srand(g_seed);
	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

	for (reverse_iterator it = set.rbegin(); it != set.rend(); it++)
		std::cout << *it << " ";
}

// 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)
leaq 0x2b833(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r12d
leaq -0x58(%rbp), %r14
leaq -0x24(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e76
decl %r12d
jne 0x89c2
cmpq -0x40(%rbp), %rbx
je 0x8a42
movq 0x2b5c9(%rip), %r14     # 0x33fd0
leaq 0x1e8fc(%rip), %r15     # 0x2730a
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq -0x40(%rbp), %rax
jne 0x8a0e
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8a5a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_100_size_const_set()
void
test_set_reverse_iterators_100_size_const_set()
{
	typedef ft::set<int>::const_reverse_iterator const_reverse_iterator;

	ft::set<int> set;

	srand(g_seed);
	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

	ft::set<int> const const_set(set.begin(), set.end());

	for (const_reverse_iterator it = const_set.rbegin(); it != const_set.rend(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x78(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x2b740(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r12d
leaq -0x80(%rbp), %r14
leaq -0x50(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e76
decl %r12d
jne 0x8ab5
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x416c
leaq -0x48(%rbp), %rbx
cmpq 0x10(%rbx), %rbx
je 0x8b49
movq 0x2b4c2(%rip), %r14     # 0x33fd0
leaq 0x1e7f5(%rip), %r15     # 0x2730a
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq -0x38(%rbp), %rax
jne 0x8b15
leaq -0x50(%rbp), %rdi
callq 0x35fe
leaq -0x80(%rbp), %rdi
callq 0x35fe
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b6a
movq %rax, %rbx
jmp 0x8b7b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
leaq -0x80(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_reverse_iterators.cpp
// Function: test_set_reverse_iterators_copy()
void
test_set_reverse_iterators_copy()
{
	typedef ft::set<int>::reverse_iterator reverse_iterator;
	typedef ft::set<int>::const_reverse_iterator const_reverse_iterator;

	ft::set<int> set;

	srand(g_seed);
	for (int i = 0; i < 10; i++)
		set.insert(rand() % 100 - 50);

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

	for (const_reverse_iterator it = const_it; it != set.rend(); it++)
		std::cout << *it << " ";
}

// 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)
leaq 0x2b622(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r12d
leaq -0x58(%rbp), %r14
leaq -0x24(%rbp), %r15
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e76
decl %r12d
jne 0x8bd3
cmpq -0x40(%rbp), %rbx
je 0x8c53
movq 0x2b3b8(%rip), %r14     # 0x33fd0
leaq 0x1e6eb(%rip), %r15     # 0x2730a
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq -0x40(%rbp), %rax
jne 0x8c1f
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c6b
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_operations.cpp
// Function: test_set_operations_find()
void
test_set_operations_find()
{
	ft::set<int> set;
	ft::set<int>::iterator it;

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

	print_set_info(set);

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

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

	if ((it = set.find(42)) != set.end())
		set.erase(it);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq -0x1c(%rbp), %rbx
movl $0x1, (%rbx)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71ee
movl -0x1c(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x5, %eax
jl 0x8f5c
leaq -0x50(%rbp), %rdi
callq 0x41b5
movq -0x40(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x8fa4
movq %r15, %rax
xorl %edx, %edx
cmpl $0x4, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x8f8d
movq %r15, %rsi
cmpq %r15, %rax
je 0x8fb7
cmpl $0x5, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0x8fc5
leaq -0x50(%rbp), %rdi
callq 0x72ea
movq -0x40(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x8feb
movq %r15, %rax
xorl %edx, %edx
cmpl $0x2, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x8fd4
movq %r15, %rsi
cmpq %r15, %rax
je 0x8ffe
cmpl $0x3, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0x900c
leaq -0x50(%rbp), %rdi
callq 0x72ea
movq -0x40(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x9032
movq %r15, %rax
xorl %edx, %edx
cmpl $0x2a, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x901b
movq %r15, %rsi
cmpq %r15, %rax
je 0x9045
cmpl $0x2b, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0x9053
leaq -0x50(%rbp), %rdi
callq 0x72ea
leaq -0x50(%rbp), %rdi
callq 0x41b5
leaq -0x50(%rbp), %rdi
callq 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9072
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x90c9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71ee
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x13, %ecx
jl 0x90ba
xorl %r14d, %r14d
leaq 0x1d2c2(%rip), %r12     # 0x263a3
leaq 0x1d2b6(%rip), %r13     # 0x2639e
movq 0x2aee1(%rip), %rbx     # 0x33fd0
movq -0x50(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x9115
movq %r15, %rax
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x90fe
movq %r15, %rcx
cmpq %r15, %rax
je 0x9128
cmpl 0x20(%rax), %r14d
cmovlq %r15, %rax
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
sete %al
movq %r13, %rsi
cmoveq %r12, %rsi
leaq 0x4(,%rax,4), %rdx
movq %rbx, %rdi
callq 0x2230
incl %r14d
cmpl $0x14, %r14d
jne 0x90ef
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2ae62(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9197
jmp 0x9197
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e76
addl $0xa, %r12d
cmpl $0x64, %r12d
jne 0x9786
movq -0x48(%rbp), %rax
movq %rbx, %r14
testq %rax, %rax
je 0x97dc
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 0x97b1
jmp 0x97dc
xorl %ecx, %ecx
cmpl $0x3d, 0x20(%rax)
setl %cl
cmovgeq %rax, %rbx
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x97ca
leaq -0x58(%rbp), %rdi
callq 0x41b5
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x73a8
movq %r15, %rdi
callq 0x41b5
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x981c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e76
addl $0xa, %r15d
cmpl $0x3c, %r15d
jne 0x9867
leaq -0x1c(%rbp), %rsi
movl $0x1e, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x732c
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a730(%rip), %rdi     # 0x33fd0
leaq 0x1cb0b(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a714(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a6f4(%rip), %rdi     # 0x33fd0
leaq 0x1caeb(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a6d9(%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 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9928
jmp 0x9928
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e76
addl $0xa, %r15d
cmpl $0x3c, %r15d
jne 0x9973
leaq -0x1c(%rbp), %rsi
movl $0x19, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x732c
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a624(%rip), %rdi     # 0x33fd0
leaq 0x1c9ff(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a608(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a5e8(%rip), %rdi     # 0x33fd0
leaq 0x1c9df(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a5cd(%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 0x732c
movq %rax, %r14
movq %rdx, %rbx
movq 0x2a594(%rip), %rdi     # 0x33fd0
leaq 0x1c96f(%rip), %rsi     # 0x263b2
movl $0x1b, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x2a578(%rip), %rdi     # 0x33fd0
callq 0x2330
leaq -0x1c(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x2a558(%rip), %rdi     # 0x33fd0
leaq 0x1c94f(%rip), %rsi     # 0x263ce
movl $0x1b, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2a53d(%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 0x35fe
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9ac6
jmp 0x9ac6
jmp 0x9ac6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71ee
movl -0x24(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x5, %eax
jl 0x9d5e
movq 0x2a252(%rip), %rdi     # 0x33fd0
leaq 0x1c3b2(%rip), %rsi     # 0x26137
movl $0xf, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x2a22a(%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 0x9daa
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2a1d7(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e22
jmp 0x9e22
jmp 0x9e22
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71ee
movl -0x24(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x5, %eax
jl 0x9e68
movq 0x2a148(%rip), %rdi     # 0x33fd0
leaq 0x1c2a8(%rip), %rsi     # 0x26137
movl $0xf, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2130
movl 0x20(%rax), %r12d
movq -0x40(%rbp), %r15
movq 0x2a120(%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 0x9eb4
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2a0cd(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f2c
jmp 0x9f2c
jmp 0x9f2c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c216(%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 0x7128
leaq -0x68(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x7128
leaq -0x68(%rbp), %rdi
callq 0x41b5
leaq -0x38(%rbp), %rdi
callq 0x41b5
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
testq %rcx, %rcx
je 0xa3a2
testq %rax, %rax
je 0xa3cd
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 0xa403
testq %rax, %rax
je 0xa403
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 0xa3f1
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 0x41b5
leaq -0x38(%rbp), %rdi
callq 0x41b5
leaq -0x38(%rbp), %rdi
callq 0x35fe
leaq -0x68(%rbp), %rdi
callq 0x35fe
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0xa43f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35fe
leaq -0x68(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c3d5(%rip), %rsi     # 0x269c6
leaq 0x1c3d4(%rip), %rdx     # 0x269cc
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0xe432(%rip), %rdi      # 0x18a40
movq %rbx, %rsi
callq 0x25d6b
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xa627
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bf02(%rip), %rsi     # 0x26538
leaq 0x1bf00(%rip), %rdx     # 0x2653d
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0xc6f5(%rip), %rdi      # 0x16d45
movq %rbx, %rsi
callq 0x25d6b
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0xa666
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bfe6(%rip), %rsi     # 0x2665b
leaq 0x1bfe2(%rip), %rdx     # 0x2665e
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x5a91(%rip), %rdi      # 0x10120
movq %rbx, %rsi
callq 0x25d6b
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa6a5
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bcbb(%rip), %rsi     # 0x2636f
leaq 0x1bcb7(%rip), %rdx     # 0x26372
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x3232(%rip), %rdi     # 0x749c
movq %rbx, %rsi
callq 0x25d6b
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xa6e4
callq 0x21b0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0xa715
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0xa715
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0xa715
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xa71f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcf58
addl $0x101, %r12d           # imm = 0x101
movzwl %r12w, %eax
cmpl $0x3a3a, %eax           # imm = 0x3A3A
jne 0xba69
leaq -0x58(%rbp), %rdi
callq 0xcd41
movq -0x48(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0xbaba
movq %r15, %rax
xorl %edx, %edx
cmpb $0x34, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xbaa3
movq %r15, %rsi
cmpq %r15, %rax
je 0xbacd
cmpb $0x35, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0xbadb
leaq -0x58(%rbp), %rdi
callq 0xd0aa
movq -0x48(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0xbb01
movq %r15, %rax
xorl %edx, %edx
cmpb $0x34, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xbaea
movq %r15, %rsi
cmpq %r15, %rax
je 0xbb14
cmpb $0x35, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0xbb22
leaq -0x58(%rbp), %rdi
callq 0xd0aa
movq -0x48(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0xbb48
movq %r15, %rax
xorl %edx, %edx
cmpb $0x32, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xbb31
movq %r15, %rsi
cmpq %r15, %rax
je 0xbb5b
cmpb $0x33, 0x20(%rax)
cmovgeq %r15, %rax
movq %rax, %rsi
cmpq %r15, %rsi
je 0xbb69
leaq -0x58(%rbp), %rdi
callq 0xd0aa
leaq -0x58(%rbp), %rdi
callq 0xcd41
leaq -0x58(%rbp), %rdi
callq 0xcf00
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb8a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbbf2
movq %r12, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0xb3c2
incq %rbx
addq %r13, %r12
cmpq $0x14, %rbx
jne 0xbbdd
xorl %r14d, %r14d
leaq 0x1a79b(%rip), %r12     # 0x263a3
leaq 0x1a78f(%rip), %r13     # 0x2639e
movq 0x283ba(%rip), %rbx     # 0x33fd0
movq -0x50(%rbp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0xbc3c
movq %r15, %rax
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xbc25
movq %r15, %rcx
cmpq %r15, %rax
je 0xbc4f
cmpl 0x20(%rax), %r14d
cmovlq %r15, %rax
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
sete %al
movq %r13, %rsi
cmoveq %r12, %rsi
leaq 0x4(,%rax,4), %rdx
movq %rbx, %rdi
callq 0x2230
incl %r14d
cmpl $0x14, %r14d
jne 0xbc16
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2833b(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaeae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbcbe
jmp 0xbcbe
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaeae
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xce98
movl $0x14, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xce98
movl $0x28, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xce98
movl $0x3c, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xce98
movl $0x50, (%rax)
leaq -0x19(%rbp), %rsi
movb $0x65, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0xce98
movl $0x64, (%rax)
movq -0x40(%rbp), %rax
movq %rbx, %r14
testq %rax, %rax
je 0xc594
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 0xc569
jmp 0xc594
xorl %ecx, %ecx
cmpb $0x65, 0x20(%rax)
setl %cl
cmovgeq %rax, %rbx
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0xc582
leaq -0x50(%rbp), %rdi
callq 0xcd41
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd242
movq %r15, %rdi
callq 0xcd41
leaq -0x50(%rbp), %rdi
callq 0xcf00
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc5da
jmp 0xc5da
jmp 0xc5da
jmp 0xc5da
jmp 0xc5da
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340