LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x15634
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1561a
movq -0x28(%rbp), %rbx
movq 0x1c979(%rip), %rdi     # 0x31fb8
leaq 0xc28f(%rip), %rsi      # 0x218d5
callq 0x31d0
movl -0x10(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15672
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0x9, %eax
jg 0x156c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x156a6
movq -0x28(%rbp), %rbx
movq 0x1c8ed(%rip), %rdi     # 0x31fb8
leaq 0xc203(%rip), %rsi      # 0x218d5
callq 0x31d0
movl -0x10(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x28(%rbp), %rbx
movq 0x1c8c3(%rip), %rdi     # 0x31fb8
leaq 0xc1d9(%rip), %rsi      # 0x218d5
callq 0x31d0
movl -0x10(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15728
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0x9, %eax
jg 0x15776
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1575c
movq -0x30(%rbp), %rbx
movq 0x1c837(%rip), %rdi     # 0x31fb8
leaq 0xc172(%rip), %rsi      # 0x218fa
callq 0x31d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %rbx
movq 0x1c809(%rip), %rdi     # 0x31fb8
leaq 0xc164(%rip), %rsi      # 0x2191a
callq 0x31d0
subq %r14, %rbx
sarq $0x2, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31b0
leaq 0xbf09(%rip), %rsi      # 0x216dd
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x157fa
jmp 0x157fa
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x24(%rbp), %r14
movl %eax, -0x24(%rbp)
cmpl $0xa, %eax
jge 0x1584c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x24(%rbp), %eax
incl %eax
jmp 0x15832
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
movq 0x1c75d(%rip), %rdi     # 0x31fb8
leaq 0xc0c6(%rip), %rsi      # 0x21928
callq 0x31d0
movq 0x1c74a(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
cmpq %r15, %r12
je 0x15895
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl -0x4(%r12), %esi
addq $-0x4, %r12
movq %rax, %rdi
callq 0x3320
jmp 0x15872
movq 0x1c71c(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x158bb
jmp 0x158bb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x2c(%rbp), %r14
movl %eax, -0x2c(%rbp)
cmpl $0xa, %eax
jge 0x1590f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x158f5
movq -0x50(%rbp), %r13
movq -0x48(%rbp), %r15
xorl %r12d, %r12d
movq 0x1c697(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
leaq (%r15,%r12), %rax
cmpq %r13, %rax
je 0x1594c
movl -0x4(%r15,%r12), %esi
movq %rbx, %rdi
callq 0x3320
addq $-0x4, %r12
movq %rax, %rdi
movl %r14d, %esi
callq 0x3210
jmp 0x15925
movq 0x1c665(%rip), %rdi     # 0x31fb8
callq 0x30e0
movq 0x1c659(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
testq %r12, %r12
je 0x15985
movl (%r15,%r12), %esi
movq %rbx, %rdi
callq 0x3320
addq $0x4, %r12
movq %rax, %rdi
movl %r14d, %esi
callq 0x3210
jmp 0x15963
movq 0x1c62c(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x50(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x159af
jmp 0x159af
jmp 0x159af
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x159fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x159e3
movq -0x28(%rbp), %rbx
movq 0x1c5b0(%rip), %rdi     # 0x31fb8
leaq 0xbf23(%rip), %rsi      # 0x21932
callq 0x31d0
movl -0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15a3b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x15a89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x15a6f
movq -0x30(%rbp), %rbx
movq 0x1c524(%rip), %rdi     # 0x31fb8
leaq 0xbebb(%rip), %rsi      # 0x21956
callq 0x31d0
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15ac7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movaps %xmm0, -0x20(%rbp)
andq $0x0, -0x10(%rbp)
movq 0x1c4b8(%rip), %rdi     # 0x31fb8
leaq 0xb5e6(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x15b39
movq 0x1c493(%rip), %rdi     # 0x31fb8
leaq 0xb5c1(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x1c644(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0xa
popq %r15
pushq $0x64
popq %r12
leaq -0x24(%rbp), %r14
subl $0x1, %r15d
jb 0x15bc9
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x15ba7
movq -0x38(%rbp), %r15
movq 0x1c3e4(%rip), %rbx     # 0x31fb8
leaq 0xc70f(%rip), %r14      # 0x222ea
cmpq -0x40(%rbp), %r15
je 0x15bfe
movl -0x4(%r15), %esi
movq %rbx, %rdi
callq 0x3320
addq $-0x4, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
jmp 0x15bdb
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c16
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x20(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x64
popq %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq 0x8(%rbx), %r15
movq 0x1c359(%rip), %rbx     # 0x31fb8
leaq 0xc684(%rip), %r14      # 0x222ea
cmpq -0x38(%rbp), %r15
je 0x15c89
movl -0x4(%r15), %esi
movq %rbx, %rdi
callq 0x3320
addq $-0x4, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
jmp 0x15c66
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x20(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq 0x8(%rbx), %r15
movabsq $0x300000004, %rax      # imm = 0x300000004
movq %rax, -0x8(%r15)
movq 0x1c2c4(%rip), %rbx     # 0x31fb8
leaq 0xc5ef(%rip), %r14      # 0x222ea
cmpq -0x38(%rbp), %r15
je 0x15d1e
movl -0x4(%r15), %esi
movq %rbx, %rdi
callq 0x3320
addq $-0x4, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
jmp 0x15cfb
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector.cpp
// Function: test_vector()
void test_vector()
{
	subsection_wrapper(test_vector_constructors, "vector_constructors");
	subsection_wrapper(test_vector_capacity, "vector_capacity");
	subsection_wrapper(test_vector_iterators, "vector_iterators");
	subsection_wrapper(test_vector_reverse_iterators, "vector_reverse_iterators");
	subsection_wrapper(test_vector_element_access, "vector_element_access");
	subsection_wrapper(test_vector_modifiers, "vector_modifiers");
	subsection_wrapper(test_vector_allocator, "vector_allocator");
	subsection_wrapper(test_vector_non_member_overloads, "vector_non_member_overloads");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0xb81b(%rip), %rsi      # 0x219e6
leaq -0x110(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x26b2(%rip), %rdi      # 0x18894
leaq -0x110(%rbp), %rsi
callq 0x20c00
leaq -0x110(%rbp), %rdi
callq 0x30d0
leaq 0xb7f9(%rip), %rsi      # 0x219fa
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0xf04(%rip), %rdi       # 0x1711c
leaq -0xf0(%rbp), %rsi
callq 0x20c00
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0xb7d3(%rip), %rsi      # 0x21a0a
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x80a2(%rip), %rdi      # 0x1e2f0
leaq -0xd0(%rbp), %rsi
callq 0x20c00
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0xb7ae(%rip), %rsi      # 0x21a1b
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x53e(%rip), %rdi      # 0x15d46
leaq -0xb0(%rbp), %rsi
callq 0x20c00
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0xb791(%rip), %rsi      # 0x21a34
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x88e6(%rip), %rdi      # 0x1eba0
leaq -0x90(%rbp), %rsi
callq 0x20c00
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0xb771(%rip), %rsi      # 0x21a4a
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x5a6b(%rip), %rdi      # 0x1bd58
leaq -0x70(%rbp), %rsi
callq 0x20c00
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0xb755(%rip), %rsi      # 0x21a5b
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x1b47(%rip), %rdi      # 0x17e61
leaq -0x50(%rbp), %rsi
callq 0x20c00
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0xb739(%rip), %rsi      # 0x21a6c
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x3da(%rip), %rdi       # 0x16721
leaq -0x30(%rbp), %rsi
callq 0x20c00
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
jmp 0x163c6
jmp 0x163cd
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x30d0
jmp 0x163d0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_non_member_overloads.cpp
// Function: test_vector_non_member_overloads_relation_operators()
void
test_vector_non_member_overloads_relation_operators()
{

	ft::vector<int> foo (3, 100);   // three ints with a value of 100
	ft::vector<int> bar (2, 200);   // two ints with a value of 200

	if (foo == bar) std::cout << "foo and bar are equal" << std::endl;
	if (foo != bar) std::cout << "foo and bar are not equal" << std::endl;
	if (foo < bar) std::cout << "foo is less than bar" << std::endl;
	if (foo > bar) std::cout << "foo is greater than bar" << std::endl;
	if (foo <= bar) std::cout << "foo is less than or equal to bar" << std::endl;
	if (foo >= bar) std::cout << "foo is greater than or equal to bar" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x28(%rbp), %rdx
movl $0x64, (%rdx)
leaq -0x40(%rbp), %rdi
pushq $0x3
popq %rsi
leaq -0x10(%rbp), %rbx
movq %rbx, %rcx
callq 0x1465a
movl $0xc8, (%rbx)
leaq -0x28(%rbp), %rdi
pushq $0x2
popq %rsi
leaq -0x10(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x1465a
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15424
testb %al, %al
je 0x16444
movq 0x1bb88(%rip), %rdi     # 0x31fb8
leaq 0xafeb(%rip), %rsi      # 0x21422
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x167e7
testb %al, %al
je 0x16470
movq 0x1bb5c(%rip), %rdi     # 0x31fb8
leaq 0xafd5(%rip), %rsi      # 0x21438
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1549f
testb %al, %al
je 0x1649c
movq 0x1bb30(%rip), %rdi     # 0x31fb8
leaq 0xafc3(%rip), %rsi      # 0x21452
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1549f
testb %al, %al
je 0x164c8
movq 0x1bb04(%rip), %rdi     # 0x31fb8
leaq 0xafac(%rip), %rsi      # 0x21467
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x167f4
testb %al, %al
je 0x164f4
movq 0x1bad8(%rip), %rdi     # 0x31fb8
leaq 0xaf98(%rip), %rsi      # 0x2147f
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1680a
testb %al, %al
je 0x16520
movq 0x1baac(%rip), %rdi     # 0x31fb8
leaq 0xaf8d(%rip), %rsi      # 0x214a0
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x1654a
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x28(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x40(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x10(%rbp), %rbx
movq %rbx, %rcx
callq 0x1465a
movl $0xffffffd6, (%rbx)     # imm = 0xFFFFFFD6
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x10(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x1465a
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x40(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x28(%rbp)
movq %rax, -0x18(%rbp)
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x16607
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq 0xb461(%rip), %rsi      # 0x21a89
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq 0xb42f(%rip), %rsi      # 0x21a88
leaq -0x48(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0xa(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x28(%rbp)
movq %rax, -0x18(%rbp)
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x60(%rbp), %rdi
callq 0xa3b8
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x16710
movq %rax, %rbx
jmp 0x16710
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x16719
movq %rax, %rbx
jmp 0x16719
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x60(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x1b78c(%rip), %rbx     # 0x31fb8
leaq 0xa84e(%rip), %rsi      # 0x21081
movq %rbx, %rdi
callq 0x31d0
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq 0xb246(%rip), %rsi      # 0x21aa3
movq %rbx, %rdi
callq 0x31d0
movq 0x10(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x168c5
leaq 0xa805(%rip), %rsi      # 0x21095
movq %rbx, %rdi
callq 0x31d0
movq (%r14), %r12
leaq 0xba48(%rip), %r15      # 0x222ea
cmpq 0x8(%r14), %r12
je 0x168db
movl (%r12), %esi
movq %rbx, %rdi
callq 0x3320
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
addq $0x4, %r12
jmp 0x168a2
movq 0x1b6ec(%rip), %rdi     # 0x31fb8
leaq 0xb1db(%rip), %rsi      # 0x21aae
callq 0x31d0
movq %rax, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x10(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x28(%rbp), %rdi
callq 0x160d0
leaq -0x10(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x28(%rbp), %rdi
callq 0x160d0
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x16cd3
jmp 0x16cd3
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
pushq $0x3
popq %rsi
callq 0x174a6
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
pushq $0x7
popq %rsi
callq 0x174a6
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq 0xa2e3(%rip), %rsi      # 0x2110f
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
pushq $0x6
popq %rsi
leaq -0x30(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq 0xac64(%rip), %rsi      # 0x21aca
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
pushq $0x7
popq %rsi
leaq -0x30(%rbp), %rdx
callq 0x174de
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1751c
leaq -0x30(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1751c
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
callq 0xa3b8
leaq -0x30(%rbp), %rdi
callq 0xa3b8
leaq -0x48(%rbp), %rdi
callq 0xa3b8
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa3b8
jmp 0x16eed
jmp 0x16eea
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa3b8
jmp 0x16f0d
jmp 0x16f0a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x16f0d
jmp 0x16f0a
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x16f16
movq %rax, %rbx
jmp 0x16f16
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x10(%rbp), %rdx
movl $0x64, (%rdx)
leaq -0x28(%rbp), %rdi
pushq $0xa
popq %rsi
callq 0x17570
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x16ff7
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
callq 0x175aa
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
pushq $0x14
popq %rdi
callq 0x31e0
movq %rax, %rbx
xorl %eax, %eax
cmpq $0x5, %rax
je 0x17cf2
movl %eax, (%rbx,%rax,4)
incq %rax
jmp 0x17ce4
movq 0x1a2bf(%rip), %rdi     # 0x31fb8
leaq 0x933f(%rip), %rsi      # 0x2103f
callq 0x31d0
xorl %r12d, %r12d
movq 0x1a2a9(%rip), %r14     # 0x31fb8
pushq $0x20
popq %r15
cmpq $0x5, %r12
je 0x17d35
movq %r14, %rdi
movl %r15d, %esi
callq 0x3210
movl (%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x3320
incq %r12
jmp 0x17d13
movq 0x1a27c(%rip), %rdi     # 0x31fb8
callq 0x30e0
movq %rbx, %rdi
callq 0x31a0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17d63
jmp 0x17d63
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x17f28
movq %rbx, %rdi
callq 0x17f88
leaq -0x10(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x28(%rbp), %rdi
callq 0x1824e
leaq -0x28(%rbp), %rdi
callq 0x17f88
leaq -0x28(%rbp), %rdi
callq 0x181fa
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x17dd3
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x181fa
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x10(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x28(%rbp), %rdi
callq 0x160d0
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x18549
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x28(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x40(%rbp), %rbx
pushq $0x2a
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
jmp 0x1864b
jmp 0x18648
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x38(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x50(%rbp), %rbx
pushq $0x2a
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14fea
leaq -0x38(%rbp), %rdi
callq 0x16817
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14fea
leaq -0x20(%rbp), %rdi
callq 0x16817
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
leaq -0x50(%rbp), %rdi
callq 0xa746
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xa746
jmp 0x186eb
jmp 0x186e8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
jmp 0x186fb
jmp 0x186f8
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq 0x89f3(%rip), %rsi      # 0x2110f
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
pushq $0x2a
popq %rsi
leaq -0x30(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1751c
leaq -0x30(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1751c
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
callq 0xa3b8
leaq -0x30(%rbp), %rdi
callq 0xa3b8
leaq -0x48(%rbp), %rdi
callq 0xa3b8
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa3b8
jmp 0x187b0
jmp 0x187ad
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa3b8
jmp 0x187c0
jmp 0x187bd
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x187c9
movq %rax, %rbx
jmp 0x187c9
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x38(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x50(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14fea
leaq -0x38(%rbp), %rdi
callq 0x16817
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14fea
leaq -0x20(%rbp), %rdi
callq 0x16817
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
leaq -0x50(%rbp), %rdi
callq 0xa746
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xa746
jmp 0x18873
jmp 0x18870
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
jmp 0x18883
jmp 0x18880
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_constructors.cpp
// Function: test_vector_constructors()
void
test_vector_constructors()
{
	test_wrapper(test_vector_constructors_empty, "empty");
	test_wrapper(test_vector_constructors_fill_standard, "fill standard");
	test_wrapper(test_vector_constructors_range_standard, "range standard");
	test_wrapper(test_vector_constructors_copy, "copy");
	test_wrapper(test_vector_constructors_deepness, "deepness");
	test_wrapper(test_vector_constructors_strings, "strings");
	test_wrapper(test_vector_constructors_copy_const, "copy const");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
leaq 0x949c(%rip), %rsi      # 0x21d43
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x412(%rip), %rdi      # 0x184ac
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0x9329(%rip), %rsi      # 0x21c06
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x407(%rip), %rdi      # 0x184ed
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x9301(%rip), %rsi      # 0x21c14
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x3cd(%rip), %rdi      # 0x1855d
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x89fd(%rip), %rsi      # 0x21346
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x385(%rip), %rdi      # 0x185db
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x92a4(%rip), %rsi      # 0x21c23
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x337(%rip), %rdi      # 0x1865c
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x90ef(%rip), %rsi      # 0x21a9b
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x2b4(%rip), %rdi      # 0x1870c
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x9253(%rip), %rsi      # 0x21c2c
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x209(%rip), %rdi      # 0x187e4
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x18a5e
jmp 0x18a65
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x30d0
jmp 0x18a68
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_assign_range_empty_dest()
void
test_vector_modifiers_assign_range_empty_dest()
{
	ft::vector<std::string> vec(5, "test");
	ft::vector<std::string> new_vec;
	ft::vector<std::string>::iterator it = new_vec.begin();

	new_vec.assign(vec.begin(), vec.end());
	print_vec_info(vec);
	print_vec_info(new_vec);

	ft::vector<std::string>::iterator new_it = new_vec.begin();
	if (&*it != &*new_it)
		std::cout << "Reallocation occurred" << std::endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
leaq 0x85ff(%rip), %rsi      # 0x2110f
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x168ec
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x30d0
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1cccc
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq -0x30(%rbp), %rdi
callq 0x1694c
cmpq $0x0, -0x30(%rbp)
je 0x18b8d
movq 0x1943f(%rip), %rdi     # 0x31fb8
leaq 0x90b7(%rip), %rsi      # 0x21c37
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1751c
leaq -0x78(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1751c
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
callq 0xa3b8
leaq -0x78(%rbp), %rdi
callq 0xa3b8
leaq -0x30(%rbp), %rdi
callq 0xa3b8
leaq -0x48(%rbp), %rdi
callq 0xa3b8
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa3b8
jmp 0x18bf7
jmp 0x18bf4
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xa3b8
jmp 0x18c1c
jmp 0x18c19
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x18c2e
movq %rax, %rbx
jmp 0x18c2e
jmp 0x18c19
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa3b8
leaq -0x48(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_assign_range_not_empty_dest1()
void
test_vector_modifiers_assign_range_not_empty_dest1()
{
	ft::vector<std::string> vec(5, "test");
	ft::vector<std::string> new_vec(2, "42");
	ft::vector<std::string>::iterator it = new_vec.begin();

	print_vec_info(new_vec);
	new_vec.assign(vec.begin(), vec.end());
	print_vec_info(vec);
	print_vec_info(new_vec);

	ft::vector<std::string>::iterator new_it = new_vec.begin();
	if (&*it != &*new_it)
		std::cout << "Reallocation occurred" << std::endl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
leaq 0x84c9(%rip), %rsi      # 0x2110f
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x30a0
leaq -0x78(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq 0x8e12(%rip), %rsi      # 0x21a89
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x30a0
leaq -0x28(%rbp), %rdi
pushq $0x2
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0x28(%rbp), %rdi
movq (%rdi), %rbx
callq 0x1694c
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1cccc
leaq -0x78(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0x1694c
cmpq -0x28(%rbp), %rbx
je 0x18cf1
movq 0x192db(%rip), %rdi     # 0x31fb8
leaq 0x8f53(%rip), %rsi      # 0x21c37
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1751c
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1751c
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
callq 0xa3b8
leaq -0x48(%rbp), %rdi
callq 0xa3b8
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x78(%rbp), %rdi
callq 0xa3b8
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa3b8
jmp 0x18d5b
jmp 0x18d58
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa3b8
jmp 0x18d93
jmp 0x18d90
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x18d9c
movq %rax, %rbx
jmp 0x18d9c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x18da5
movq %rax, %rbx
jmp 0x18da5
jmp 0x18d90
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x78(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330