LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_range_begin_wo_realloc()
void
test_vector_modifiers_insert_range_begin_wo_realloc()
{
	ft::vector<int> vec_random;

	srand(g_seed);

	for (int i = 0; i < 50; i++)
		vec_random.push_back(rand() % 100 - 100 / 2);

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

	vec.reserve(100);

	print_vec_info(vec);
	vec.insert(vec.begin(), vec_random.begin(), vec_random.end());
	print_vec_info(vec);

	ft::vector<int> empty;

	vec.reserve(50);

	print_vec_info(empty);
	empty.insert(empty.begin(), vec_random.begin(), vec_random.end());
	print_vec_info(empty);

	{
		ft::vector<int> cpy1 = vec;
		ft::vector<int> cpy2 = empty;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
leaq -0x70(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x177a5(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x32
popq %r15
pushq $0x64
popq %r12
leaq -0x38(%rbp), %r14
subl $0x1, %r15d
jb 0x1aa68
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x38(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1aa46
leaq -0x50(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rdi
pushq $0x32
popq %rsi
leaq -0x88(%rbp), %rcx
callq 0x1465a
leaq -0x38(%rbp), %rdi
pushq $0x64
popq %rsi
callq 0x175aa
leaq -0x38(%rbp), %rdi
callq 0x16817
leaq -0x38(%rbp), %rdi
movq (%rdi), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x1cc60
leaq -0x38(%rbp), %rdi
callq 0x16817
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
pushq $0x32
popq %rsi
callq 0x175aa
leaq -0x50(%rbp), %rdi
callq 0x16817
leaq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x1cc60
leaq -0x50(%rbp), %rdi
callq 0x16817
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14fea
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14fea
leaq -0xa0(%rbp), %rdi
callq 0xa746
leaq -0x88(%rbp), %rdi
callq 0xa746
leaq -0x50(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
leaq -0x70(%rbp), %rdi
callq 0xa746
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xa746
jmp 0x1ab74
jmp 0x1ab71
jmp 0x1ab71
jmp 0x1ab7f
jmp 0x1ab8d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa746
jmp 0x1ab82
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
jmp 0x1ab90
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_range_middle_w_realloc()
void
test_vector_modifiers_insert_range_middle_w_realloc()
{
	ft::vector<int> vec_random;

	srand(g_seed);

	for (int i = 0; i < 50; i++)
		vec_random.push_back(rand() % 100 - 100 / 2);

	ft::vector<int> vec;
	for (int i = 1; i <= 50; i++)
		vec.push_back(i);

	print_vec_info(vec);
	vec.insert(vec.begin() + 25, vec_random.begin(), vec_random.end());
	print_vec_info(vec);

	{
		ft::vector<int> cpy1 = vec;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x60(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x17612(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x32
popq %r15
pushq $0x64
popq %r12
leaq -0x40(%rbp), %r14
subl $0x1, %r15d
jb 0x1abfb
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1abd9
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x1
popq %rax
leaq -0x78(%rbp), %r14
movl %eax, -0x78(%rbp)
cmpl $0x33, %eax
jge 0x1ac2b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x78(%rbp), %eax
incl %eax
jmp 0x1ac11
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x40(%rbp), %rdi
movq (%rdi), %rsi
addq $0x64, %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x1cc60
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
leaq -0x78(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
leaq -0x60(%rbp), %rdi
callq 0xa746
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ac90
jmp 0x1ac90
jmp 0x1ac90
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
jmp 0x1aca1
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_range_middle_wo_realloc()
void
test_vector_modifiers_insert_range_middle_wo_realloc()
{
	ft::vector<int> vec_random;

	srand(g_seed);

	for (int i = 0; i < 50; i++)
		vec_random.push_back(rand() % 100 - 100 / 2);

	ft::vector<int> vec;
	for (int i = 1; i <= 50; i++)
		vec.push_back(i);

	vec.reserve(100);

	print_vec_info(vec);
	vec.insert(vec.begin() + 25, vec_random.begin(), vec_random.end());
	print_vec_info(vec);

	{
		ft::vector<int> cpy1 = vec;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x60(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x17501(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x32
popq %r15
pushq $0x64
popq %r12
leaq -0x40(%rbp), %r14
subl $0x1, %r15d
jb 0x1ad0c
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1acea
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x1
popq %rax
leaq -0x78(%rbp), %r14
movl %eax, -0x78(%rbp)
cmpl $0x33, %eax
jge 0x1ad3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x78(%rbp), %eax
incl %eax
jmp 0x1ad22
leaq -0x40(%rbp), %rdi
pushq $0x64
popq %rsi
callq 0x175aa
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x40(%rbp), %rdi
movq (%rdi), %rsi
addq $0x64, %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x1cc60
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
leaq -0x78(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
leaq -0x60(%rbp), %rdi
callq 0xa746
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1adad
jmp 0x1adad
jmp 0x1adad
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
jmp 0x1adbe
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_range_end_w_realloc()
void
test_vector_modifiers_insert_range_end_w_realloc()
{
	ft::vector<int> vec_random;

	srand(g_seed);

	for (int i = 0; i < 50; i++)
		vec_random.push_back(rand() % 100 - 100 / 2);

	ft::vector<int> vec;
	for (int i = 1; i <= 50; i++)
		vec.push_back(i);

	print_vec_info(vec);
	vec.insert(vec.end(), vec_random.begin(), vec_random.end());
	print_vec_info(vec);

	{
		ft::vector<int> cpy1 = vec;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x60(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x173e4(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x32
popq %r15
pushq $0x64
popq %r12
leaq -0x40(%rbp), %r14
subl $0x1, %r15d
jb 0x1ae29
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1ae07
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x1
popq %rax
leaq -0x78(%rbp), %r14
movl %eax, -0x78(%rbp)
cmpl $0x33, %eax
jge 0x1ae59
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x78(%rbp), %eax
incl %eax
jmp 0x1ae3f
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x1cc60
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
leaq -0x78(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
leaq -0x60(%rbp), %rdi
callq 0xa746
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aebb
jmp 0x1aebb
jmp 0x1aebb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
jmp 0x1aecc
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_range_end_wo_realloc()
void
test_vector_modifiers_insert_range_end_wo_realloc()
{
	ft::vector<int> vec_random;

	srand(g_seed);

	for (int i = 0; i < 50; i++)
		vec_random.push_back(rand() % 100 - 100 / 2);

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

	vec.reserve(100);

	print_vec_info(vec);
	vec.insert(vec.end(), vec_random.begin(), vec_random.end());
	print_vec_info(vec);

	{
		ft::vector<int> cpy1 = vec;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x60(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x172d6(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x32
popq %r15
pushq $0x64
popq %r12
leaq -0x40(%rbp), %r14
subl $0x1, %r15d
jb 0x1af37
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1af15
leaq -0x78(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x40(%rbp), %rdi
pushq $0x32
popq %rsi
leaq -0x21(%rbp), %rcx
callq 0x1465a
leaq -0x40(%rbp), %rdi
pushq $0x64
popq %rsi
callq 0x175aa
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x1cc60
leaq -0x40(%rbp), %rdi
callq 0x16817
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
leaq -0x78(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
leaq -0x60(%rbp), %rdi
callq 0xa746
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1afbf
jmp 0x1afbf
jmp 0x1afcd
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
jmp 0x1afd0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_insert_cplusplus()
void
test_vector_modifiers_insert_cplusplus()
{
	ft::vector<int> myvector(3, 100);
	ft::vector<int>::iterator it;

	it = myvector.begin();
	it = myvector.insert(it, 200);

	myvector.insert(it, 2, 300);

	// "it" no longer valid, get a new one:
	it = myvector.begin();

	ft::vector<int> anothervector(2, 400);
	myvector.insert(it + 2, anothervector.begin(), anothervector.end());

	int myarray[] = {501, 502, 503};
	myvector.insert(myvector.begin(), myarray, myarray + 3);

	std::cout << "myvector contains:";
	for (it = myvector.begin(); it < myvector.end(); it++)
		std::cout << ' ' << *it;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq -0x60(%rbp), %rbx
movl $0x64, (%rbx)
leaq -0x38(%rbp), %r14
pushq $0x3
popq %rsi
leaq -0x48(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1465a
movq (%r14), %rsi
movl $0xc8, (%rbx)
leaq -0x60(%rbp), %rdx
movq %r14, %rdi
callq 0x1d612
leaq -0x60(%rbp), %rcx
movl $0x12c, (%rcx)          # imm = 0x12C
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rdx
movq %rax, %rsi
callq 0x1cc40
movq -0x38(%rbp), %rbx
leaq -0x48(%rbp), %rdx
movl $0x190, (%rdx)          # imm = 0x190
leaq -0x60(%rbp), %rdi
pushq $0x2
popq %rsi
leaq -0x19(%rbp), %rcx
callq 0x1465a
addq $0x8, %rbx
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x1cc60
movabsq $0x1f6000001f5, %rax    # imm = 0x1F6000001F5
leaq -0x3c(%rbp), %rcx
movq %rax, -0xc(%rcx)
movl $0x1f7, -0x4(%rcx)      # imm = 0x1F7
leaq -0x38(%rbp), %rdi
movq (%rdi), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1cc80
movq 0x16f16(%rip), %rdi     # 0x31fb8
leaq 0x6bd5(%rip), %rsi      # 0x21c7e
callq 0x31d0
movq -0x38(%rbp), %r15
movq 0x16eff(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
cmpq -0x30(%rbp), %r15
jae 0x1b0df
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl (%r15), %esi
movq %rax, %rdi
callq 0x3320
addq $0x4, %r15
jmp 0x1b0bd
movq 0x16ed2(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b117
jmp 0x1b117
jmp 0x1b110
jmp 0x1b110
movq %rax, %rbx
jmp 0x1b123
jmp 0x1b117
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_single_begin()
void
test_vector_modifiers_erase_single_begin()
{
	srand(g_seed);

	ft::vector<int> vec;
	ft::vector<int>::iterator it;

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

	print_vec_info(vec);
	it = vec.erase(vec.begin());
	print_vec_info(vec);

	if (it == vec.begin())
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x1708e(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
movaps %xmm0, (%rbx)
pushq $0x64
popq %r15
leaq -0x24(%rbp), %r14
movl %r15d, %r12d
subl $0x1, %r12d
jb 0x1b18d
callq 0x3070
cltd
idivl %r15d
addl $-0x32, %edx
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1b16b
leaq -0x40(%rbp), %rdi
callq 0x16817
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rdx
leaq 0x4(%rbx), %rsi
cmpq %rdx, %rsi
je 0x1b1b6
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x32f0
movq -0x38(%rbp), %rdx
addq $-0x4, %rdx
leaq -0x40(%rbp), %rdi
movq %rdx, 0x8(%rdi)
callq 0x16817
cmpq -0x40(%rbp), %rbx
jne 0x1b1e8
movq 0x16de4(%rip), %rdi     # 0x31fb8
leaq 0x7302(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b200
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_single_end()
void
test_vector_modifiers_erase_single_end()
{
	srand(g_seed);

	ft::vector<int> vec;
	ft::vector<int>::iterator it;

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

	print_vec_info(vec);
	it = vec.erase(vec.end() - 1);
	print_vec_info(vec);

	if (it == vec.end())
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x16ec8(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
movaps %xmm0, (%rbx)
pushq $0x64
popq %r15
leaq -0x24(%rbp), %r14
movl %r15d, %r12d
subl $0x1, %r12d
jb 0x1b353
callq 0x3070
cltd
idivl %r15d
addl $-0x32, %edx
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1b331
leaq -0x40(%rbp), %rdi
callq 0x16817
movq -0x38(%rbp), %rsi
leaq -0x4(%rsi), %rbx
movb $0x1, %al
testb %al, %al
jne 0x1b37c
movq %rsi, %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x32f0
movq -0x38(%rbp), %rsi
addq $-0x4, %rsi
leaq -0x40(%rbp), %rdi
movq %rsi, 0x8(%rdi)
callq 0x16817
cmpq -0x38(%rbp), %rbx
jne 0x1b3ae
movq 0x16c1e(%rip), %rdi     # 0x31fb8
leaq 0x713c(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b3c6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_single_string()
void
test_vector_modifiers_erase_single_string()
{
	ft::vector<std::string> vec(100, "42");
	ft::vector<std::string>::iterator it;


	print_vec_info(vec);
	it = vec.erase(vec.begin() + 50);
	print_vec_info(vec);

	if (it == vec.begin() + 50)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x669f(%rip), %rsi      # 0x21a89
leaq -0x48(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0x30a0
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0x28(%rbp), %rdi
callq 0x1694c
movl $0x640, %esi            # imm = 0x640
leaq -0x28(%rbp), %rdi
addq (%rdi), %rsi
callq 0x1cca0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1694c
movl $0x640, %eax            # imm = 0x640
addq -0x28(%rbp), %rax
cmpq %rax, %rbx
jne 0x1b463
movq 0x16b69(%rip), %rdi     # 0x31fb8
leaq 0x7087(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa3b8
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1b488
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x1b494
movq %rax, %rbx
jmp 0x1b494
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_range_end()
void
test_vector_modifiers_erase_range_end()
{
	srand(g_seed);

	ft::vector<int> vec;
	ft::vector<int>::iterator it;

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

	print_vec_info(vec);
	it = vec.erase(vec.begin() + 50, vec.end());
	print_vec_info(vec);

	if (it == vec.end())
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x16b7b(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
movaps %xmm0, (%rbx)
pushq $0x64
popq %r15
leaq -0x24(%rbp), %r14
movl %r15d, %r12d
subl $0x1, %r12d
jb 0x1b6a0
callq 0x3070
cltd
idivl %r15d
addl $-0x32, %edx
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1b67e
leaq -0x40(%rbp), %rdi
callq 0x16817
movl $0xc8, %esi
leaq -0x40(%rbp), %rdi
addq (%rdi), %rsi
movq 0x8(%rdi), %rdx
callq 0x1ccaa
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x16817
cmpq -0x38(%rbp), %rbx
jne 0x1b6eb
movq 0x168e1(%rip), %rdi     # 0x31fb8
leaq 0x6dff(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b705
jmp 0x1b705
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_range_string()
void
test_vector_modifiers_erase_range_string()
{
	ft::vector<std::string> vec(100, "42");
	ft::vector<std::string>::iterator it;

	print_vec_info(vec);
	it = vec.erase(vec.begin() + 25, vec.begin() + 75);
	print_vec_info(vec);

	if (it == vec.begin() + 25)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x6360(%rip), %rsi      # 0x21a89
leaq -0x48(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0x30a0
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0x28(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
movq (%rdi), %rdx
leaq 0x320(%rdx), %rsi
addq $0x960, %rdx            # imm = 0x960
callq 0x1ccb4
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1694c
movl $0x320, %eax            # imm = 0x320
addq -0x28(%rbp), %rax
cmpq %rax, %rbx
jne 0x1b7ab
movq 0x16821(%rip), %rdi     # 0x31fb8
leaq 0x6d3f(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa3b8
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1b7d0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x1b7dc
movq %rax, %rbx
jmp 0x1b7dc
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_erase_cplusplus()
void
test_vector_modifiers_erase_cplusplus()
{
	ft::vector<int> myvector;

	// set some values (from 1 to 10)
	for (int i = 1; i <= 10; i++)
		myvector.push_back(i);

	// erase the 6th element
	myvector.erase(myvector.begin() + 5);

	// erase the first 3 elements:
	myvector.erase(myvector.begin(), myvector.begin() + 3);

	std::cout << "myvector contains:";
	for (unsigned i = 0; i < myvector.size(); ++i)
		std::cout << ' ' << myvector[i];
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x1
popq %rax
leaq -0x1c(%rbp), %r14
movl %eax, -0x1c(%rbp)
cmpl $0xb, %eax
jge 0x1b821
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x1c(%rbp), %eax
incl %eax
jmp 0x1b807
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
leaq 0x18(%rbx), %rsi
cmpq %r14, %rsi
je 0x1b841
leaq 0x14(%rbx), %rdi
movq %r14, %rdx
subq %rsi, %rdx
callq 0x32f0
addq $-0x4, %r14
leaq -0x40(%rbp), %rdi
movq %r14, 0x8(%rdi)
leaq 0xc(%rbx), %rdx
movq %rbx, %rsi
callq 0x1ccaa
movq 0x16758(%rip), %rdi     # 0x31fb8
leaq 0x6417(%rip), %rsi      # 0x21c7e
callq 0x31d0
xorl %r15d, %r15d
movq 0x16742(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
movl %r15d, %r15d
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
sarq $0x2, %rax
cmpq %r15, %rax
jbe 0x1b8ae
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movq -0x40(%rbp), %rcx
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x3320
incl %r15d
jmp 0x1b87a
movq 0x16703(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b8d4
jmp 0x1b8d4
jmp 0x1b8d4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_swap_strings()
void
test_vector_modifiers_swap_strings()
{
	ft::vector<std::string> v1(5, "42"), v2(100, "-42");

	print_vec_info(v1);
	print_vec_info(v2);

	v1.swap(v2);

	print_vec_info(v1);
	print_vec_info(v2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0x60d4(%rip), %rsi      # 0x21a89
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq 0x60a2(%rip), %rsi      # 0x21a88
leaq -0x48(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x28(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x48(%rbp), %rdx
leaq -0xa(%rbp), %rcx
callq 0x168ec
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0x60(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0x1694c
leaq -0x60(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x28(%rbp)
movq %rax, -0x18(%rbp)
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0x1694c
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x60(%rbp), %rdi
callq 0xa3b8
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x1ba9d
movq %rax, %rbx
jmp 0x1ba9d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30d0
jmp 0x1baa6
movq %rax, %rbx
jmp 0x1baa6
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa3b8
leaq -0x60(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_swap_iterator_validity()
void
test_vector_modifiers_swap_iterator_validity()
{
	ft::vector<int> v1(5, 42), v2(100, -42);

	ft::vector<int>::iterator it_v1, it_v2;

	print_vec_info(v1);
	print_vec_info(v2);

	it_v1 = v1.begin();
	it_v2 = v2.begin();

	std::cout << *it_v1 << std::endl;
	std::cout << *it_v2 << std::endl;

	v1.swap(v2);

	print_vec_info(v1);
	print_vec_info(v2);

	std::cout << *it_v1 << std::endl;
	std::cout << *it_v2 << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x30(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x48(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x18(%rbp), %rbx
movq %rbx, %rcx
callq 0x1465a
movl $0xffffffd6, (%rbx)     # imm = 0xFFFFFFD6
leaq -0x30(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x18(%rbp), %rdx
leaq -0x11(%rbp), %rcx
callq 0x1465a
leaq -0x48(%rbp), %rdi
callq 0x16817
leaq -0x30(%rbp), %rdi
callq 0x16817
movq -0x48(%rbp), %r14
movq -0x30(%rbp), %rbx
movl (%r14), %esi
movq 0x164a4(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movl (%rbx), %esi
movq 0x1648e(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x30(%rbp)
movq %rax, -0x20(%rbp)
callq 0x16817
leaq -0x30(%rbp), %rdi
callq 0x16817
movl (%r14), %esi
movq 0x16447(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movl (%rbx), %esi
movq 0x16431(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
leaq -0x48(%rbp), %rdi
callq 0xa746
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x1bbc0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
leaq -0x48(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_modifiers.cpp
// Function: test_vector_modifiers_clear_ints()
void
test_vector_modifiers_clear_ints()
{
	ft::vector<int> vec(100, 42);

	print_vec_info(vec);

	vec.clear();

	vec.push_back(1101);
	vec.push_back(2202);

	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x64
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
movq -0x28(%rbp), %rax
cmpq %rax, -0x20(%rbp)
je 0x1bc0d
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x44d, (%rsi)          # imm = 0x44D
leaq -0x28(%rbp), %rdi
callq 0x160d0
leaq -0x10(%rbp), %rsi
movl $0x89a, (%rsi)          # imm = 0x89A
leaq -0x28(%rbp), %rdi
callq 0x160d0
leaq -0x28(%rbp), %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1bc50
jmp 0x1bc50
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
pushq %rbx
subq $0x48, %rsp
leaq 0x5e15(%rip), %rsi      # 0x21a89
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x30(%rbp), %rdx
leaq -0xa(%rbp), %rcx
callq 0x168ec
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq -0x48(%rbp), %rdi
callq 0x1ccbe
leaq 0x5458(%rip), %rsi      # 0x2110f
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d998
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq 0x542e(%rip), %rsi      # 0x2110f
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d998
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x1694c
leaq -0x48(%rbp), %rdi
callq 0xa3b8
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1bd21
jmp 0x1bd44
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x1bd47
jmp 0x1bd44
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x1bd50
movq %rax, %rbx
jmp 0x1bd50
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa3b8
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0x9, %eax
jg 0x1da0e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1d9f4
movq 0x145a3(%rip), %rdi     # 0x31fb8
leaq 0x4ac1(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1da3d
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1da8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1da71
movq -0x30(%rbp), %rax
movl (%rax), %esi
movq 0x14520(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1dab9
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1db07
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1daed
movq -0x30(%rbp), %rbx
movq 0x144a6(%rip), %rdi     # 0x31fb8
leaq 0x464b(%rip), %rsi      # 0x22164
callq 0x31d0
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1db45
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1db93
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1db79
movq -0x30(%rbp), %rbx
movq 0x1441a(%rip), %rdi     # 0x31fb8
leaq 0x45bf(%rip), %rsi      # 0x22164
callq 0x31d0
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x30(%rbp), %rbx
movq 0x143f0(%rip), %rdi     # 0x31fb8
leaq 0x4595(%rip), %rsi      # 0x22164
callq 0x31d0
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1dbfb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1dc49
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1dc2f
movq -0x28(%rbp), %rbx
movq 0x14364(%rip), %rdi     # 0x31fb8
leaq 0x4530(%rip), %rsi      # 0x2218b
callq 0x31d0
movl -0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %rbx
movq 0x14336(%rip), %rdi     # 0x31fb8
leaq 0x3c91(%rip), %rsi      # 0x2191a
callq 0x31d0
subq %r14, %rbx
sarq $0x2, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31b0
leaq 0x3a36(%rip), %rsi      # 0x216dd
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1dccd
jmp 0x1dccd
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %r12
pushq %rbx
subq $0x20, %rsp
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x24(%rbp), %r14
movl %eax, -0x24(%rbp)
cmpl $0xa, %eax
jge 0x1dd1f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x24(%rbp), %eax
incl %eax
jmp 0x1dd05
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
movq 0x1428a(%rip), %rdi     # 0x31fb8
leaq 0x3bf3(%rip), %rsi      # 0x21928
callq 0x31d0
movq 0x14277(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
cmpq %r12, %r15
je 0x1dd66
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl (%r15), %esi
movq %rax, %rdi
callq 0x3320
addq $0x4, %r15
jmp 0x1dd45
movq 0x1424b(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dd8c
jmp 0x1dd8c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
leaq -0x50(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x2c(%rbp), %r14
movl %eax, -0x2c(%rbp)
cmpl $0xa, %eax
jge 0x1dde0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x1ddc6
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
xorl %r12d, %r12d
movq 0x141c6(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
leaq (%r15,%r12), %rax
cmpq %r13, %rax
je 0x1de1a
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3320
addq $0x4, %r12
movq %rax, %rdi
movl %r14d, %esi
callq 0x3210
jmp 0x1ddf6
movq 0x14197(%rip), %rdi     # 0x31fb8
callq 0x30e0
movq 0x1418b(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
testq %r12, %r12
je 0x1de54
movl -0x4(%r15,%r12), %esi
movq %rbx, %rdi
callq 0x3320
addq $-0x4, %r12
movq %rax, %rdi
movl %r14d, %esi
callq 0x3210
jmp 0x1de31
movq 0x1415d(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x50(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1de7e
jmp 0x1de7e
jmp 0x1de7e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1decc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1deb2
movq -0x30(%rbp), %rbx
movq 0x140e1(%rip), %rdi     # 0x31fb8
leaq 0x42cc(%rip), %rsi      # 0x221aa
callq 0x31d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1df0a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x1df58
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1df3e
movq -0x28(%rbp), %rbx
movq 0x14055(%rip), %rdi     # 0x31fb8
leaq 0x39ec(%rip), %rsi      # 0x21956
callq 0x31d0
movl -0x10(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1df96
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movaps %xmm0, -0x20(%rbp)
andq $0x0, -0x10(%rbp)
movq 0x13fe9(%rip), %rdi     # 0x31fb8
leaq 0x3117(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1e008
movq 0x13fc4(%rip), %rdi     # 0x31fb8
leaq 0x30f2(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %r12
pushq %rbx
subq $0x20, %rsp
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x14175(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0xa
popq %r15
pushq $0x64
popq %r12
leaq -0x24(%rbp), %r14
subl $0x1, %r15d
jb 0x1e098
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160d0
jmp 0x1e076
movq -0x40(%rbp), %r15
movq 0x13f15(%rip), %rbx     # 0x31fb8
leaq 0x4240(%rip), %r14      # 0x222ea
cmpq -0x38(%rbp), %r15
je 0x1e0cc
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3320
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
addq $0x4, %r15
jmp 0x1e0aa
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e0e4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %rbx
subq $0x28, %rsp
leaq -0x20(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x64
popq %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq (%rbx), %r15
movq 0x13e8c(%rip), %rbx     # 0x31fb8
leaq 0x41b7(%rip), %r14      # 0x222ea
cmpq -0x30(%rbp), %r15
je 0x1e155
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3320
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
addq $0x4, %r15
jmp 0x1e133
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %rbx
subq $0x28, %rsp
leaq -0x20(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq (%rbx), %r15
movabsq $0x400000003, %rax      # imm = 0x400000003
movq %rax, (%r15)
movq 0x13dfa(%rip), %rbx     # 0x31fb8
leaq 0x4125(%rip), %r14      # 0x222ea
cmpq -0x30(%rbp), %r15
je 0x1e1e7
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3320
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
addq $0x4, %r15
jmp 0x1e1c5
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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 %rbx
subq $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x6
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq (%rbx), %rax
movabsq $0x400000003, %rcx      # imm = 0x400000003
movq %rcx, (%rax)
movq 0x13d6c(%rip), %rdi     # 0x31fb8
pushq $0x1
popq %rsi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x13d55(%rip), %rdi     # 0x31fb8
xorl %esi, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x13d3f(%rip), %rdi     # 0x31fb8
xorl %esi, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x13d29(%rip), %rdi     # 0x31fb8
xorl %esi, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x13d13(%rip), %rdi     # 0x31fb8
pushq $0x1
popq %rsi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x13cfc(%rip), %rdi     # 0x31fb8
pushq $0x1
popq %rsi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330