LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_clear_strings()
void
test_vector_modifiers_clear_strings()
{
	ft::vector<std::string> vec(100, "42");

	print_vec_info(vec);

	vec.clear();

	vec.push_back("test");
	vec.push_back("test");

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3370
movq -0xa8(%rbp), %rdx
leaq 0xe40e(%rip), %rsi      # 0x57a97
leaq -0x38(%rbp), %rdi
callq 0x3290
jmp 0x49694
leaq -0x4d(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x15360
movq -0xb0(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x64, %esi
leaq -0x38(%rbp), %rdx
callq 0x3c220
jmp 0x496bf
leaq -0x4d(%rbp), %rdi
callq 0x16ae0
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3230
leaq -0x18(%rbp), %rdi
callq 0x3c2a0
jmp 0x496e5
leaq -0x18(%rbp), %rdi
callq 0x4be20
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3370
movq -0xb8(%rbp), %rdx
leaq 0xda03(%rip), %rsi      # 0x5710f
leaq -0x70(%rbp), %rdi
callq 0x3290
jmp 0x49717
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4be40
jmp 0x49726
leaq -0x70(%rbp), %rdi
callq 0x3160
leaq -0x71(%rbp), %rdi
callq 0x3230
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3370
movq -0xc0(%rbp), %rdx
leaq 0xd9b6(%rip), %rsi      # 0x5710f
leaq -0x98(%rbp), %rdi
callq 0x3290
jmp 0x49767
leaq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4be40
jmp 0x49779
leaq -0x98(%rbp), %rdi
callq 0x3160
leaq -0x99(%rbp), %rdi
callq 0x3230
leaq -0x18(%rbp), %rdi
callq 0x3c2a0
jmp 0x4979c
leaq -0x18(%rbp), %rdi
callq 0x152b0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x497da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x16ae0
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3230
jmp 0x4985c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49816
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
leaq -0x71(%rbp), %rdi
callq 0x3230
jmp 0x49853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x49847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3160
leaq -0x99(%rbp), %rdi
callq 0x3230
leaq -0x18(%rbp), %rdi
callq 0x152b0
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_constructors_base()
void
test_vector_iterators_constructors_base()
{
	ft::vector<int> myvector;

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

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

	iter_type from(myvector.begin());
	iter_type cpy(from);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f231
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f20d
jmp 0x4f20f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f1f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f295
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3a930
testb $0x1, %al
jne 0x4f259
jmp 0x4f286
movq 0x2bd58(%rip), %rdi     # 0x7afb8
leaq 0x9276(%rip), %rsi      # 0x584dd
callq 0x31e0
movq %rax, -0x48(%rbp)
jmp 0x4f272
movq -0x48(%rbp), %rdi
movq 0x2bd1b(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f284
jmp 0x4f286
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_star()
void
test_vector_iterators_operator_star()
{
	ft::vector<int> myvector;

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

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

	iter_type from(myvector.begin());

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f2f1
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f2cd
jmp 0x4f2cf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f2b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f33c
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x38310
movl (%rax), %esi
movq 0x2bca8(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x40(%rbp)
jmp 0x4f31b
movq -0x40(%rbp), %rdi
movq 0x2bc72(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f32d
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_brackets()
void
test_vector_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;

	iter_type it = myvector.begin();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f3a1
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f37d
jmp 0x4f37f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f368
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f407
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
movq 0x2bc03(%rip), %rdi     # 0x7afb8
leaq 0x8db4(%rip), %rsi      # 0x58170
callq 0x31e0
movq %rax, -0x40(%rbp)
jmp 0x4f3c7
leaq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x50940
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x48(%rbp)
jmp 0x4f3e6
movq -0x48(%rbp), %rdi
movq 0x2bba7(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f3f8
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_iterators.cpp
// Function: test_vector_iterators_operator_plus()
void
test_vector_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;

	iter_type it = 3 + myvector.begin();

	std::cout << "The fourth element from the begin is: " << *it << std::endl;

	it = myvector.begin() + 3;

	std::cout << "The fourth element from the begin is: " << *it << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f464
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f43d
jmp 0x4f43f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f428
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f543
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x40(%rbp)
movl $0x3, %edi
leaq -0x40(%rbp), %rsi
callq 0x50960
movq %rax, -0x38(%rbp)
movq 0x2bb2e(%rip), %rdi     # 0x7afb8
leaq 0x8cdf(%rip), %rsi      # 0x58170
callq 0x31e0
movq %rax, -0x58(%rbp)
jmp 0x4f49c
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x60(%rbp)
jmp 0x4f4b6
movq -0x60(%rbp), %rdi
movq 0x2bad7(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f4c8
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x3, %esi
callq 0x3afe0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x2bac2(%rip), %rdi     # 0x7afb8
leaq 0x8c73(%rip), %rsi      # 0x58170
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x4f508
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x70(%rbp)
jmp 0x4f522
movq -0x70(%rbp), %rdi
movq 0x2ba6b(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f534
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0x80, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f5a7
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f580
jmp 0x4f582
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f56b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f69b
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x3, %esi
callq 0x382d0
movq %rax, -0x38(%rbp)
movq 0x2b9eb(%rip), %rdi     # 0x7afb8
leaq 0x8bc3(%rip), %rsi      # 0x58197
callq 0x31e0
movq %rax, -0x58(%rbp)
jmp 0x4f5df
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x60(%rbp)
jmp 0x4f5f9
movq -0x60(%rbp), %rdi
movq 0x2b994(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f60b
leaq -0x18(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x380c0
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x37f50
movq %rax, -0x50(%rbp)
movq 0x2b988(%rip), %rdi     # 0x7afb8
leaq 0x82f1(%rip), %rsi      # 0x57928
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x4f642
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38080
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x3390
movq %rax, -0x78(%rbp)
jmp 0x4f661
movq -0x78(%rbp), %rdi
leaq 0x807f(%rip), %rsi      # 0x576eb
callq 0x31e0
movq %rax, -0x80(%rbp)
jmp 0x4f677
movq -0x80(%rbp), %rdi
movq 0x2b916(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f689
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f704
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f6dd
jmp 0x4f6df
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f6c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f7a8
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x380c0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x37f50
movq %rax, -0x40(%rbp)
movq 0x2b88f(%rip), %rdi     # 0x7afb8
leaq 0x8206(%rip), %rsi      # 0x57936
callq 0x31e0
jmp 0x4f737
jmp 0x4f739
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4e150
testb $0x1, %al
jne 0x4f74c
jmp 0x4f784
movq 0x2b865(%rip), %rdi     # 0x7afb8
movl $0x20, %esi
callq 0x3250
movq %rax, -0x50(%rbp)
jmp 0x4f763
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
jmp 0x4f779
leaq -0x38(%rbp), %rdi
callq 0x3b020
jmp 0x4f739
movq 0x2b82d(%rip), %rdi     # 0x7afb8
movq 0x2b806(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f799
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f814
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f7ed
jmp 0x4f7ef
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f7d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f90c
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4e150
testb $0x1, %al
jne 0x4f849
jmp 0x4f887
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x4bba0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x38310
movl (%rax), %esi
movq 0x2b74e(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x4f875
movq -0x58(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x4f885
jmp 0x4f836
movq 0x2b72a(%rip), %rdi     # 0x7afb8
movq 0x2b703(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f89c
jmp 0x4f89e
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4e150
testb $0x1, %al
jne 0x4f8b1
jmp 0x4f8e8
leaq -0x48(%rbp), %rdi
callq 0x3afa0
movq %rax, %rdi
callq 0x38310
movl (%rax), %esi
movq 0x2b6ed(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x60(%rbp)
jmp 0x4f8d6
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x3250
jmp 0x4f8e6
jmp 0x4f89e
movq 0x2b6c9(%rip), %rdi     # 0x7afb8
movq 0x2b6a2(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f8fd
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4f971
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4f94d
jmp 0x4f94f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f938
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4f9e0
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x3b070
movq 0x2b625(%rip), %rdi     # 0x7afb8
leaq 0x881c(%rip), %rsi      # 0x581b6
callq 0x31e0
movq %rax, -0x40(%rbp)
jmp 0x4f9a5
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x48(%rbp)
jmp 0x4f9bf
movq -0x48(%rbp), %rdi
movq 0x2b5ce(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4f9d1
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4fa41
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x4fa1d
jmp 0x4fa1f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fa08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4fab0
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x3b040
movq 0x2b555(%rip), %rdi     # 0x7afb8
leaq 0x7efa(%rip), %rsi      # 0x57964
callq 0x31e0
movq %rax, -0x40(%rbp)
jmp 0x4fa75
leaq -0x38(%rbp), %rdi
callq 0x38310
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x48(%rbp)
jmp 0x4fa8f
movq -0x48(%rbp), %rdi
movq 0x2b4fe(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4faa1
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
leaq -0x30(%rbp), %rdi
callq 0x14d00
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3a930
testb $0x1, %al
jne 0x4fb07
jmp 0x4fb54
movq 0x2b4aa(%rip), %rdi     # 0x7afb8
leaq 0x75d8(%rip), %rsi      # 0x570ed
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x4fb20
movq -0x68(%rbp), %rdi
movq 0x2b46d(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4fb32
jmp 0x4fb54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4fbc6
leaq -0x30(%rbp), %rdi
callq 0x37710
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x37740
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x37d00
testb $0x1, %al
jne 0x4fb81
jmp 0x4fbae
movq 0x2b430(%rip), %rdi     # 0x7afb8
leaq 0x755e(%rip), %rsi      # 0x570ed
callq 0x31e0
movq %rax, -0x70(%rbp)
jmp 0x4fb9a
movq -0x70(%rbp), %rdi
movq 0x2b3f3(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4fbac
jmp 0x4fbae
leaq -0x30(%rbp), %rdi
callq 0x15250
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nop
// File: 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
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
leaq 0x2b620(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x4fc5d
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3ae40
jmp 0x4fc39
jmp 0x4fc3b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fbf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4fcdb
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4e150
testb $0x1, %al
jne 0x4fc8a
jmp 0x4fccc
leaq -0x38(%rbp), %rdi
callq 0x38310
movl (%rax), %esi
movq 0x2b31c(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x50(%rbp)
jmp 0x4fca7
movq -0x50(%rbp), %rdi
leaq 0x8638(%rip), %rsi      # 0x582ea
callq 0x31e0
jmp 0x4fcb9
jmp 0x4fcbb
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x4bba0
movq %rax, -0x48(%rbp)
jmp 0x4fc6a
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x60, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15410
movq -0x50(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x64, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x4fd24
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x37710
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x37740
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c470
testb $0x1, %al
jne 0x4fd5a
jmp 0x4fdca
leaq -0x38(%rbp), %rdi
callq 0x3b330
movl (%rax), %esi
movq 0x2b24c(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x4fd77
movq -0x58(%rbp), %rdi
leaq 0x8568(%rip), %rsi      # 0x582ea
callq 0x31e0
jmp 0x4fd89
jmp 0x4fd8b
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x3c4b0
movq %rax, -0x48(%rbp)
jmp 0x4fd3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x4fdd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4fdd9
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x70, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x15410
movq -0x68(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x4fe24
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x38310
movl $0x3, (%rax)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x3afe0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x38310
movl $0x4, (%rax)
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3b350
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x37f50
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3b390
testb $0x1, %al
jne 0x4fe9f
jmp 0x4ff0f
leaq -0x50(%rbp), %rdi
callq 0x3b330
movl (%rax), %esi
movq 0x2b107(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x70(%rbp)
jmp 0x4febc
movq -0x70(%rbp), %rdi
leaq 0x8423(%rip), %rsi      # 0x582ea
callq 0x31e0
jmp 0x4fece
jmp 0x4fed0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x3c4b0
movq %rax, -0x60(%rbp)
jmp 0x4fe7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x4ff1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x4ff1e
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x90, %rsp
movl $0x2a, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15410
movq -0x50(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x4ff67
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x380c0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x38310
movq -0x68(%rbp), %rdi
movl $0x3, (%rax)
movl $0x1, %esi
callq 0x3afe0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x38310
movq -0x68(%rbp), %rsi
movl $0x4, (%rax)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3b350
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x509b0
movzbl %al, %esi
movq 0x2afdf(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x58(%rbp)
jmp 0x4ffe4
movq -0x58(%rbp), %rdi
movq 0x2afa9(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x4fff6
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x509f0
movzbl %al, %esi
movq 0x2afab(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x70(%rbp)
jmp 0x50018
movq -0x70(%rbp), %rdi
movq 0x2af75(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x5002a
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x50a30
movzbl %al, %esi
movq 0x2af77(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x78(%rbp)
jmp 0x5004c
movq -0x78(%rbp), %rdi
movq 0x2af41(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x5005e
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x50a70
movzbl %al, %esi
movq 0x2af43(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x80(%rbp)
jmp 0x50080
movq -0x80(%rbp), %rdi
movq 0x2af0d(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50092
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x50ab0
movzbl %al, %esi
movq 0x2af0f(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x88(%rbp)
jmp 0x500b7
movq -0x88(%rbp), %rdi
movq 0x2aed3(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x500cc
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x50af0
movzbl %al, %esi
movq 0x2aed5(%rip), %rdi     # 0x7afb8
callq 0x3380
movq %rax, -0x90(%rbp)
jmp 0x500f1
movq -0x90(%rbp), %rdi
movq 0x2ae99(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50106
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x50144
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: 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
subq $0x50, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x50b84
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x50b5d
jmp 0x50b5f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50b48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x50c21
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x50b8f
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x4bde0
movl (%rax), %esi
movq 0x2a412(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x38(%rbp)
jmp 0x50bb1
movq -0x38(%rbp), %rdi
movq 0x2a3dc(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50bc3
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x2, %esi
movq %rsi, -0x48(%rbp)
callq 0x4bde0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x2a, (%rax)
callq 0x4bde0
movl (%rax), %esi
movq 0x2a3c3(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x40(%rbp)
jmp 0x50c00
movq -0x40(%rbp), %rdi
movq 0x2a38d(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50c12
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x14d00
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x50dd4
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x35610
jmp 0x50dad
jmp 0x50daf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50d98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
jmp 0x50e88
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x50ddf
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x51910
movq %rax, -0x38(%rbp)
jmp 0x50df3
movq -0x38(%rbp), %rax
movl (%rax), %esi
movq 0x2a1b8(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x40(%rbp)
jmp 0x50e0b
movq -0x40(%rbp), %rdi
movq 0x2a182(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50e1d
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x51910
movq %rax, -0x48(%rbp)
jmp 0x50e31
movq -0x48(%rbp), %rax
movl $0x2a, (%rax)
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x51910
movq %rax, -0x50(%rbp)
jmp 0x50e4f
movq -0x50(%rbp), %rax
movl (%rax), %esi
movq 0x2a15c(%rip), %rdi     # 0x7afb8
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x50e67
movq -0x58(%rbp), %rdi
movq 0x2a126(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x50e79
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
subq $0x40, %rsp
movl $0xa, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x15410
movq -0x38(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0xa, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x51074
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x51088
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x51990
movq -0x40(%rbp), %rdi
movl $0x2a, (%rax)
callq 0x3c0a0
jmp 0x510a6
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x510e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movl $0xa, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x15410
movq -0x38(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0xa, %esi
leaq -0x1c(%rbp), %rdx
callq 0x35420
jmp 0x51124
leaq -0x1d(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x51138
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x38290
movq -0x40(%rbp), %rdi
movl $0x2a, (%rax)
callq 0x3c0a0
jmp 0x51156
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x48e0
jmp 0x51191
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x14d00
movq -0x38(%rbp), %rdi
movl $0x4e, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x3ae40
jmp 0x511cb
movl $0x10, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3ae40
jmp 0x511e1
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x38290
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
callq 0x51990
movl -0x44(%rbp), %edx
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq 0x29dac(%rip), %rdi     # 0x7afb8
leaq 0x6fc9(%rip), %rsi      # 0x581dc
callq 0x31e0
movq %rax, -0x40(%rbp)
jmp 0x5121e
leaq -0x18(%rbp), %rdi
callq 0x51990
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x58(%rbp)
jmp 0x51238
movq -0x58(%rbp), %rdi
movq 0x29d55(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x5124a
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x15410
movq -0x40(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
callq 0x519c0
jmp 0x512a9
leaq -0x19(%rbp), %rdi
callq 0x48e0
leaq -0x18(%rbp), %rdi
callq 0x3c0a0
jmp 0x512bd
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x51a30
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xa, (%rax)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x14, (%rax)
movq -0x38(%rbp), %rax
movl $0x64, 0x8(%rax)
callq 0x3c0a0
jmp 0x51304
leaq -0x18(%rbp), %rdi
callq 0x15250
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x48e0
jmp 0x5133f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15250
movq -0x28(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq 0x6721(%rip), %rax      # 0x58250
movq %rax, -0x20(%rbp)
movq 0x671e(%rip), %rax      # 0x58258
movq %rax, -0x18(%rbp)
movl 0x671c(%rip), %eax      # 0x58260
movl %eax, -0x10(%rbp)
movq 0x6716(%rip), %rax      # 0x58264
movq %rax, -0x2c(%rbp)
movl 0x6714(%rip), %eax      # 0x5826c
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
addq $0x14, %rsi
callq 0x51bd0
leaq -0x2c(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
addq $0xc, %rsi
callq 0x51bd0
leaq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
addq $0x14, %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
addq $0xc, %rcx
callq 0x51c10
testb $0x1, %al
jne 0x51ba0
jmp 0x51bc2
movq 0x29411(%rip), %rdi     # 0x7afb8
leaq 0x66c2(%rip), %rsi      # 0x58270
callq 0x31e0
movq %rax, %rdi
movq 0x293db(%rip), %rsi     # 0x7af98
callq 0x3220
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_assignement_overload()
void
test_pair_assignement_overload()
{
	ft::pair<std::string, int> planet, homeplanet;

	planet.first = "Earth";
	planet.second = 6371;

	std::cout << "Planet: " << planet.first << std::endl;
	std::cout << "Planet size: " << planet.second << std::endl;

	homeplanet = planet;

	std::cout << "Home planet: " << homeplanet.first << std::endl;
	std::cout << "Home planet size: " << homeplanet.second << std::endl;

	{
		ft::pair<std::string, int> cpy1 = planet;
		ft::pair<std::string, int> cpy2 = homeplanet;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x28(%rbp), %rdi
callq 0x53350
leaq -0x50(%rbp), %rdi
callq 0x53350
jmp 0x52b3f
leaq 0x575f(%rip), %rsi      # 0x582a5
leaq -0x28(%rbp), %rdi
callq 0x3280
jmp 0x52b51
movl $0x18e3, -0x8(%rbp)     # imm = 0x18E3
movq 0x28459(%rip), %rdi     # 0x7afb8
leaq 0x5745(%rip), %rsi      # 0x582ab
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x52b74
movq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31b0
movq %rax, -0xc0(%rbp)
jmp 0x52b8d
movq -0xc0(%rbp), %rdi
movq 0x283fd(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x52ba2
movq 0x2840f(%rip), %rdi     # 0x7afb8
leaq 0x5704(%rip), %rsi      # 0x582b4
callq 0x31e0
movq %rax, -0xc8(%rbp)
jmp 0x52bbe
movq -0xc8(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x3350
movq %rax, -0xd0(%rbp)
jmp 0x52bd6
movq -0xd0(%rbp), %rdi
movq 0x283b4(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x52beb
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53380
jmp 0x52bfa
movq 0x283b7(%rip), %rdi     # 0x7afb8
leaq 0x56ba(%rip), %rsi      # 0x582c2
callq 0x31e0
movq %rax, -0xd8(%rbp)
jmp 0x52c16
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x31b0
movq %rax, -0xe0(%rbp)
jmp 0x52c2f
movq -0xe0(%rbp), %rdi
movq 0x2835b(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x52c44
movq 0x2836d(%rip), %rdi     # 0x7afb8
leaq 0x567e(%rip), %rsi      # 0x582d0
callq 0x31e0
movq %rax, -0xe8(%rbp)
jmp 0x52c60
movq -0xe8(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x3350
movq %rax, -0xf0(%rbp)
jmp 0x52c78
movq -0xf0(%rbp), %rdi
movq 0x28312(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x52c8d
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x533c0
jmp 0x52c9f
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x533c0
jmp 0x52cb1
leaq -0xb0(%rbp), %rdi
callq 0x53400
leaq -0x88(%rbp), %rdi
callq 0x53400
leaq -0x50(%rbp), %rdi
callq 0x53400
leaq -0x28(%rbp), %rdi
callq 0x53400
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x52d21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x52d18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x53400
leaq -0x50(%rbp), %rdi
callq 0x53400
leaq -0x28(%rbp), %rdi
callq 0x53400
movq -0x58(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl $0xa, -0xc(%rbp)
movb $0x7a, -0xd(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0xd(%rbp), %rdx
callq 0x22aa0
movl $0x5a, -0x1c(%rbp)
movb $0x61, -0x1d(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x1d(%rbp), %rdx
callq 0x22aa0
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53420
testb $0x1, %al
jne 0x52d93
jmp 0x52db5
movq 0x2821e(%rip), %rdi     # 0x7afb8
leaq 0x46a1(%rip), %rsi      # 0x57442
callq 0x31e0
movq %rax, %rdi
movq 0x281e8(%rip), %rsi     # 0x7af98
callq 0x3220
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53460
testb $0x1, %al
jne 0x52dc8
jmp 0x52dea
movq 0x281e9(%rip), %rdi     # 0x7afb8
leaq 0x4682(%rip), %rsi      # 0x57458
callq 0x31e0
movq %rax, %rdi
movq 0x281b3(%rip), %rsi     # 0x7af98
callq 0x3220
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53490
testb $0x1, %al
jne 0x52dfd
jmp 0x52e1f
movq 0x281b4(%rip), %rdi     # 0x7afb8
leaq 0x4667(%rip), %rsi      # 0x57472
callq 0x31e0
movq %rax, %rdi
movq 0x2817e(%rip), %rsi     # 0x7af98
callq 0x3220
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x534f0
testb $0x1, %al
jne 0x52e32
jmp 0x52e54
movq 0x2817f(%rip), %rdi     # 0x7afb8
leaq 0x4647(%rip), %rsi      # 0x57487
callq 0x31e0
movq %rax, %rdi
movq 0x28149(%rip), %rsi     # 0x7af98
callq 0x3220
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53520
testb $0x1, %al
jne 0x52e67
jmp 0x52e89
movq 0x2814a(%rip), %rdi     # 0x7afb8
leaq 0x462a(%rip), %rsi      # 0x5749f
callq 0x31e0
movq %rax, %rdi
movq 0x28114(%rip), %rsi     # 0x7af98
callq 0x3220
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53550
testb $0x1, %al
jne 0x52e9c
jmp 0x52ebe
movq 0x28115(%rip), %rdi     # 0x7afb8
leaq 0x4616(%rip), %rsi      # 0x574c0
callq 0x31e0
movq %rax, %rdi
movq 0x280df(%rip), %rsi     # 0x7af98
callq 0x3220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
leaq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x53580
leaq -0x10(%rbp), %rdi
callq 0x53580
movl $0xa, -0x1c(%rbp)
movl $0x14, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14f50
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x535a0
movabsq $0x4025000000000000, %rax # imm = 0x4025000000000000
movq %rax, -0x38(%rbp)
movb $0x41, -0x39(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x39(%rbp), %rsi
callq 0x535d0
movb %al, -0x48(%rbp)
movsd %xmm0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x48(%rbp), %al
movb %al, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x53600
movq 0x28055(%rip), %rdi     # 0x7afb8
leaq 0x5379(%rip), %rsi      # 0x582e3
callq 0x31e0
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x3350
movq %rax, %rdi
leaq 0x5365(%rip), %rsi      # 0x582e9
callq 0x31e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3350
movq %rax, %rdi
movq 0x27ffa(%rip), %rsi     # 0x7af98
callq 0x3220
movq 0x2800e(%rip), %rdi     # 0x7afb8
leaq 0x533b(%rip), %rsi      # 0x582ec
callq 0x31e0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3350
movq %rax, %rdi
leaq 0x531e(%rip), %rsi      # 0x582e9
callq 0x31e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3350
movq %rax, %rdi
movq 0x27fb3(%rip), %rsi     # 0x7af98
callq 0x3220
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x70, %rsp
popq %rbp
retq
// File: 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
subq $0xd0, %rsp
leaq -0x21(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3370
movq -0xb8(%rbp), %rdx
leaq 0x482f(%rip), %rsi      # 0x57858
leaq -0x20(%rbp), %rdi
callq 0x3290
jmp 0x53034
leaq -0x81b(%rip), %rdi      # 0x52820
leaq -0x20(%rbp), %rsi
callq 0x56430
jmp 0x53046
leaq -0x20(%rbp), %rdi
callq 0x3160
leaq -0x21(%rbp), %rdi
callq 0x3230
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3370
movq -0xc0(%rbp), %rdx
leaq 0x527c(%rip), %rsi      # 0x582f2
leaq -0x58(%rbp), %rdi
callq 0x3290
jmp 0x53081
leaq -0x568(%rip), %rdi      # 0x52b20
leaq -0x58(%rbp), %rsi
callq 0x56430
jmp 0x53093
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3230
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3370
movq -0xc8(%rbp), %rdx
leaq 0x5241(%rip), %rsi      # 0x58307
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x530d1
leaq -0x398(%rip), %rdi      # 0x52d40
leaq -0x80(%rbp), %rsi
callq 0x56430
jmp 0x530e3
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x3230
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3370
movq -0xd0(%rbp), %rdx
leaq 0x534a(%rip), %rsi      # 0x58463
leaq -0xa8(%rbp), %rdi
callq 0x3290
jmp 0x53127
leaq -0x25e(%rip), %rdi      # 0x52ed0
leaq -0xa8(%rbp), %rsi
callq 0x56430
jmp 0x5313c
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0xa9(%rbp), %rdi
callq 0x3230
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x53180
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3160
leaq -0x21(%rbp), %rdi
callq 0x3230
jmp 0x5321f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x531b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3230
jmp 0x5321f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x531df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x3230
jmp 0x5321f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x53213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0xa9(%rbp), %rdi
callq 0x3230
movq -0x30(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)