LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_constructors_base()
void
test_set_iterators_constructors_base()
{
	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 cpy(from);

	if (from == cpy)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xf607
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0xf5d7
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf5bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xf66e
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0xf62f
jmp 0xf65c
movq 0x6b982(%rip), %rdi     # 0x7afb8
leaq 0x48ea0(%rip), %rsi     # 0x584dd
callq 0x31e0
movq %rax, -0x80(%rbp)
jmp 0xf648
movq -0x80(%rbp), %rdi
movq 0x6b945(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xf65a
jmp 0xf65c
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_operator_star()
void
test_set_iterators_operator_star()
{
	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());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xf6e7
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x69(%rbp)
movq %rax, -0x68(%rbp)
jmp 0xf6b7
movb -0x69(%rbp), %al
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf69b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xf735
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b8b2(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x78(%rbp)
jmp 0xf711
movq -0x78(%rbp), %rdi
movq 0x6b87c(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xf723
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_operator_increment()
void
test_set_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());

	std::cout << "myset:";
	while (from != until)
	{
		std::cout << ' ' << *from;
		++from;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xf7aa
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0xf777
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xf857
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7580
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x75b0
movq %rax, -0x68(%rbp)
movq 0x6b7e9(%rip), %rdi     # 0x7afb8
leaq 0x47b26(%rip), %rsi     # 0x572fc
callq 0x31e0
jmp 0xf7dd
jmp 0xf7df
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xf7f2
jmp 0xf830
movq 0x6b7bf(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0x88(%rbp)
jmp 0xf80c
leaq -0x60(%rbp), %rdi
callq 0x60c0
movq -0x88(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
jmp 0xf825
leaq -0x60(%rbp), %rdi
callq 0x97b0
jmp 0xf7df
movq 0x6b781(%rip), %rdi     # 0x7afb8
movq 0x6b75a(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xf845
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_iterators.cpp
// Function: test_set_iterators_operator_decrement()
void
test_set_iterators_operator_decrement()
{
	ft::set<int> myset;

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

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

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

	iter_type it(begin);
	while (it != end)
		std::cout << *it++ << ' ';
	std::cout << std::endl;

	while (it != begin)
		std::cout << *(--it) << ' ';
	std::cout << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xf8d0
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0xf89a
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf87b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xf9d7
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xf905
jmp 0xf949
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x60e0
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b692(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x90(%rbp)
jmp 0xf934
movq -0x90(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0xf947
jmp 0xf8f2
movq 0x6b668(%rip), %rdi     # 0x7afb8
movq 0x6b641(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xf95e
jmp 0xf960
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xf973
jmp 0xf9b0
leaq -0x70(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b62b(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x98(%rbp)
jmp 0xf99b
movq -0x98(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0xf9ae
jmp 0xf960
movq 0x6b601(%rip), %rdi     # 0x7afb8
movq 0x6b5da(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xf9c5
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
// File: 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
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq -0x60(%rbp), %rdi
callq 0x4830
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0xfa2a
jmp 0xfa80
movq 0x6b587(%rip), %rdi     # 0x7afb8
leaq 0x476b5(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0x98(%rbp)
jmp 0xfa46
movq -0x98(%rbp), %rdi
movq 0x6b544(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xfa5b
jmp 0xfa80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xfb07
leaq -0x60(%rbp), %rdi
callq 0x7580
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x75b0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0xfab9
jmp 0xfaec
movq 0x6b4f8(%rip), %rdi     # 0x7afb8
leaq 0x47626(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0xfad5
movq -0xa0(%rbp), %rdi
movq 0x6b4b5(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0xfaea
jmp 0xfaec
leaq -0x60(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3360
// File: 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
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x6b6dd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xfbb6
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0xfb83
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfb39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xfc3d
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xfbe3
jmp 0xfc2b
leaq -0x60(%rbp), %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b3c3(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x88(%rbp)
jmp 0xfc03
movq -0x88(%rbp), %rdi
leaq 0x486d9(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0xfc18
jmp 0xfc1a
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x60e0
movq %rax, -0x70(%rbp)
jmp 0xfbc3
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x6b59d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xfcf9
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0xfcc9
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfc79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfe07
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x7580
movq -0xc8(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x75b0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x75e0
jmp 0xfd3f
leaq -0x88(%rbp), %rdi
callq 0x7580
movq %rax, -0xa0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x75b0
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xfd7e
jmp 0xfde9
leaq -0xa0(%rbp), %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b225(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xd0(%rbp)
jmp 0xfda1
movq -0xd0(%rbp), %rdi
leaq 0x4853b(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0xfdb6
jmp 0xfdb8
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
callq 0x60e0
movq %rax, -0xb0(%rbp)
jmp 0xfd52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4960
jmp 0xfe07
leaq -0x88(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x4960
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x6b3cd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0xfed6
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0xfe9d
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfe49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0xff6d
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0xff13
jmp 0xff5b
leaq -0x70(%rbp), %rdi
callq 0x60c0
movl (%rax), %esi
movq 0x6b093(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x98(%rbp)
jmp 0xff33
movq -0x98(%rbp), %rdi
leaq 0x483a9(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0xff48
jmp 0xff4a
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x60e0
movq %rax, -0x80(%rbp)
jmp 0xfef3
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x10796
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x1075d
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1073b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x1089f
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7580
movq -0xb0(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x75b0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x11840
jmp 0x107d1
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x11840
jmp 0x107ee
leaq -0x70(%rbp), %rdi
callq 0x11860
movq %rax, -0xb8(%rbp)
jmp 0x10800
movq -0xb8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x11860
movq %rax, -0xc0(%rbp)
jmp 0x10820
movq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0x10844
jmp 0x1088d
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0x1085a
jmp 0x1088d
movq 0x6a757(%rip), %rdi     # 0x7afb8
leaq 0x47c75(%rip), %rsi     # 0x584dd
callq 0x31e0
movq %rax, -0xc8(%rbp)
jmp 0x10876
movq -0xc8(%rbp), %rdi
movq 0x6a714(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x1088b
jmp 0x1088d
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x10917
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x108e7
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x108cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x10992
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x11840
jmp 0x1093b
leaq -0x68(%rbp), %rdi
callq 0x11880
movq %rax, -0x88(%rbp)
jmp 0x1094d
movq -0x88(%rbp), %rax
movl (%rax), %esi
movq 0x6a65b(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x90(%rbp)
jmp 0x1096b
movq -0x90(%rbp), %rdi
movq 0x6a61f(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10980
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x10a16
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x109dd
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x109bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x10b1d
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x7580
movq -0xa0(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x75b0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x11840
jmp 0x10a51
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x11840
jmp 0x10a6e
movq 0x6a543(%rip), %rdi     # 0x7afb8
leaq 0x46880(%rip), %rsi     # 0x572fc
callq 0x31e0
jmp 0x10a83
jmp 0x10a85
leaq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x118b0
movb %al, -0xa1(%rbp)
jmp 0x10a9a
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x10aa6
jmp 0x10af6
movq 0x6a50b(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0xb0(%rbp)
jmp 0x10ac0
leaq -0x80(%rbp), %rdi
callq 0x11880
movq %rax, -0xb8(%rbp)
jmp 0x10ad2
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl (%rax), %esi
callq 0x3350
jmp 0x10ae9
leaq -0x80(%rbp), %rdi
callq 0x118e0
jmp 0x10af4
jmp 0x10a85
movq 0x6a4bb(%rip), %rdi     # 0x7afb8
movq 0x6a494(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10b0b
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x10ba6
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x10b6d
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10b4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x10d25
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x11840
jmp 0x10bc2
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x11840
jmp 0x10bde
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x11910
jmp 0x10bed
jmp 0x10bef
leaq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x118b0
movb %al, -0x92(%rbp)
jmp 0x10c04
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x10c10
jmp 0x10c6c
leaq -0x88(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x11930
jmp 0x10c24
leaq -0x88(%rbp), %rdi
callq 0x11880
movq %rax, -0xa0(%rbp)
jmp 0x10c39
movq -0xa0(%rbp), %rax
movl (%rax), %esi
movq 0x6a36f(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xa8(%rbp)
jmp 0x10c57
movq -0xa8(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x10c6a
jmp 0x10bef
movq 0x6a345(%rip), %rdi     # 0x7afb8
movq 0x6a31e(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10c81
jmp 0x10c83
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x118b0
movb %al, -0xa9(%rbp)
jmp 0x10c98
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x10ca4
jmp 0x10cfe
leaq -0x80(%rbp), %rdi
callq 0x11970
movq %rax, -0xb8(%rbp)
jmp 0x10cb6
movq -0xb8(%rbp), %rdi
callq 0x11880
movq %rax, -0xc0(%rbp)
jmp 0x10ccb
movq -0xc0(%rbp), %rax
movl (%rax), %esi
movq 0x6a2dd(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xc8(%rbp)
jmp 0x10ce9
movq -0xc8(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x10cfc
jmp 0x10c83
movq 0x6a2b3(%rip), %rdi     # 0x7afb8
movq 0x6a28c(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10d13
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nop
// File: 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
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x4830
leaq -0x60(%rbp), %rdi
callq 0x4830
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x119e0
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x11a10
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x119a0
movb %al, -0x91(%rbp)
jmp 0x10d9d
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x10da9
jmp 0x10dff
movq 0x6a208(%rip), %rdi     # 0x7afb8
leaq 0x46336(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x10dc5
movq -0xb8(%rbp), %rdi
movq 0x6a1c5(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10dda
jmp 0x10dff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x10eac
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x119e0
movq -0xd8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x11a10
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x119a0
movb %al, -0xb9(%rbp)
jmp 0x10e52
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x10e5e
jmp 0x10e91
movq 0x6a153(%rip), %rdi     # 0x7afb8
leaq 0x46281(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xe0(%rbp)
jmp 0x10e7a
movq -0xe0(%rbp), %rdi
movq 0x6a110(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x10e8f
jmp 0x10e91
leaq -0x60(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xe0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x6a32d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x10f66
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x10f33
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10ee9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x11014
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x119e0
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x11a10
movq -0x88(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x118b0
movb %al, -0x7a(%rbp)
jmp 0x10f9c
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x10fa5
jmp 0x11002
leaq -0x60(%rbp), %rdi
callq 0x11880
movq %rax, -0x90(%rbp)
jmp 0x10fb7
movq -0x90(%rbp), %rax
movl (%rax), %esi
movq 0x69ff1(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x98(%rbp)
jmp 0x10fd5
movq -0x98(%rbp), %rdi
leaq 0x47307(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x10fea
jmp 0x10fec
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x11930
jmp 0x10ffd
jmp 0x10f73
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0xf0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x6a1cd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x110c9
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x11099
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x11204
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x7580
movq -0xc8(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x75b0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x75e0
jmp 0x1110f
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x119e0
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x11a10
movq -0xd8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x118b0
movb %al, -0xc9(%rbp)
jmp 0x11157
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x11166
jmp 0x111e6
leaq -0xa0(%rbp), %rdi
callq 0x11880
movq %rax, -0xe0(%rbp)
jmp 0x1117b
movq -0xe0(%rbp), %rax
movl (%rax), %esi
movq 0x69e2d(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xe8(%rbp)
jmp 0x11199
movq -0xe8(%rbp), %rdi
leaq 0x47143(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x111ae
jmp 0x111b0
leaq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
xorl %edx, %edx
callq 0x11930
jmp 0x111c7
jmp 0x11122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4960
jmp 0x11204
leaq -0x88(%rbp), %rdi
callq 0x4960
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x4960
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq 0x69fcd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x112d6
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x1129d
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x113b4
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x119e0
movq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x11910
jmp 0x112fc
leaq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x11910
jmp 0x1130b
jmp 0x1130d
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x11a10
movq -0xa8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x118b0
movb %al, -0x99(%rbp)
jmp 0x11339
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x11345
jmp 0x113a2
leaq -0x70(%rbp), %rdi
callq 0x11880
movq %rax, -0xb0(%rbp)
jmp 0x11357
movq -0xb0(%rbp), %rax
movl (%rax), %esi
movq 0x69c51(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xb8(%rbp)
jmp 0x11375
movq -0xb8(%rbp), %rdi
leaq 0x46f67(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x1138a
jmp 0x1138c
leaq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
xorl %edx, %edx
callq 0x11930
jmp 0x1139d
jmp 0x1130d
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq -0x38(%rbp), %rdi
callq 0xdf50
movl $0x1, -0x3c(%rbp)
cmpl $0x5, -0x3c(%rbp)
jg 0x11b5f
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xe040
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x11b26
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11b04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x11d2b
leaq -0x30(%rbp), %rdi
callq 0x7660
jmp 0x11b6a
movl $0x4, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0xdf70
movq %rax, -0xf0(%rbp)
jmp 0x11b87
movq -0xf0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0x11bba
jmp 0x11be6
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe0f0
movq %rax, -0xf8(%rbp)
jmp 0x11bd8
movq -0xf8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x2, -0x94(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x94(%rbp), %rsi
callq 0xdf70
movq %rax, -0x100(%rbp)
jmp 0x11c09
movq -0x100(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0xa0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0x11c48
jmp 0x11c7a
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe0f0
movq %rax, -0x108(%rbp)
jmp 0x11c6c
movq -0x108(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x2a, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0xbc(%rbp), %rsi
callq 0xdf70
movq %rax, -0x110(%rbp)
jmp 0x11c9d
movq -0x110(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x75b0
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x6060
testb $0x1, %al
jne 0x11cdc
jmp 0x11d0e
movq -0x38(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe0f0
movq %rax, -0x118(%rbp)
jmp 0x11d00
movq -0x118(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7660
jmp 0x11d19
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x0, -0x34(%rbp)
cmpl $0x14, -0x34(%rbp)
jge 0x11dbe
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x11db1
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe040
movb %dl, -0x69(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x11d87
movb -0x69(%rbp), %al
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
jmp 0x11db1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x11e3a
jmp 0x11db3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11d5b
movl $0x0, -0x5c(%rbp)
cmpl $0x14, -0x5c(%rbp)
jge 0x11e13
leaq -0x30(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x12f50
movq %rax, -0x78(%rbp)
jmp 0x11dde
movq -0x78(%rbp), %rax
subq $0x1, %rax
leaq 0x45591(%rip), %rax     # 0x5737e
leaq 0x4558f(%rip), %rsi     # 0x57383
cmoveq %rax, %rsi
movq 0x691b9(%rip), %rdi     # 0x7afb8
callq 0x31e0
jmp 0x11e06
jmp 0x11e08
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x11dc5
movq 0x6919e(%rip), %rdi     # 0x7afb8
movq 0x69177(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x11e28
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
leaq -0x38(%rbp), %rdi
callq 0xdf50
leaq -0x40(%rbp), %rdi
callq 0xdf50
movl $0x1, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jge 0x12665
movl -0x44(%rbp), %ecx
addl %ecx, %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %eax
movl %eax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7770
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x1262c
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x125fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x12737
movl $0x1e, -0x74(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x12fb0
movq %rax, -0xb8(%rbp)
jmp 0x12682
movq -0xb8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x3c, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x12ff0
movq %rax, -0xc0(%rbp)
jmp 0x126b8
movq -0xc0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7660
jmp 0x126d6
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xe160
movq %rax, -0xc8(%rbp)
jmp 0x1270c
movq -0xc8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7660
jmp 0x12725
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3360
// File: 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
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x4830
movl $0x1, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jg 0x127c3
movl -0x34(%rbp), %ecx
addl %ecx, %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7770
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x1278a
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1275b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x128c5
leaq -0x68(%rbp), %rdi
callq 0x13030
jmp 0x127ce
movl $0x1e, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x13060
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x127f2
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x130a0
movq 0x6879c(%rip), %rdi     # 0x7afb8
leaq 0x44b6f(%rip), %rsi     # 0x57392
callq 0x31e0
movq %rax, -0xa8(%rbp)
jmp 0x12831
leaq -0x68(%rbp), %rdi
callq 0x60c0
movq -0xa8(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xb0(%rbp)
jmp 0x12851
movq -0xb0(%rbp), %rdi
movl $0xa, %esi
callq 0x3250
jmp 0x12864
movq 0x6874d(%rip), %rdi     # 0x7afb8
leaq 0x44b3c(%rip), %rsi     # 0x573ae
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x12880
leaq -0x60(%rbp), %rdi
callq 0x60c0
movq -0xb8(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xc0(%rbp)
jmp 0x128a0
movq -0xc0(%rbp), %rdi
movl $0xa, %esi
callq 0x3250
jmp 0x128b3
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nop
// File: 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
subq $0xb0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4830
movq -0x78(%rbp), %rdi
callq 0x13750
jmp 0x13393
movl $0x0, -0x4c(%rbp)
cmpl $0x5, -0x4c(%rbp)
jg 0x133ef
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0xe040
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x133b9
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1339a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x134d7
movq 0x67bc2(%rip), %rdi     # 0x7afb8
leaq 0x43cf8(%rip), %rsi     # 0x570f5
callq 0x31e0
jmp 0x13404
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x119e0
movq -0x98(%rbp), %rdi
callq 0x11880
movq %rax, -0x90(%rbp)
jmp 0x1342d
movq -0x90(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x70(%rbp)
movq 0x67b6b(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0xa0(%rbp)
jmp 0x13460
leaq -0x70(%rbp), %rdi
callq 0x60c0
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
jmp 0x13479
jmp 0x1347b
leaq -0x70(%rbp), %rdi
callq 0x97b0
movq %rax, %rdi
callq 0x60c0
movq %rax, %rsi
leaq -0x35(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x5c60
movb %al, -0xa1(%rbp)
jmp 0x134a4
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x13446
jmp 0x134b0
movq 0x67b01(%rip), %rdi     # 0x7afb8
movq 0x67ada(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x134c5
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
// File: 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
subq $0xb0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4830
movq -0x78(%rbp), %rdi
callq 0x13770
jmp 0x13503
movl $0x0, -0x4c(%rbp)
cmpl $0x5, -0x4c(%rbp)
jg 0x1355f
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0xe040
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x13529
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1350a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4960
jmp 0x13647
movq 0x67a52(%rip), %rdi     # 0x7afb8
leaq 0x43b88(%rip), %rsi     # 0x570f5
callq 0x31e0
jmp 0x13574
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x119e0
movq -0x98(%rbp), %rdi
callq 0x11880
movq %rax, -0x90(%rbp)
jmp 0x1359d
movq -0x90(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7580
movq %rax, -0x70(%rbp)
movq 0x679fb(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0xa0(%rbp)
jmp 0x135d0
leaq -0x70(%rbp), %rdi
callq 0x60c0
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
jmp 0x135e9
jmp 0x135eb
leaq -0x70(%rbp), %rdi
callq 0x97b0
movq %rax, %rdi
callq 0x60c0
movq %rax, %rsi
leaq -0x35(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x5c60
movb %al, -0xa1(%rbp)
jmp 0x13614
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x135b6
jmp 0x13620
movq 0x67991(%rip), %rdi     # 0x7afb8
movq 0x6796a(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x13635
leaq -0x30(%rbp), %rdi
callq 0x4960
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
// File: 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
subq $0xa0, %rsp
movaps 0x439de(%rip), %xmm0    # 0x57500
movaps %xmm0, -0x20(%rbp)
movabsq $0x1900000014, %rax     # imm = 0x1900000014
movq %rax, -0x10(%rbp)
leaq -0x14(%rbp), %rdx
movq %rdx, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe1b0
movq -0x98(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0xe1b0
jmp 0x13b62
leaq -0x50(%rbp), %rdi
callq 0x7660
jmp 0x13b6d
leaq -0x80(%rbp), %rdi
callq 0x7660
jmp 0x13b78
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x13e30
movq -0xa0(%rbp), %rdi
callq 0x7660
jmp 0x13b9a
leaq -0x80(%rbp), %rdi
callq 0x7660
jmp 0x13ba5
leaq -0x80(%rbp), %rdi
callq 0x4960
leaq -0x50(%rbp), %rdi
callq 0x4960
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x13bef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4960
leaq -0x50(%rbp), %rdi
callq 0x4960
movq -0x88(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)