LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17a41
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17a4c
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17a2b
movq -0x28(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1c568(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17aa5
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17ab0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17ac1
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17b09
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17b14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17af3
movq -0x28(%rbp), %rbx
movq 0x1c4a3(%rip), %rdi     # 0x33fd0
leaq 0xed9e(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c488(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17b85
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17b90
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17ba1
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17be9
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17bf4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17bd3
movq -0x28(%rbp), %rbx
movq 0x1c3c3(%rip), %rdi     # 0x33fd0
leaq 0xecbe(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c3a8(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x28(%rbp), %rbx
movq 0x1c36e(%rip), %rdi     # 0x33fd0
leaq 0xec69(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c353(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17cba
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17cc5
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17cd6
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17d1e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17d29
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17d08
movq -0x30(%rbp), %rbx
movq 0x1c28e(%rip), %rdi     # 0x33fd0
leaq 0xebae(%rip), %rsi      # 0x268f7
movl $0x1f, %edx
callq 0x2230
movl 0x8(%rbx), %esi
movq 0x1c273(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %rbx
movq 0x1c235(%rip), %rdi     # 0x33fd0
leaq 0xeb75(%rip), %rsi      # 0x26917
movl $0xd, %edx
callq 0x2230
subq %r14, %rbx
sarq $0x2, %rbx
movq 0x1c216(%rip), %rdi     # 0x33fd0
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rbx
leaq 0xe93f(%rip), %rsi      # 0x2670b
movl $0xa, %edx
movq %rax, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17e0e
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17e1b
jmp 0x17e1b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17e2c
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x17e78
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x17e83
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x24(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x9, %ecx
jl 0x17e62
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
movq 0x1c130(%rip), %rdi     # 0x33fd0
leaq 0xea7e(%rip), %rsi      # 0x26925
movl $0x9, %edx
callq 0x2230
movq 0x1c118(%rip), %rbx     # 0x33fd0
leaq -0x24(%rbp), %r14
cmpq %r15, %r12
je 0x17ee8
movb $0x20, -0x24(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movl -0x4(%r12), %esi
addq $-0x4, %r12
movq %rax, %rdi
callq 0x2330
jmp 0x17ebc
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1c0ca(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x17f21
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17f32
jmp 0x17f32
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x17f43
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x17f91
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x17f9c
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x17f7b
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r12
movq %r12, %r13
cmpq %r15, %r12
je 0x17ff1
movq 0x1c00f(%rip), %rbx     # 0x33fd0
leaq -0x2c(%rbp), %r14
movq %r12, %r13
movl -0x4(%r13), %esi
movq %rbx, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
addq $-0x4, %r13
cmpq %r15, %r13
jne 0x17fc8
movq 0x1bfd8(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1bfbd(%rip), %rbx     # 0x33fd0
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r12, %r13
je 0x1805c
movq 0x1bfa1(%rip), %r14     # 0x33fd0
leaq -0x2c(%rbp), %r15
movl (%r13), %esi
movq %r14, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
addq $0x4, %r13
cmpq %r12, %r13
jne 0x18033
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1bf56(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x18095
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x180aa
jmp 0x180aa
jmp 0x180aa
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x180bb
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x18103
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x1810e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x180ed
movq -0x28(%rbp), %rbx
movq 0x1bea9(%rip), %rdi     # 0x33fd0
leaq 0xe801(%rip), %rsi      # 0x2692f
movl $0x23, %edx
callq 0x2230
movl -0xc(%rbx), %esi
movq 0x1be8e(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1817f
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1818a
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1819b
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x181e3
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x181ee
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x181cd
movq -0x30(%rbp), %rbx
movq 0x1bdc9(%rip), %rdi     # 0x33fd0
leaq 0xe745(%rip), %rsi      # 0x26953
movl $0x1c, %edx
callq 0x2230
movl 0xc(%rbx), %esi
movq 0x1bdae(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1825f
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1826a
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1827b
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x1bd3f(%rip), %rbx     # 0x33fd0
leaq 0xde97(%rip), %r14      # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x7, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x1beb0(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r15d
leaq -0x1c(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x1837f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x1838a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1896a
decl %r15d
jne 0x18341
movq -0x38(%rbp), %r15
movq 0x1bc36(%rip), %rbx     # 0x33fd0
leaq 0xef69(%rip), %r14      # 0x2730a
movq -0x40(%rbp), %rdi
cmpq %rdi, %r15
je 0x183cc
movl -0x4(%r15), %esi
movq %rbx, %rdi
callq 0x2330
addq $-0x4, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
jmp 0x183a1
testq %rdi, %rdi
je 0x183d6
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x183e3
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x183f4
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x190, %edi            # imm = 0x190
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x190, %rax            # imm = 0x190
jne 0x18416
movl $0x190, %r12d           # imm = 0x190
movq 0x1bb9a(%rip), %r14     # 0x33fd0
leaq 0xeecd(%rip), %r15      # 0x2730a
testq %r12, %r12
je 0x18465
movl -0x4(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
addq $-0x4, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
jmp 0x1843d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x18, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x18, %rax
jne 0x184a2
movabsq $0x300000004, %rax      # imm = 0x300000004
movq %rax, 0x10(%rbx)
movl $0x18, %r12d
movq 0x1bb02(%rip), %r14     # 0x33fd0
leaq 0xee35(%rip), %r15      # 0x2730a
testq %r12, %r12
je 0x184fd
movl -0x4(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
addq $-0x4, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
jmp 0x184d5
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x14, %edi
callq 0x2200
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x30(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x18f6a
movq %rcx, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x190, %rcx            # imm = 0x190
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0xffffffd6, (%rax,%rdx) # imm = 0xFFFFFFD6
addq $0x4, %rdx
cmpq $0x190, %rdx            # imm = 0x190
jne 0x18fb0
movq %rcx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1928b
leaq -0x20(%rbp), %rdi
callq 0x1928b
leaq -0x40(%rbp), %rdi
movaps (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x18(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movaps %xmm0, -0x20(%rbp)
movq %rax, -0x10(%rbp)
callq 0x1928b
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19018
callq 0x21b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x19026
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x19043
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19043
callq 0x21b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x19051
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xda13(%rip), %rsi      # 0x26a86
leaq 0xda0e(%rip), %rdx      # 0x26a88
leaq -0x50(%rbp), %rdi
callq 0x2f88
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x5, %esi
callq 0x193f2
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x190a7
callq 0x21b0
leaq -0x50(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xd9d0(%rip), %rsi      # 0x26a85
leaq 0xd9cc(%rip), %rdx      # 0x26a88
callq 0x2f88
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x11(%rbp), %rcx
movl $0x64, %esi
callq 0x193f2
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x190e5
callq 0x21b0
leaq -0x68(%rbp), %rdi
callq 0x19488
leaq -0x30(%rbp), %rdi
callq 0x19488
leaq -0x68(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x30(%rbp)
movq %rax, -0x20(%rbp)
callq 0x19488
leaq -0x30(%rbp), %rdi
callq 0x19488
leaq -0x30(%rbp), %rdi
callq 0xac7c
leaq -0x68(%rbp), %rdi
callq 0xac7c
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x1917e
callq 0x21b0
jmp 0x1917e
movq %rax, %rbx
jmp 0x1917e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x19187
callq 0x21b0
jmp 0x19187
movq %rax, %rbx
jmp 0x19187
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xac7c
leaq -0x68(%rbp), %rdi
callq 0xac7c
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_vec_info<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x1ab30(%rip), %rbx     # 0x33fd0
leaq 0xcc04(%rip), %rsi      # 0x260ab
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0xd5d9(%rip), %rsi      # 0x26ad1
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x10(%r14), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x195a6
movq 0x1aa7e(%rip), %rdi     # 0x33fd0
leaq 0xcb66(%rip), %rsi      # 0x260bf
movl $0x8, %edx
callq 0x2230
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x195be
movq 0x1aa5d(%rip), %r15     # 0x33fd0
leaq 0xdd90(%rip), %r12      # 0x2730a
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
addq $0x20, %r13
cmpq 0x8(%r14), %r13
jne 0x1957a
jmp 0x195be
movq 0x1aa23(%rip), %rdi     # 0x33fd0
leaq 0xd528(%rip), %rsi      # 0x26adc
movl $0xf, %edx
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x20(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x1987f
leaq -0x30(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
movl $0x4, -0xc(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x198be
movl $0x4, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x198cb
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1896a
movl $0x2, -0xc(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x198ec
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x198f9
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1896a
leaq -0x30(%rbp), %rdi
callq 0x1928b
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x19910
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1991b
jmp 0x1991b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1992c
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_resize_smaller()
void
test_vector_capacity_resize_smaller()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	vec.resize(3);

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x1996b
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x1a370
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x199ae
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x199c6
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_resize_bigger_size()
void
test_vector_capacity_resize_bigger_size()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	vec.resize(7);

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x19a9f
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movl $0x7, %esi
callq 0x1a370
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19ae2
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19afa
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_resize_bigger_size_val()
void
test_vector_capacity_resize_bigger_size_val()
{
	ft::vector<std::string> vec(6, "test");
	print_vec_info(vec);

	vec.resize(7, "new test");

	{
		ft::vector<std::string> cpy1(vec);
		print_vec_info(cpy1);
		ft::vector<std::string> cpy2 = vec;
		print_vec_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xc635(%rip), %rsi      # 0x26151
leaq 0xc632(%rip), %rdx      # 0x26155
leaq -0x30(%rbp), %rdi
callq 0x2f88
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movl $0x6, %esi
callq 0x193f2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x19b50
callq 0x21b0
leaq -0x48(%rbp), %rdi
callq 0x19488
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xcf91(%rip), %rsi      # 0x26af8
leaq 0xcf92(%rip), %rdx      # 0x26b00
callq 0x2f88
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movl $0x7, %esi
callq 0x1a3a8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x19b93
callq 0x21b0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a41e
leaq -0x30(%rbp), %rdi
callq 0x19488
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a41e
leaq -0x60(%rbp), %rdi
callq 0x19488
leaq -0x60(%rbp), %rdi
callq 0xac7c
leaq -0x30(%rbp), %rdi
callq 0xac7c
leaq -0x48(%rbp), %rdi
callq 0xac7c
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xac7c
jmp 0x19bf6
jmp 0x19bf3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xac7c
jmp 0x19c1b
jmp 0x19c18
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x19c1b
callq 0x21b0
jmp 0x19c1b
jmp 0x19c18
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xac7c
movq %rbx, %rdi
callq 0x2340
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x19c24
callq 0x21b0
jmp 0x19c24
movq %rax, %rbx
jmp 0x19c24
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_resize_bigger_capacity()
void
test_vector_capacity_resize_bigger_capacity()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	vec.resize(10);

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x19c7b
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x1a370
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19cbe
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19cd6
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_resize_bigger_capacity_val()
void
test_vector_capacity_resize_bigger_capacity_val()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	vec.resize(10, 100);

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x19d15
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x24(%rbp), %rdx
movl $0x64, (%rdx)
leaq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x1a4ac
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19d62
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x19d6b
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19d7c
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_reserve_bigger_capacity()
void
test_vector_capacity_reserve_bigger_capacity()
{
	ft::vector<int> vec(6, 42);

	print_vec_info(vec);
	vec.reserve(100);
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x19dbb
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movl $0x64, %esi
callq 0x1a4e6
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19dfe
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19e16
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_capacity.cpp
// Function: test_vector_capacity_reserve_smaller_capacity()
void
test_vector_capacity_reserve_smaller_capacity()
{
	ft::vector<int> vec(6, 42);

	print_vec_info(vec);
	vec.reserve(-1);
	print_vec_info(vec);
	vec.reserve(1);
	print_vec_info(vec);
	vec.reserve(6);
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x19e55
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq 0xcdaa(%rip), %rdi      # 0x26c24
callq 0x20e0
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19e90
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_allocator.cpp
// Function: test_vector_allocator_cplusplus()
void
test_vector_allocator_cplusplus()
{
	ft::vector<int> myvector;
	int* p;
	unsigned int i;

	// allocate an array with space for 5 elements using vector's allocator:
	p = myvector.get_allocator().allocate(5);

	// construct values in-place on the array:
	for (i = 0; i < 5; i++)
		myvector.get_allocator().construct(&p[i], i);

	std::cout << "The allocated array contains:";
	for (i = 0; i < 5; i++)
		std::cout << ' ' << p[i];
	std::cout << std::endl;

	// destroy and deallocate:
	for (i = 0; i < 5; i++)
		myvector.get_allocator().destroy(&p[i]);
	myvector.get_allocator().deallocate(p, 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x14, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl %eax, (%rbx,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x1ad4e
movq 0x1926f(%rip), %r14     # 0x33fd0
leaq 0xb301(%rip), %rsi      # 0x26069
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2230
xorl %r12d, %r12d
leaq -0x21(%rbp), %r15
movb $0x20, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl (%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x2330
incq %r12
cmpq $0x5, %r12
jne 0x1ad7c
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_allocator.cpp
// Function: test_vector_allocator_custom_allocator()
void
test_vector_allocator_custom_allocator()
{
	ft::vector<int, custom_allocator<int> > vec(6, 42);
	print_vec_info(vec);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq 0x18(%rax), %rcx
movq %rcx, -0x10(%rbp)
xorl %ecx, %ecx
movl $0x2a, (%rax,%rcx)
addq $0x4, %rcx
cmpq $0x18, %rcx
jne 0x1ae15
addq %rcx, %rax
leaq -0x20(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x1b02e
movl $0x4, -0x24(%rbp)
movq -0x18(%rbp), %rsi
cmpq -0x10(%rbp), %rsi
je 0x1ae57
movl $0x4, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x18(%rbp)
jmp 0x1ae64
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0x1b3e8
leaq -0x20(%rbp), %rdi
callq 0x1b02e
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1ae7b
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1ae84
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1ae95
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors_fill_standard()
void
test_vector_constructors_fill_standard()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	// Because fill constructor only allocates exact needed memory
	// we test if push_back triggers same memory allocation as std
	vec.push_back(4);
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x1b62d
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
movl $0x4, -0x24(%rbp)
movq -0x18(%rbp), %rsi
cmpq -0x10(%rbp), %rsi
je 0x1b66c
movl $0x4, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x18(%rbp)
jmp 0x1b679
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0x1896a
leaq -0x20(%rbp), %rdi
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b690
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1b699
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b6aa
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors_copy()
void
test_vector_constructors_copy()
{
	ft::vector<int> vec(42, 42);
	print_vec_info(vec);

	ft::vector<int> cpy = vec;
	print_vec_info(cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0xa8, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0xa8, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0xa8, %rdx
jne 0x1b77c
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e8
leaq -0x38(%rbp), %rdi
callq 0x1928b
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1b7c1
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b7cf
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1b7ee
callq 0x21b0
jmp 0x1b7ee
jmp 0x1b7eb
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b7fc
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors_deepness()
void
test_vector_constructors_deepness()
{
	ft::vector<int> vec(42, 42);
	print_vec_info(vec);

	{
		ft::vector<int> cpy1(vec);
		print_vec_info(cpy1);
		ft::vector<int> cpy2 = vec;
		print_vec_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0xa8, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0xa8, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0xa8, %rdx
jne 0x1b83e
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e8
leaq -0x50(%rbp), %rdi
callq 0x1928b
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e8
leaq -0x38(%rbp), %rdi
callq 0x1928b
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1b899
callq 0x21b0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1b8a7
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b8b5
callq 0x21b0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1b8d4
callq 0x21b0
jmp 0x1b8d4
jmp 0x1b8d1
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1b8e9
callq 0x21b0
jmp 0x1b8e9
jmp 0x1b8e6
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b8f7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors_strings()
void
test_vector_constructors_strings()
{
	ft::vector<std::string> vec(42, "test");
	print_vec_info(vec);

	{
		ft::vector<std::string> cpy1(vec);
		print_vec_info(cpy1);
		ft::vector<std::string> cpy2 = vec;
		print_vec_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xa838(%rip), %rsi      # 0x26151
leaq 0xa835(%rip), %rdx      # 0x26155
leaq -0x30(%rbp), %rdi
callq 0x2f88
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movl $0x2a, %esi
callq 0x193f2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1b94d
callq 0x21b0
leaq -0x48(%rbp), %rdi
callq 0x19488
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a41e
leaq -0x30(%rbp), %rdi
callq 0x19488
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a41e
leaq -0x60(%rbp), %rdi
callq 0x19488
leaq -0x60(%rbp), %rdi
callq 0xac7c
leaq -0x30(%rbp), %rdi
callq 0xac7c
leaq -0x48(%rbp), %rdi
callq 0xac7c
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xac7c
jmp 0x1b9b9
jmp 0x1b9b6
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xac7c
jmp 0x1b9c9
jmp 0x1b9c6
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xac7c
movq %rbx, %rdi
callq 0x2340
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1b9d2
callq 0x21b0
jmp 0x1b9d2
movq %rax, %rbx
jmp 0x1b9d2
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors_copy_const()
void
test_vector_constructors_copy_const()
{
	ft::vector<int> vec(6, 42);
	print_vec_info(vec);

	ft::vector<int> const const_vec1(vec);
	print_vec_info(const_vec1);

	ft::vector<int> const const_vec2 = vec;
	print_vec_info(const_vec2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x18, %rdx
jne 0x1ba29
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e8
leaq -0x50(%rbp), %rdi
callq 0x1928b
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e8
leaq -0x38(%rbp), %rdi
callq 0x1928b
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1ba81
callq 0x21b0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1ba8f
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1ba9d
callq 0x21b0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1babc
callq 0x21b0
jmp 0x1babc
jmp 0x1bab9
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1bad1
callq 0x21b0
jmp 0x1bad1
jmp 0x1bace
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1badf
callq 0x21b0
movq %rbx, %rdi
callq 0x2340