LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_copy()
void
test_map_iterators_copy()
{
	typedef ft::map<int, int>::iterator iterator;
	typedef ft::map<int, int>::const_iterator const_iterator;

	ft::map<int, int> map;

	srand(g_seed);

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

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

	for (const_iterator it = const_it; it != map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x473cd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x33efa
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, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x98(%rbp)
jmp 0x33e97
movq -0x98(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x33ebe
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x33e49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x34004
leaq -0x30(%rbp), %rdi
callq 0x2b0c0
movq %rax, -0x68(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x189d0
movq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18830
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x189d0
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x20dc0
testb $0x1, %al
jne 0x33f52
jmp 0x33fdd
movq 0x4705f(%rip), %rdi     # 0x7afb8
leaq 0x236b7(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x33f6e
leaq -0x78(%rbp), %rdi
callq 0x20e40
movq -0xb0(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xb8(%rbp)
jmp 0x33f8e
movq -0xb8(%rbp), %rdi
leaq 0x2367e(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xc0(%rbp)
jmp 0x33faa
leaq -0x78(%rbp), %rdi
callq 0x20e40
movq -0xc0(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x33fc4
jmp 0x33fc6
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x2ba90
movq %rax, -0x90(%rbp)
jmp 0x33f1c
movq 0x46fd4(%rip), %rdi     # 0x7afb8
movq 0x46fad(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33ff2
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_constructors()
void
test_stack_constructors()
{
	std::deque<int> mydeque(3, 100);
	std::list<int> mylist(3, 100);
	ft::vector<int> myvector(2, 200);

	ft::stack<int> first;
	ft::stack<int, std::deque<int> > second(mydeque);

	ft::stack<int, std::deque<int> > third;
	ft::stack<int, ft::vector<int> > fourth(myvector);
	ft::stack<int, std::list<int> > fifht(mylist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movl $0x64, -0x54(%rbp)
leaq -0x55(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x15410
movq -0x1d0(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x3, %esi
leaq -0x54(%rbp), %rdx
callq 0x35300
jmp 0x3457d
leaq -0x55(%rbp), %rdi
callq 0x48e0
movl $0x64, -0x84(%rbp)
leaq -0x85(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x15410
movq -0x1d8(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0x3, %esi
leaq -0x84(%rbp), %rdx
callq 0x35380
jmp 0x345c1
leaq -0x85(%rbp), %rdi
callq 0x48e0
movl $0xc8, -0xa4(%rbp)
leaq -0xa5(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x15410
movq -0x1e0(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
movl $0x2, %esi
leaq -0xa4(%rbp), %rdx
callq 0x35420
jmp 0x3460b
leaq -0xa5(%rbp), %rdi
callq 0x48e0
leaq -0xf8(%rbp), %rdi
callq 0x14d20
jmp 0x34625
leaq -0x148(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x354a0
jmp 0x34637
leaq -0x198(%rbp), %rdi
callq 0x14d20
jmp 0x34645
leaq -0x1b0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x354d0
jmp 0x3465a
leaq -0x1c8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x35500
jmp 0x3466c
leaq -0x1c8(%rbp), %rdi
callq 0x35530
leaq -0x1b0(%rbp), %rdi
callq 0x35550
leaq -0x198(%rbp), %rdi
callq 0x15230
leaq -0x148(%rbp), %rdi
callq 0x15230
leaq -0xf8(%rbp), %rdi
callq 0x15230
leaq -0xa0(%rbp), %rdi
callq 0x15250
leaq -0x80(%rbp), %rdi
callq 0x35570
leaq -0x50(%rbp), %rdi
callq 0x16540
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x48e0
jmp 0x347b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x85(%rbp), %rdi
callq 0x48e0
jmp 0x347ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa5(%rbp), %rdi
callq 0x48e0
jmp 0x347a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x34797
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3478b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3477f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x34773
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x35550
leaq -0x198(%rbp), %rdi
callq 0x15230
leaq -0x148(%rbp), %rdi
callq 0x15230
leaq -0xf8(%rbp), %rdi
callq 0x15230
leaq -0xa0(%rbp), %rdi
callq 0x15250
leaq -0x80(%rbp), %rdi
callq 0x35570
leaq -0x50(%rbp), %rdi
callq 0x16540
movq -0x60(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_empty()
void
test_stack_empty()
{
	ft::vector<int> vec(5, 42);
	ft::stack<int, ft::vector<int> > stack(vec);
	ft::stack<int> empty;

	if (!stack.empty())
		std::cout << "Valid" << std::endl;
	if (empty.empty())
		std::cout << "Valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x15410
movq -0xa0(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x347fd
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x354d0
jmp 0x34815
leaq -0x98(%rbp), %rdi
callq 0x14d20
jmp 0x34823
leaq -0x48(%rbp), %rdi
callq 0x35590
movb %al, -0xa1(%rbp)
jmp 0x34834
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x348cd
jmp 0x34844
movq 0x4676d(%rip), %rdi     # 0x7afb8
leaq 0x22fe2(%rip), %rsi     # 0x57834
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x34860
movq -0xb0(%rbp), %rdi
movq 0x4672a(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34875
jmp 0x348cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x34959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34947
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x15230
jmp 0x34947
leaq -0x98(%rbp), %rdi
callq 0x355b0
movb %al, -0xb1(%rbp)
jmp 0x348e1
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x348ed
jmp 0x34920
movq 0x466c4(%rip), %rdi     # 0x7afb8
leaq 0x22f39(%rip), %rsi     # 0x57834
callq 0x31e0
movq %rax, -0xc0(%rbp)
jmp 0x34909
movq -0xc0(%rbp), %rdi
movq 0x46681(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3491e
jmp 0x34920
leaq -0x98(%rbp), %rdi
callq 0x15230
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_size()
void
test_stack_size()
{
	ft::vector<int> vec(5, 42);
	ft::stack<int, ft::vector<int> > stack(vec);
	ft::stack<int> empty;

	std::cout << stack.size() << std::endl;
	std::cout << empty.size() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x15410
movq -0xa0(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x349ad
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x354d0
jmp 0x349c5
leaq -0x98(%rbp), %rdi
callq 0x14d20
jmp 0x349d3
leaq -0x48(%rbp), %rdi
callq 0x355d0
movq %rax, -0xa8(%rbp)
jmp 0x349e5
movq -0xa8(%rbp), %rsi
movq 0x465c5(%rip), %rdi     # 0x7afb8
callq 0x3080
movq %rax, -0xb0(%rbp)
jmp 0x34a01
movq -0xb0(%rbp), %rdi
movq 0x46589(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34a16
leaq -0x98(%rbp), %rdi
callq 0x355f0
movq %rax, -0xb8(%rbp)
jmp 0x34a2b
movq -0xb8(%rbp), %rsi
movq 0x4657f(%rip), %rdi     # 0x7afb8
callq 0x3080
movq %rax, -0xc0(%rbp)
jmp 0x34a47
movq -0xc0(%rbp), %rdi
movq 0x46543(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34a5c
leaq -0x98(%rbp), %rdi
callq 0x15230
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x34ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34ad7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34ace
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x15230
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_top()
void
test_stack_top()
{
	ft::vector<int> vec;

	for (int i = 0; i < 100; i++) vec.push_back(i);

	ft::stack<int, ft::vector<int> > stack(vec);

	std::cout << stack.top() << std::endl;
	stack.top() = 42;
	std::cout << stack.top() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0x64, -0x1c(%rbp)
jge 0x34b3b
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x34b1d
jmp 0x34b1f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34b08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34c02
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x354d0
jmp 0x34b4a
leaq -0x48(%rbp), %rdi
callq 0x35680
movq %rax, -0x50(%rbp)
jmp 0x34b59
movq -0x50(%rbp), %rax
movl (%rax), %esi
movq 0x46452(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x34b71
movq -0x58(%rbp), %rdi
movq 0x4641c(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34b83
leaq -0x48(%rbp), %rdi
callq 0x35680
movq %rax, -0x60(%rbp)
jmp 0x34b92
movq -0x60(%rbp), %rax
movl $0x2a, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x35680
movq %rax, -0x68(%rbp)
jmp 0x34bab
movq -0x68(%rbp), %rax
movl (%rax), %esi
movq 0x46400(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x70(%rbp)
jmp 0x34bc3
movq -0x70(%rbp), %rdi
movq 0x463ca(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34bd5
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35550
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_push_pop()
void
test_stack_push_pop()
{
	ft::stack<int> stack;

	for (int i = 0; i < 5; i++)
	{
		stack.push(i);
		std::cout << stack.top() << std::endl;
	}

	std::cout << "Popping out elements...";
	while (!stack.empty())
	{
		std::cout << stack.top() << std::endl;
		stack.pop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x50(%rbp), %rdi
callq 0x14d20
movl $0x0, -0x54(%rbp)
cmpl $0x5, -0x54(%rbp)
jge 0x34cb0
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x356a0
jmp 0x34c50
leaq -0x50(%rbp), %rdi
callq 0x356d0
movq %rax, -0x70(%rbp)
jmp 0x34c5f
movq -0x70(%rbp), %rax
movl (%rax), %esi
movq 0x4634c(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x78(%rbp)
jmp 0x34c77
movq -0x78(%rbp), %rdi
movq 0x46316(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34c89
jmp 0x34c8b
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x34c3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x15230
jmp 0x34d44
movq 0x46301(%rip), %rdi     # 0x7afb8
leaq 0x22b7c(%rip), %rsi     # 0x5783a
callq 0x31e0
jmp 0x34cc5
jmp 0x34cc7
leaq -0x50(%rbp), %rdi
callq 0x355b0
movb %al, -0x79(%rbp)
jmp 0x34cd5
movb -0x79(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x34ce0
jmp 0x34d32
leaq -0x50(%rbp), %rdi
callq 0x356d0
movq %rax, -0x88(%rbp)
jmp 0x34cf2
movq -0x88(%rbp), %rax
movl (%rax), %esi
movq 0x462b6(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x90(%rbp)
jmp 0x34d10
movq -0x90(%rbp), %rdi
movq 0x4627a(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x34d25
leaq -0x50(%rbp), %rdi
callq 0x356f0
jmp 0x34d30
jmp 0x34cc7
leaq -0x50(%rbp), %rdi
callq 0x15230
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_constructors_base()
void
test_vector_reverse_iterators_constructors_base()
{
	ft::vector<int> myvector;

	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	iter_type from(myvector.begin());
	iter_type until(myvector.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 $0x90, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39157
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x39130
jmp 0x39132
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3911b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39242
leaq -0x18(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x380c0
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x37f50
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3a8f0
jmp 0x3918c
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3a8f0
jmp 0x391a3
leaq -0x48(%rbp), %rdi
callq 0x3a910
movq %rax, -0x80(%rbp)
jmp 0x391b2
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3a910
movq %rax, -0x88(%rbp)
jmp 0x391cc
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3a930
testb $0x1, %al
jne 0x391ea
jmp 0x39230
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3a930
testb $0x1, %al
jne 0x391fd
jmp 0x39230
movq 0x41db4(%rip), %rdi     # 0x7afb8
leaq 0x1f2d2(%rip), %rsi     # 0x584dd
callq 0x31e0
movq %rax, -0x90(%rbp)
jmp 0x39219
movq -0x90(%rbp), %rdi
movq 0x41d71(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3922e
jmp 0x39230
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_star()
void
test_vector_reverse_iterators_operator_star()
{
	ft::vector<int> myvector;

	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	iter_type until(myvector.end());

	rev_iter_type rev_from(until);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x392a1
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x3927d
jmp 0x3927f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x3930d
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3a8f0
jmp 0x392c5
leaq -0x40(%rbp), %rdi
callq 0x3a970
movq %rax, -0x50(%rbp)
jmp 0x392d4
movq -0x50(%rbp), %rax
movl (%rax), %esi
movq 0x41cd7(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x392ec
movq -0x58(%rbp), %rdi
movq 0x41ca1(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x392fe
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_brackets()
void
test_vector_reverse_iterators_operator_brackets()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = myvector.rbegin();

	std::cout << "The fourth element from the end is: " << rev_it[3] << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39374
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x3934d
jmp 0x3934f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39338
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x393f7
leaq -0x38(%rbp), %rdi
callq 0x3a9a0
jmp 0x3937f
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x41c1d(%rip), %rdi     # 0x7afb8
leaq 0x1e541(%rip), %rsi     # 0x578e3
callq 0x31e0
movq %rax, -0x48(%rbp)
jmp 0x393ad
leaq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x3aa10
movq %rax, -0x50(%rbp)
jmp 0x393c1
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x393d6
movq -0x58(%rbp), %rdi
movq 0x41bb7(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x393e8
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_plus()
void
test_vector_reverse_iterators_operator_plus()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = 3 + myvector.rbegin();

	std::cout << "The fourth element from the end is: " << *rev_it << std::endl;

	rev_it = myvector.rbegin() + 3;

	std::cout << "The fourth element from the end is: " << *rev_it << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39457
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x39430
jmp 0x39432
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3941b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x3957e
leaq -0x38(%rbp), %rdi
callq 0x3a9a0
jmp 0x39462
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x3, %esi
callq 0x3aa40
jmp 0x39487
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x41b22(%rip), %rdi     # 0x7afb8
leaq 0x1e446(%rip), %rsi     # 0x578e3
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x394a8
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x70(%rbp)
jmp 0x394b7
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x78(%rbp)
jmp 0x394cc
movq -0x78(%rbp), %rdi
movq 0x41ac1(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x394de
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x3, %edx
callq 0x3aaa0
jmp 0x39503
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x41aa6(%rip), %rdi     # 0x7afb8
leaq 0x1e3ca(%rip), %rsi     # 0x578e3
callq 0x31e0
movq %rax, -0x88(%rbp)
jmp 0x39527
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x90(%rbp)
jmp 0x39539
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x98(%rbp)
jmp 0x39557
movq -0x98(%rbp), %rdi
movq 0x41a33(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3956c
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_minus()
void
test_vector_reverse_iterators_operator_minus()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = myvector.rend() - 3;

	std::cout << "myvector.rend() - 3 points to: " << *rev_it << std::endl;

	ft::reverse_iterator<iter_type> from, until;

	from = myvector.rbegin();
	until = myvector.rend();

	std::cout << "myvector has " << (until - from) << " elements." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x395e7
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x395c0
jmp 0x395c2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x395ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x3974f
leaq -0x38(%rbp), %rdi
callq 0x3a9a0
jmp 0x395f2
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3aaf0
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x3, %edx
callq 0x3ab40
jmp 0x39617
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x41992(%rip), %rdi     # 0x7afb8
leaq 0x1e2db(%rip), %rsi     # 0x57908
callq 0x31e0
movq %rax, -0x78(%rbp)
jmp 0x39638
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x80(%rbp)
jmp 0x39647
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x88(%rbp)
jmp 0x3965f
movq -0x88(%rbp), %rdi
movq 0x4192b(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39674
leaq -0x50(%rbp), %rdi
callq 0x3a9a0
jmp 0x3967f
leaq -0x58(%rbp), %rdi
callq 0x3a9a0
jmp 0x3968a
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0x3a9c0
movq -0x98(%rbp), %rsi
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3aaf0
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x418f3(%rip), %rdi     # 0x7afb8
leaq 0x1e25c(%rip), %rsi     # 0x57928
callq 0x31e0
movq %rax, -0x90(%rbp)
jmp 0x396da
leaq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ab90
movq %rax, -0xa0(%rbp)
jmp 0x396f0
movq -0xa0(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x3390
movq %rax, -0xa8(%rbp)
jmp 0x3970c
movq -0xa8(%rbp), %rdi
leaq 0x1dfd1(%rip), %rsi     # 0x576eb
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x39728
movq -0xb0(%rbp), %rdi
movq 0x41862(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3973d
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xb0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_increment()
void
test_vector_reverse_iterators_operator_increment()
{
	ft::vector<int> myvector;

	for (int i  = 0; i < 10; i++)
		myvector.push_back(i);

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

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

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

	std::cout << "myvector:";
	while (rev_from != rev_until)
	{
		std::cout << ' ' << *rev_from;
		++rev_from;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x397b7
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x39790
jmp 0x39792
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3977b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x398a0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x380c0
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x37f50
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3a8f0
jmp 0x397ec
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3a8f0
jmp 0x39803
movq 0x417ae(%rip), %rdi     # 0x7afb8
leaq 0x1e125(%rip), %rsi     # 0x57936
callq 0x31e0
jmp 0x39818
jmp 0x3981a
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3abd0
movb %al, -0x69(%rbp)
jmp 0x3982c
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x39835
jmp 0x39879
movq 0x4177c(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0x78(%rbp)
jmp 0x3984c
leaq -0x58(%rbp), %rdi
callq 0x3a970
movq %rax, -0x80(%rbp)
jmp 0x3985b
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rax
movl (%rax), %esi
callq 0x3350
jmp 0x3986c
leaq -0x58(%rbp), %rdi
callq 0x3ac00
jmp 0x39877
jmp 0x3981a
movq 0x41738(%rip), %rdi     # 0x7afb8
movq 0x41711(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3988e
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_decrement()
void
test_vector_reverse_iterators_operator_decrement()
{
	ft::vector<int> myvector;

	for (int i = 0 ; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_begin (myvector.end());
	ft::reverse_iterator<iter_type> rev_end (myvector.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 $0xa0, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39907
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x398e0
jmp 0x398e2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x398cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39a68
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3a8f0
jmp 0x39923
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3a8f0
jmp 0x3993f
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3ac30
jmp 0x3994e
jmp 0x39950
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3abd0
movb %al, -0x61(%rbp)
jmp 0x39962
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3996b
jmp 0x399b5
leaq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x3ac50
jmp 0x3997c
leaq -0x60(%rbp), %rdi
callq 0x3a970
movq %rax, -0x70(%rbp)
jmp 0x3998b
movq -0x70(%rbp), %rax
movl (%rax), %esi
movq 0x41620(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x78(%rbp)
jmp 0x399a3
movq -0x78(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x399b3
jmp 0x39950
movq 0x415fc(%rip), %rdi     # 0x7afb8
movq 0x415d5(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x399ca
jmp 0x399cc
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3abd0
movb %al, -0x79(%rbp)
jmp 0x399de
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x399e7
jmp 0x39a41
leaq -0x58(%rbp), %rdi
callq 0x3ac90
movq %rax, -0x88(%rbp)
jmp 0x399f9
movq -0x88(%rbp), %rdi
callq 0x3a970
movq %rax, -0x90(%rbp)
jmp 0x39a0e
movq -0x90(%rbp), %rax
movl (%rax), %esi
movq 0x4159a(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x98(%rbp)
jmp 0x39a2c
movq -0x98(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x39a3f
jmp 0x399cc
movq 0x41570(%rip), %rdi     # 0x7afb8
movq 0x41549(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39a56
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_plus_equal()
void
test_vector_reverse_iterators_operator_plus_equal()
{
	ft::vector<int> myvector;

	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_iterator = myvector.rbegin();

	rev_iterator += 2;

	std::cout << "The third element from the end is: " << *rev_iterator << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39ad1
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x39aad
jmp 0x39aaf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39b50
leaq -0x38(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x3acc0
jmp 0x39af2
movq 0x414bf(%rip), %rdi     # 0x7afb8
leaq 0x1de40(%rip), %rsi     # 0x57940
callq 0x31e0
movq %rax, -0x48(%rbp)
jmp 0x39b0b
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x50(%rbp)
jmp 0x39b1a
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x39b2f
movq -0x58(%rbp), %rdi
movq 0x4145e(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39b41
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_minus_equal()
void
test_vector_reverse_iterators_operator_minus_equal()
{
	ft::vector<int> myvector;

	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_iterator = myvector.rend();

	rev_iterator -= 4;

	std::cout <<  "rev_iterator now points to: " << *rev_iterator << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39bb1
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x39b8d
jmp 0x39b8f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39b78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39c30
leaq -0x38(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3aaf0
movq -0x40(%rbp), %rdi
movl $0x4, %esi
callq 0x3acf0
jmp 0x39bd2
movq 0x413df(%rip), %rdi     # 0x7afb8
leaq 0x1dd84(%rip), %rsi     # 0x57964
callq 0x31e0
movq %rax, -0x48(%rbp)
jmp 0x39beb
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x50(%rbp)
jmp 0x39bfa
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x39c0f
movq -0x58(%rbp), %rdi
movq 0x4137e(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39c21
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_empty_vectors()
void
test_vector_reverse_iterators_empty_vectors()
{
	ft::vector<int> vec;
	ft::vector<int> const const_vec;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x18(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x14d00
leaq -0x30(%rbp), %rdi
callq 0x14d00
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3a9c0
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3aaf0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3ad20
movb %al, -0x61(%rbp)
jmp 0x39c95
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x39c9e
jmp 0x39cf4
movq 0x41313(%rip), %rdi     # 0x7afb8
leaq 0x1d441(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0x88(%rbp)
jmp 0x39cba
movq -0x88(%rbp), %rdi
movq 0x412d0(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39ccf
jmp 0x39cf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39d9b
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x30(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x3ada0
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3adf0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3ad60
movb %al, -0x89(%rbp)
jmp 0x39d41
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x39d4d
jmp 0x39d80
movq 0x41264(%rip), %rdi     # 0x7afb8
leaq 0x1d392(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x39d69
movq -0xb0(%rbp), %rdi
movq 0x41221(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x39d7e
jmp 0x39d80
leaq -0x30(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_100_size_vector()
void
test_vector_reverse_iterators_100_size_vector()
{
	typedef ft::vector<int>::reverse_iterator reverse_iterator;

	ft::vector<int> vec;

	srand(g_seed);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
leaq 0x41440(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x39e40
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, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3ae40
jmp 0x39e19
jmp 0x39e1b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39dd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39ed6
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3aaf0
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3abd0
movb %al, -0x49(%rbp)
jmp 0x39e70
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x39e79
jmp 0x39ec7
leaq -0x38(%rbp), %rdi
callq 0x3a970
movq %rax, -0x60(%rbp)
jmp 0x39e88
movq -0x60(%rbp), %rax
movl (%rax), %esi
movq 0x41123(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x68(%rbp)
jmp 0x39ea0
movq -0x68(%rbp), %rdi
leaq 0x1e43f(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x39eb2
jmp 0x39eb4
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x3ac50
jmp 0x39ec5
jmp 0x39e4d
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_100_size_const_vector()
void
test_vector_reverse_iterators_100_size_const_vector()
{
	typedef ft::vector<int>::const_reverse_iterator const_reverse_iterator;

	ft::vector<int> const const_vec(100, 42);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15410
movq -0x50(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x64, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x39f14
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3ada0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3adf0
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3ae70
movb %al, -0x51(%rbp)
jmp 0x39f4d
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x39f56
jmp 0x39fd2
leaq -0x38(%rbp), %rdi
callq 0x3aea0
movq %rax, -0x68(%rbp)
jmp 0x39f65
movq -0x68(%rbp), %rax
movl (%rax), %esi
movq 0x41046(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x70(%rbp)
jmp 0x39f7d
movq -0x70(%rbp), %rdi
leaq 0x1e362(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x39f8f
jmp 0x39f91
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x3aed0
jmp 0x39fa2
jmp 0x39f2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x39fe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x39fe1
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_copy()
void
test_vector_reverse_iterators_copy()
{
	typedef ft::vector<int>::reverse_iterator reverse_iterator;
	typedef ft::vector<int>::const_reverse_iterator const_reverse_iterator;

	ft::vector<int> vec(6, 42);

	reverse_iterator it(vec.rbegin());
	*it = 3;
	*(it + 1) = 4;
	const_reverse_iterator const_it(it);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x15410
movq -0x68(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x3a027
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3a9c0
movq -0x78(%rbp), %rdi
callq 0x3a970
movq %rax, -0x70(%rbp)
jmp 0x3a050
movq -0x70(%rbp), %rax
movl $0x3, (%rax)
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x3aaa0
jmp 0x3a06e
leaq -0x40(%rbp), %rdi
callq 0x3a970
movq %rax, -0x80(%rbp)
jmp 0x3a07d
movq -0x80(%rbp), %rax
movl $0x4, (%rax)
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3af10
jmp 0x3a096
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3af40
jmp 0x3a0a5
jmp 0x3a0a7
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3aaf0
movq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3af60
movb %al, -0x81(%rbp)
jmp 0x3a0d3
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x3a0e2
jmp 0x3a16d
leaq -0x50(%rbp), %rdi
callq 0x3aea0
movq %rax, -0x98(%rbp)
jmp 0x3a0f4
movq -0x98(%rbp), %rax
movl (%rax), %esi
movq 0x40eb4(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0xa0(%rbp)
jmp 0x3a112
movq -0xa0(%rbp), %rdi
leaq 0x1e1ca(%rip), %rsi     # 0x582ea
callq 0x31e0
jmp 0x3a127
jmp 0x3a129
leaq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x3aed0
jmp 0x3a13a
jmp 0x3a0a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x3a17f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x3a17f
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_non_member_overloads.cpp
// Function: test_vector_non_member_overloads_swap_ints()
void
test_vector_non_member_overloads_swap_ints()
{
	ft::vector<int> v1(5, 42), v2(100, -42);

	print_vec_info(v1);
	print_vec_info(v2);

	swap(v1, v2);

	print_vec_info(v1);
	print_vec_info(v2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x15410
movq -0x58(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x3bb54
leaq -0x1d(%rbp), %rdi
callq 0x48e0
movl $0xffffffd6, -0x4c(%rbp) # imm = 0xFFFFFFD6
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x15410
movq -0x60(%rbp), %rcx
leaq -0x48(%rbp), %rdi
movl $0x64, %esi
leaq -0x4c(%rbp), %rdx
callq 0x35420
jmp 0x3bb89
leaq -0x4d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x3bb9d
leaq -0x48(%rbp), %rdi
callq 0x3c0a0
jmp 0x3bba8
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x3c1f0
movq -0x68(%rbp), %rdi
callq 0x3c0a0
jmp 0x3bbc4
leaq -0x48(%rbp), %rdi
callq 0x3c0a0
jmp 0x3bbcf
leaq -0x48(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x3bc33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x48e0
jmp 0x3bc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_non_member_overloads.cpp
// Function: test_vector_non_member_overloads_swap_strings()
void
test_vector_non_member_overloads_swap_strings()
{
	ft::vector<std::string> v1(5, "42"), v2(100, "-42");

	print_vec_info(v1);
	print_vec_info(v2);

	v1.swap(v2);

	print_vec_info(v1);
	print_vec_info(v2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3370
movq -0x98(%rbp), %rdx
leaq 0x1be2e(%rip), %rsi     # 0x57a97
leaq -0x38(%rbp), %rdi
callq 0x3290
jmp 0x3bc74
leaq -0x4d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x15360
movq -0xa0(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
leaq -0x38(%rbp), %rdx
callq 0x3c220
jmp 0x3bc9f
leaq -0x4d(%rbp), %rdi
callq 0x16ae0
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3230
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3370
movq -0xa8(%rbp), %rdx
leaq 0x1bdbb(%rip), %rsi     # 0x57a96
leaq -0x88(%rbp), %rdi
callq 0x3290
jmp 0x3bce9
leaq -0x8a(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x15360
movq -0xb0(%rbp), %rcx
leaq -0x68(%rbp), %rdi
movl $0x64, %esi
leaq -0x88(%rbp), %rdx
callq 0x3c220
jmp 0x3bd1a
leaq -0x8a(%rbp), %rdi
callq 0x16ae0
leaq -0x88(%rbp), %rdi
callq 0x3160
leaq -0x89(%rbp), %rdi
callq 0x3230
leaq -0x18(%rbp), %rdi
callq 0x3c2a0
jmp 0x3bd49
leaq -0x68(%rbp), %rdi
callq 0x3c2a0
jmp 0x3bd54
leaq -0x18(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x3c3f0
movq -0xb8(%rbp), %rdi
callq 0x3c2a0
jmp 0x3bd76
leaq -0x68(%rbp), %rdi
callq 0x3c2a0
jmp 0x3bd81
leaq -0x68(%rbp), %rdi
callq 0x152b0
leaq -0x18(%rbp), %rdi
callq 0x152b0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3bdc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x16ae0
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3230
jmp 0x3be31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3be05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x8a(%rbp), %rdi
callq 0x16ae0
leaq -0x88(%rbp), %rdi
callq 0x3160
leaq -0x89(%rbp), %rdi
callq 0x3230
jmp 0x3be28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x152b0
leaq -0x18(%rbp), %rdi
callq 0x152b0
movq -0x48(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_vec_info<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&)
void print_vec_info(Vector const& vec)
{
	std::cout << "Size: " << vec.size() << std::endl;
	std::cout << "Capacity: " << vec.capacity() << std::endl;

	if (vec.empty())
		std::cout << "Vector is empty" << std::endl;
	else
	{
		std::cout << "Values: ";
		for (typename Vector::const_iterator it = vec.begin(); it != vec.end(); it++)
			std::cout << *it << " ";
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3ef05(%rip), %rdi     # 0x7afb8
leaq 0x1afc7(%rip), %rsi     # 0x57081
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x376a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3080
movq %rax, %rdi
movq 0x3eeb6(%rip), %rsi     # 0x7af98
callq 0x3220
movq 0x3eeca(%rip), %rdi     # 0x7afb8
leaq 0x1b9bc(%rip), %rsi     # 0x57ab1
callq 0x31e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c450
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3080
movq %rax, %rdi
movq 0x3ee7b(%rip), %rsi     # 0x7af98
callq 0x3220
movq -0x8(%rbp), %rdi
callq 0x37cc0
testb $0x1, %al
jne 0x3c131
jmp 0x3c158
movq 0x3ee80(%rip), %rdi     # 0x7afb8
leaq 0x1b97d(%rip), %rsi     # 0x57abc
callq 0x31e0
movq %rax, %rdi
movq 0x3ee4a(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3c1e2
movq 0x3ee59(%rip), %rdi     # 0x7afb8
leaq 0x1af2f(%rip), %rsi     # 0x57095
callq 0x31e0
movq -0x8(%rbp), %rdi
callq 0x37710
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37740
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3c470
testb $0x1, %al
jne 0x3c198
jmp 0x3c1cf
leaq -0x10(%rbp), %rdi
callq 0x3b330
movl (%rax), %esi
movq 0x3ee0e(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, %rdi
leaq 0x1c131(%rip), %rsi     # 0x582ea
callq 0x31e0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3c4b0
movq %rax, -0x20(%rbp)
jmp 0x3c178
movq 0x3ede2(%rip), %rdi     # 0x7afb8
movq 0x3edbb(%rip), %rsi     # 0x7af98
callq 0x3220
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_not_full_vector()
void
test_vector_capacity_not_full_vector()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	vec.push_back(4);
	vec.push_back(2);
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x15410
movq -0x40(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x3cfd4
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x3cfe8
movl $0x4, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3ae40
jmp 0x3cffe
movl $0x2, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3ae40
jmp 0x3d014
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x3d01f
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x3d05a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)