LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_minus()
void
test_vector_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;

	iter_type it = myvector.end() - 3;

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

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

	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 0x22651
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x2265c
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x2263b
movq -0x28(%rbp), %rbx
movq 0x1195b(%rip), %rdi     # 0x33fd0
leaq 0x4b3b(%rip), %rsi      # 0x271b7
movl $0x1e, %edx
callq 0x2230
movl -0xc(%rbx), %esi
movq 0x11940(%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 0x11902(%rip), %rdi     # 0x33fd0
leaq 0x4242(%rip), %rsi      # 0x26917
movl $0xd, %edx
callq 0x2230
subq %r14, %rbx
sarq $0x2, %rbx
movq 0x118e3(%rip), %rdi     # 0x33fd0
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rbx
leaq 0x400c(%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 0x22741
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2274e
jmp 0x2274e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2275f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_increment()
void
test_vector_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());

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

	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 0x227ad
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x227b8
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x22797
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r13
movq 0x117fb(%rip), %rbx     # 0x33fd0
leaq 0x4149(%rip), %rsi      # 0x26925
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2230
cmpq %r13, %r12
je 0x22822
movq 0x117db(%rip), %r14     # 0x33fd0
leaq -0x2c(%rbp), %r15
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl (%r12), %esi
movq %rax, %rdi
callq 0x2330
addq $0x4, %r12
cmpq %r13, %r12
jne 0x227f9
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x11790(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2285b
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2286e
jmp 0x2286e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2287f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_decrement()
void
test_vector_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;

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

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

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x228cd
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x228d8
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x228b7
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r15
movq %r12, %r13
cmpq %r15, %r12
je 0x2292d
movq 0x116d3(%rip), %rbx     # 0x33fd0
leaq -0x2c(%rbp), %r14
movq %r12, %r13
movl (%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 0x22904
movq 0x1169c(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x11681(%rip), %rbx     # 0x33fd0
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r12, %r13
je 0x22998
movq 0x11665(%rip), %r14     # 0x33fd0
leaq -0x2c(%rbp), %r15
movl -0x4(%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 0x2296f
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1161a(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x229d1
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x229e6
jmp 0x229e6
jmp 0x229e6
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x229f7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_plus_equal()
void
test_vector_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;

	iter_type it = myvector.begin();

	it += 2;

	std::cout << "The third element from the begin is: " << *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 0x22a3f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x22a4a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x22a29
movq -0x30(%rbp), %rbx
movq 0x1156d(%rip), %rdi     # 0x33fd0
leaq 0x476c(%rip), %rsi      # 0x271d6
movl $0x25, %edx
callq 0x2230
movl 0x8(%rbx), %esi
movq 0x11552(%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 0x22abb
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x22ac6
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x22ad7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_minus_equal()
void
test_vector_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;

	iter_type it = myvector.end();

	it -= 4;

	std::cout <<  "rev_iterator now points to: " << *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 0x22b1f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x22b2a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x22b09
movq -0x28(%rbp), %rbx
movq 0x1148d(%rip), %rdi     # 0x33fd0
leaq 0x3e09(%rip), %rsi      # 0x26953
movl $0x1c, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x11472(%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 0x22b9b
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x22ba6
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x22bb7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_empty_vectors()
void
test_vector_iterators_empty_vectors()
{
	ft::vector<int> vec;
	ft::vector<int> const const_vec;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x11403(%rip), %rbx     # 0x33fd0
leaq 0x355b(%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_iterators.cpp
// Function: test_vector_iterators_100_size_vector()
void
test_vector_iterators_100_size_vector()
{
	typedef ft::vector<int>::iterator iterator;

	ft::vector<int> vec;

	srand(g_seed);

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

	for (iterator it = vec.begin(); it != vec.end(); 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 0x11574(%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 0x22cbb
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x22cc6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1896a
decl %r15d
jne 0x22c7d
movq -0x40(%rbp), %r15
cmpq -0x38(%rbp), %r15
je 0x22d08
movq 0x112f4(%rip), %rbx     # 0x33fd0
leaq 0x4627(%rip), %r14      # 0x2730a
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
addq $0x4, %r15
cmpq -0x38(%rbp), %r15
jne 0x22ce3
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x22d16
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22d23
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x22d34
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_100_size_const_vector()
void
test_vector_iterators_100_size_const_vector()
{
	typedef ft::vector<int>::const_iterator const_iterator;

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

	for (const_iterator it = const_vec.begin(); it != const_vec.end(); 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 0x22d56
xorl %r12d, %r12d
movq 0x1125d(%rip), %r14     # 0x33fd0
leaq 0x4590(%rip), %r15      # 0x2730a
movl (%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
addq $0x4, %r12
cmpq $0x190, %r12            # imm = 0x190
jne 0x22d7a
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_iterators.cpp
// Function: test_vector_iterators_copy()
void
test_vector_iterators_copy()
{
	typedef ft::vector<int>::iterator iterator;
	typedef ft::vector<int>::const_iterator const_iterator;

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

	iterator it(vec.begin());
	*it = 3;
	*(it + 1) = 4;
	const_iterator const_it(it);

	for (const_iterator it = const_it; it != vec.end(); 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 0x22de0
movabsq $0x400000003, %rax      # imm = 0x400000003
movq %rax, (%rbx)
xorl %r12d, %r12d
movq 0x111c8(%rip), %r14     # 0x33fd0
leaq 0x44fb(%rip), %r15      # 0x2730a
movl (%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
addq $0x4, %r12
cmpq $0x18, %r12
jne 0x22e0f
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_iterators.cpp
// Function: test_vector_iterators_compare_const()
void
test_vector_iterators_compare_const()
{
	typedef ft::vector<int>::iterator iterator;
	typedef ft::vector<int>::const_iterator const_iterator;

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

	iterator it(vec.begin());
	*it = 3;
	*(it + 1) = 4;
	const_iterator const_it(it);

	std::cout << (it == const_it) << std::endl;
	std::cout << (it != const_it) << std::endl;
	std::cout << (it < const_it) << std::endl;
	std::cout << (it > const_it) << std::endl;
	std::cout << (it <= const_it) << std::endl;
	std::cout << (it >= const_it) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x18, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x18, %rax
jne 0x22e6e
movabsq $0x400000003, %rax      # imm = 0x400000003
movq %rax, (%rbx)
movq 0x1113d(%rip), %rdi     # 0x33fd0
movl $0x1, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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 0x11102(%rip), %rdi     # 0x33fd0
xorl %esi, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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 0x110ca(%rip), %rdi     # 0x33fd0
xorl %esi, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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 0x11092(%rip), %rdi     # 0x33fd0
xorl %esi, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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 0x1105a(%rip), %rdi     # 0x33fd0
movl $0x1, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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 0x1101f(%rip), %rdi     # 0x33fd0
movl $0x1, %esi
callq 0x2320
movq %rax, %r14
movq (%rax), %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
popq %rbx
popq %r14
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_element_access.cpp
// Function: test_vector_element_access_brackets()
void
test_vector_element_access_brackets()
{
	ft::vector<int> vec;

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);
	}
	print_vec_info(vec);

	std::cout << vec[2] << std::endl;
	vec[2] = 42;
	std::cout << vec[2] << 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 0x234e8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x234f3
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x234d2
leaq -0x30(%rbp), %rdi
callq 0x1928b
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x10ab8(%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), %rax
movl $0x2a, 0x8(%rax)
movq 0x10a77(%rip), %rdi     # 0x33fd0
movl $0x2a, %esi
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 0x2359b
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x235a6
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x235b7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_at()
void
test_vector_element_access_at()
{
	ft::vector<int> vec;

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);
	}
	print_vec_info(vec);

	std::cout << vec.at(2) << std::endl;
	vec.at(2) = 42;
	std::cout << vec.at(2) << 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 0x23742
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x2374d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x2372c
leaq -0x30(%rbp), %rdi
callq 0x1928b
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq $0x3, %rdx
jb 0x23824
movl 0x8(%rax), %esi
movq 0x10849(%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), %rax
movq -0x28(%rbp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jbe 0x23824
movl $0x2a, 0x8(%rax)
movq 0x107f7(%rip), %rdi     # 0x33fd0
movl $0x2a, %esi
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 0x2381b
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2d91(%rip), %rdi      # 0x265bc
movl $0x2, %esi
xorl %eax, %eax
callq 0x22a0
jmp 0x23839
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2384a
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_front()
void
test_vector_element_access_front()
{
	ft::vector<int> vec(10, 10);
	print_vec_info(vec);

	vec.front() = 42;
	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 $0x28, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0xa, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x28, %rdx
jne 0x23a51
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movq (%rdi), %rax
movl $0x2a, (%rax)
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23a8f
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23aa7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_back()
void
test_vector_element_access_back()
{
	ft::vector<int> vec(10, 10);
	print_vec_info(vec);

	vec.back() = 42;
	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 $0x28, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0xa, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x28, %rdx
jne 0x23ae6
leaq -0x20(%rbp), %rdi
movq %rcx, 0x8(%rdi)
callq 0x1928b
leaq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rax
movl $0x2a, -0x4(%rax)
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23b26
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23b3e
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_front_back_mix()
void
test_vector_element_access_front_back_mix()
{
	ft::vector<int> myvector;

	myvector.push_back(78);
	myvector.push_back(16);

	myvector.front() -= myvector.back();

	std::cout << "myvector.front() is now " << myvector.front() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x4e, -0xc(%rbp)
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0x23b7e
movl $0x4e, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x23b8b
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1896a
movl $0x10, -0xc(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x23bac
movl $0x10, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x23bb9
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x1896a
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x4(%rcx), %ecx
subl %ecx, (%rax)
movq 0x10403(%rip), %rdi     # 0x33fd0
leaq 0x3628(%rip), %rsi      # 0x271fc
movl $0x18, %edx
callq 0x2230
movq -0x30(%rbp), %rax
movl (%rax), %esi
movq 0x103e5(%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 0x23c28
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x23c33
jmp 0x23c33
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x23c44
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_data()
void
test_vector_element_access_data()
{
	ft::vector<int> myvector(5);

	print_vec_info(myvector);

	int* p = myvector.data();

	*p = 10;
	++p;
	*p = 20;
	p[2] = 100;

	print_vec_info(myvector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x14, %edi
callq 0x2200
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x14(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1928b
leaq -0x20(%rbp), %rdi
movq (%rdi), %rax
movabsq $0x140000000a, %rcx     # imm = 0x140000000A
movq %rcx, (%rax)
movl $0x64, 0xc(%rax)
callq 0x1928b
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23cc7
callq 0x21b0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
jmp 0x23cd0
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23ce1
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_less.cpp
// Function: test_less()
void test_less()
{
	int foo[]={10, 20, 5, 15, 25};
	int bar[]={15, 10, 20};
	std::sort(foo, foo + 5, ft::less<int>());  // 5 10 15 20 25
	std::sort(bar, bar + 3, ft::less<int>());  //   10 15 20
	if (std::includes (foo, foo + 5, bar, bar + 3, ft::less<int>()))
		std::cout << "foo includes bar." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movaps 0x322c(%rip), %xmm0     # 0x27270
leaq -0x1c(%rbp), %rsi
movaps %xmm0, -0x14(%rsi)
movl $0x19, -0x4(%rsi)
movabsq $0xa0000000f, %rax      # imm = 0xA0000000F
leaq -0xc(%rbp), %rbx
movq %rax, -0xc(%rbx)
movl $0x14, -0x4(%rbx)
leaq -0x30(%rbp), %rdi
callq 0x240fa
leaq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0x240fa
xorl %eax, %eax
xorl %ecx, %ecx
movl -0x18(%rbp,%rax), %edx
movl -0x30(%rbp,%rcx), %esi
cmpl %esi, %edx
jl 0x240f3
setle %dl
movzbl %dl, %edx
leaq (%rax,%rdx,4), %rax
cmpq $0x10, %rcx
je 0x240ab
addq $0x4, %rcx
cmpq $0xc, %rax
jne 0x24085
cmpq $0xc, %rax
jne 0x240f3
movq 0xff18(%rip), %rbx      # 0x33fd0
leaq 0x31d1(%rip), %rsi      # 0x27290
movl $0x11, %edx
movq %rbx, %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
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_relational_operators()
void
test_pair_relational_operators()
{
	ft::pair<int, char> foo(10, 'z');
	ft::pair<int, char> bar(90, 'a');

	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
pushq %rax
movq 0xf812(%rip), %rbx      # 0x33fd0
leaq 0x1cb3(%rip), %rsi      # 0x26478
movl $0x19, %edx
movq %rbx, %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
leaq 0x1c92(%rip), %rsi      # 0x26492
movl $0x14, %edx
movq %rbx, %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
leaq 0x1c84(%rip), %rsi      # 0x264bf
movl $0x20, %edx
movq %rbx, %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
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_make_pair()
void
test_pair_make_pair()
{
	ft::pair<int, int> foo;
	ft::pair<int, int> bar;

	foo = ft::make_pair(10, 20);
	bar = ft::make_pair(10.5, 'A');

	std::cout << "foo: " << foo.first << ", " << foo.second << std::endl;
	std::cout << "bar: " << bar.first << ", " << bar.second << std::endl;

	{
		ft::pair<int, int> cpy1 = foo;
		(void)cpy1;
		ft::pair<int, int> cpy2 = bar;
		(void)cpy2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xf74a(%rip), %rbx      # 0x33fd0
leaq 0x2a76(%rip), %rsi      # 0x27303
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2330
movq %rax, %r15
leaq 0x2a58(%rip), %r14      # 0x27309
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
movq %r15, %rdi
movl $0x14, %esi
callq 0x2330
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 0x2a0d(%rip), %rsi      # 0x2730c
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2330
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
movq %rbx, %rdi
movl $0x41, %esi
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
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair()
void
test_pair()
{
	test_wrapper(test_pair_constructors, "constructors");
	test_wrapper(test_pair_assignement_overload, "assignement overload");
	test_wrapper(test_pair_relational_operators, "relational operators");
	test_wrapper(test_pair_make_pair, "make_pair");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1eee(%rip), %rsi      # 0x26878
leaq 0x1ef3(%rip), %rdx      # 0x26884
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x82f(%rip), %rdi      # 0x24178
movq %rbx, %rsi
callq 0x25e66
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x249c0
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2943(%rip), %rsi      # 0x27312
leaq 0x2950(%rip), %rdx      # 0x27326
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x4d5(%rip), %rdi      # 0x24514
movq %rbx, %rsi
callq 0x25e66
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x249ff
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2919(%rip), %rsi      # 0x27327
leaq 0x2926(%rip), %rdx      # 0x2733b
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x277(%rip), %rdi      # 0x247b1
movq %rbx, %rsi
callq 0x25e66
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x24a3e
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2a36(%rip), %rsi      # 0x27483
leaq 0x2a38(%rip), %rdx      # 0x2748c
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x1f2(%rip), %rdi      # 0x24875
movq %rbx, %rsi
callq 0x25e66
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x24a7d
callq 0x21b0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x24aae
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x24aae
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0x24aae
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x24ab8
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_equal.cpp
// Function: test_equal()
void
test_equal()
{
	int myints[] = {20, 40, 60, 80, 100};
	ft::vector<int> myvector(myints, myints + 5);

	// using default comparison:
	if (ft::equal(myvector.begin(), myvector.end(), myints))
		std::cout << "The contents of both sequences are equal." << std::endl;
	else
		std::cout << "The contents of both sequences differ." << std::endl;

	myvector[3] = 81;

	// using predicate comparison:
	if (std::equal (myvector.begin(), myvector.end(), myints, mypredicate))
		std::cout << "The contents of both sequences are equal." << std::endl;
	else
		std::cout << "The contents of both sequences differ." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movaps 0x2865(%rip), %xmm0     # 0x27340
leaq -0xc(%rbp), %rdx
movaps %xmm0, -0x14(%rdx)
movl $0x64, -0x4(%rdx)
leaq -0x38(%rbp), %rbx
leaq -0x20(%rbp), %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x24c32
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rdi, %rdx
je 0x24b25
leaq -0x20(%rbp), %rsi
callq 0x2210
testl %eax, %eax
je 0x24b25
movl $0x26, %edx
leaq 0x285b(%rip), %rsi      # 0x2737e
jmp 0x24b31
movl $0x29, %edx
leaq 0x2823(%rip), %rsi      # 0x27354
movq 0xf498(%rip), %rbx      # 0x33fd0
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0xf472(%rip), %rdi      # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x38(%rbp), %rax
movl $0x51, 0xc(%rax)
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
sete %dl
je 0x24baa
movl (%rax), %esi
cmpl -0x20(%rbp), %esi
jne 0x24baa
addq $0x4, %rax
leaq -0x1c(%rbp), %rsi
cmpq %rcx, %rax
sete %dl
je 0x24baa
movl (%rax), %edi
addq $0x4, %rax
leaq 0x4(%rsi), %r8
cmpl (%rsi), %edi
movq %r8, %rsi
je 0x24b91
leaq 0x27a3(%rip), %rax      # 0x27354
leaq 0x27c6(%rip), %rsi      # 0x2737e
testb %dl, %dl
cmovneq %rax, %rsi
movzbl %dl, %eax
leaq (%rax,%rax,2), %rdx
addq $0x26, %rdx
movq 0xf400(%rip), %rbx      # 0x33fd0
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0xf3da(%rip), %rdi      # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x24c11
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x24c29
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_distance.cpp
// Function: test_distance()
void
test_distance()
{
	ft::vector<int> vec(5, 42);

	std::cout << vec.end() - vec.begin() << std::endl;
	std::cout <<
		ft::distance<ft::vector<int>::iterator>(vec.begin(), vec.end())
		<< std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x14, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x14, %rax
jne 0x24d0e
movq 0xf2aa(%rip), %rdi      # 0x33fd0
movl $0x5, %esi
callq 0x21c0
movq %rax, %r14
movq (%rax), %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 0xf26f(%rip), %rdi      # 0x33fd0
movl $0x5, %esi
callq 0x21c0
movq %rax, %r14
movq (%rax), %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
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
jmp 0x24da3
movq %rax, %r14
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_lexicographical_compare.cpp
// Function: test_lexicographical_compare()
void
test_lexicographical_compare()
{
    char foo[] = "Apple";
    char bar[] = "apartment";

    std::cout << std::boolalpha;

    std::cout << "Comparing foo and bar lexicographically (foo < bar):" << std::endl;

    std::cout << "Using default comparison (operator<): ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9);
    std::cout << std::endl;

    std::cout << "Using mycomp as comparison object: ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9, mycomp);
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xf1e0(%rip), %rbx      # 0x33fd0
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%rbx,%rax)
leaq 0x25b2(%rip), %rsi      # 0x273b5
movl $0x34, %edx
movq %rbx, %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
leaq 0x25ac(%rip), %rsi      # 0x273ea
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2230
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2320
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
leaq 0x258b(%rip), %rsi      # 0x27411
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2230
xorl %r12d, %r12d
leaq 0x250e(%rip), %r13      # 0x273ab
leaq 0x2501(%rip), %rbx      # 0x273a5
movsbl (%r12,%rbx), %edi
movsbl (%r12,%r13), %r14d
callq 0x2280
movl %eax, %r15d
movl %r14d, %edi
callq 0x2280
cmpl %eax, %r15d
setl %al
jl 0x24ed7
jg 0x24ed5
incq %r12
cmpq $0x5, %r12
jne 0x24ea4
movb $0x1, %al
jmp 0x24ed7
xorl %eax, %eax
movzbl %al, %esi
movq 0xf0ef(%rip), %rbx      # 0x33fd0
movq %rbx, %rdi
callq 0x2320
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/others/test_is_integral.cpp
// Function: void test_single_is_integral<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
test_single_is_integral(std::string const& type_tested)
{
	int value = ft::is_integral<T>::value;
	typedef typename ft::is_integral<T>::value_type value_type;
	typedef typename ft::is_integral<T>::type type;

	if (value
			&& typeid(value_type) == typeid(bool)
			&& typeid(type) == typeid(ft::true_type)
			&& ft::is_integral<T>() == value)
	{
		std::cout << type_tested << " is integral" << std::endl;
	}
	else
	{
		std::cout << type_tested << " is not integral" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0xe9aa(%rip), %rdi      # 0x33fd0
callq 0x2230
movq %rax, %rbx
leaq 0x1ee4(%rip), %rsi      # 0x27519
movl $0xc, %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
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/others/test_is_const.cpp
// Function: test_is_const()
void
test_is_const()
{
	std::cout << ft::is_const<int>::value << std::endl
		<< ft::is_const<int const>::value << std::endl
		<< ft::is_const<char>::value << std::endl
		<< ft::is_const<char const>::value << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xe43b(%rip), %rdi      # 0x33fd0
xorl %esi, %esi
callq 0x2320
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 %rax, %rdi
movl $0x1, %esi
callq 0x2320
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 %rax, %rdi
xorl %esi, %esi
callq 0x2320
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 %rax, %rdi
movl $0x1, %esi
callq 0x2320
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
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: section_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
section_wrapper(void f(), std::string section_name)
{
	std::cout << "====== test_" << section_name << " ======" << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xe349(%rip), %rbx      # 0x33fd0
leaq 0x18a9(%rip), %rsi      # 0x27537
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2230
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x1890(%rip), %rsi      # 0x27544
movl $0x7, %edx
movq %rax, %rdi
callq 0x2230
movq (%r15), %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
callq *%r14
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 %r14
popq %r15
popq %rbp
jmp 0x2150
movq %rax, %r14
cmpl $0x1, %edx
jne 0x25d5b
movq %r14, %rdi
callq 0x20c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0xe294(%rip), %rdi      # 0x33fd0
movq %rax, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x20d0
callq 0x2310
jmp 0x25ceb
movq %rax, %r14
callq 0x2310
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
callq 0x35f0
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: subsection_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
subsection_wrapper(void f(), std::string subsection_name)
{
	std::cout << "*** test_" << subsection_name << " ***" << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xe24e(%rip), %rbx      # 0x33fd0
leaq 0x17c3(%rip), %rsi      # 0x2754c
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2230
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x79f(%rip), %rsi       # 0x2654e
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movq (%r15), %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
callq *%r14
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 %r14
popq %r15
popq %rbp
jmp 0x2150
movq %rax, %r14
cmpl $0x1, %edx
jne 0x25e56
movq %r14, %rdi
callq 0x20c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0xe199(%rip), %rdi      # 0x33fd0
movq %rax, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x20d0
callq 0x2310
jmp 0x25de6
movq %rax, %r14
callq 0x2310
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
callq 0x35f0
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: test_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
test_wrapper(void f(), std::string test_name)
{
	std::cout << "# test_" << test_name << ": " << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xe153(%rip), %rbx      # 0x33fd0
leaq 0x16d2(%rip), %rsi      # 0x27556
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x1564(%rip), %rsi      # 0x2740e
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq (%r15), %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
callq *%r14
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 %r14
popq %r15
popq %rbp
jmp 0x2150
movq %rax, %r14
cmpl $0x1, %edx
jne 0x25f51
movq %r14, %rdi
callq 0x20c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0xe09e(%rip), %rdi      # 0x33fd0
movq %rax, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x20d0
callq 0x2310
jmp 0x25ee1
movq %rax, %r14
callq 0x2310
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
callq 0x35f0
// File: /workspace/github_cpp_makefile_star2_O1/ledbit[P]varint/leb128.cpp
// Function: leb128_encode(std::vector<unsigned long, std::allocator<unsigned long>> const&)
vector<uint8_t> leb128_encode(const vector<uint64_t> &in) {
  vector<uint8_t> out;
  for (auto x : in) {
    while (x > 127) {
      out.push_back(x | 0x80);
      x >>= 7;
    }
    out.push_back(x);
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x134e
leaq 0x7(%rsp), %r14
leaq 0x6(%rsp), %r15
movq (%r12), %rbp
cmpq $0x80, %rbp
jb 0x1333
movl %ebp, %eax
orb $-0x80, %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13c6
movq %rbp, %rax
shrq $0x7, %rax
cmpq $0x3fff, %rbp           # imm = 0x3FFF
movq %rax, %rbp
ja 0x130b
jmp 0x1336
movq %rbp, %rax
movb %al, 0x6(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13c6
addq $0x8, %r12
cmpq %r13, %r12
jne 0x12fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1362
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1379
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/ledbit[P]varint/leb128.cpp
// Function: leb128_decode(unsigned char const*, unsigned long*, unsigned long)
void leb128_decode(const uint8_t *in, uint64_t *out, size_t count) {
  while (count-- > 0) {
    uint8_t byte = *in++;
    if (LIKELY(byte < 128)) {
      *out++ = byte;
      continue;
    }
    uint64_t value = byte & 0x7f;
    unsigned shift = 7;
    do {
      byte = *in++;
      value |= uint64_t(byte & 0x7f) << shift;
      shift += 7;
    } while (byte >= 128);
    *out++ = value;
  }
}

// Assembly:
testq %rdx, %rdx
je 0x13c4
movsbq (%rdi), %rax
incq %rdi
testq %rax, %rax
js 0x139e
decq %rdx
movq %rax, (%rsi)
addq $0x8, %rsi
jmp 0x1381
andl $0x7f, %eax
movl $0x7, %ecx
movzbl (%rdi), %r8d
movl %r8d, %r9d
andl $0x7f, %r9d
shlq %cl, %r9
incq %rdi
orq %r9, %rax
addl $0x7, %ecx
testb %r8b, %r8b
js 0x13a6
jmp 0x1392
retq
nop