LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_100_size_map()
void
test_map_iterators_100_size_map()
{
	typedef ft::map<int, int>::iterator iterator;

	ft::map<int, int> map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	for (iterator it = map.begin(); it != map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
movl $0x0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r15, 0x20(%rax)
leaq 0x1e583(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r15
cmpq $0x64, %r15
jne 0x15c6c
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15d22
movq 0x1e309(%rip), %r14     # 0x33fd0
leaq 0x10969(%rip), %r15     # 0x26637
leaq 0x10965(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movl 0x24(%rbx), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
jne 0x15cd5
movq 0x1e2a7(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e28c(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15d6d
jmp 0x15d6d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_100_size_const_map()
void
test_map_iterators_100_size_const_map()
{
	typedef ft::map<int, int>::const_iterator const_iterator;

	ft::map<int, int> const_map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		const_map.insert(ft::make_pair(i, rand() % 100 - 50));

	for (const_iterator it = const_map.begin(); it != const_map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
movl $0x0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r15, 0x20(%rax)
leaq 0x1e42a(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r15
cmpq $0x64, %r15
jne 0x15dc5
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15e7b
movq 0x1e1b0(%rip), %r14     # 0x33fd0
leaq 0x10810(%rip), %r15     # 0x26637
leaq 0x1080c(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movl 0x24(%rbx), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
jne 0x15e2e
movq 0x1e14e(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e133(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15ec6
jmp 0x15ec6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_copy()
void
test_map_iterators_copy()
{
	typedef ft::map<int, int>::iterator iterator;
	typedef ft::map<int, int>::const_iterator const_iterator;

	ft::map<int, int> map;

	srand(g_seed);

	for (int i = 0; i < 10; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	iterator it(map.begin());
	const_iterator const_it(it);

	for (const_iterator it = const_it; it != map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
movl $0x0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r15, 0x20(%rax)
leaq 0x1e2d1(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb43c
incq %r15
cmpq $0xa, %r15
jne 0x15f1e
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15fd4
movq 0x1e057(%rip), %r14     # 0x33fd0
leaq 0x106b7(%rip), %r15     # 0x26637
leaq 0x106b3(%rip), %r12     # 0x2663a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movl 0x24(%rbx), %esi
movq %r13, %rdi
callq 0x2330
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
jne 0x15f87
movq 0x1dff5(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1dfda(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaf10
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1601f
jmp 0x1601f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaf10
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_constructors()
void
test_stack_constructors()
{
	std::deque<int> mydeque(3, 100);
	std::list<int> mylist(3, 100);
	ft::vector<int> myvector(2, 200);

	ft::stack<int> first;
	ft::stack<int, std::deque<int> > second(mydeque);

	ft::stack<int, std::deque<int> > third;
	ft::stack<int, ft::vector<int> > fourth(myvector);
	ft::stack<int, std::list<int> > fifht(mylist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl $0x64, %r14d
leaq -0xd0(%rbp), %rbx
movl %r14d, (%rbx)
leaq -0x170(%rbp), %rdi
leaq -0x120(%rbp), %rcx
movl $0x3, %esi
movq %rbx, %rdx
callq 0x170e0
movl %r14d, (%rbx)
leaq -0x48(%rbp), %rbx
leaq -0xd0(%rbp), %rdx
leaq -0x120(%rbp), %rcx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x17140
movl $0x8, %edi
callq 0x2200
movq %rax, %r15
movq %rax, -0x30(%rbp)
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movabsq $0xc8000000c8, %rcx     # imm = 0xC8000000C8
movq %rcx, (%r15)
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
leaq -0xd0(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xafdc
leaq -0x120(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x17242
xorps %xmm0, %xmm0
leaq -0x1c0(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xafdc
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1767e
leaq -0x78(%rbp), %r15
leaq -0x48(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x176fe
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x163f3
movq (%rdi), %rbx
callq 0x21b0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x163e3
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x16401
callq 0x21b0
leaq -0x1c0(%rbp), %rdi
callq 0xaf82
leaq -0x120(%rbp), %rdi
callq 0xaf82
leaq -0xd0(%rbp), %rdi
callq 0xaf82
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x16433
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x1644c
movq (%rdi), %rbx
callq 0x21b0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x1643c
leaq -0x170(%rbp), %rdi
callq 0xaf82
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x1647c
callq 0x21b0
jmp 0x1647c
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0xaf82
jmp 0x1648d
movq %rax, %r14
leaq -0x120(%rbp), %rdi
callq 0xaf82
jmp 0x1649e
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0xaf82
movq -0x30(%rbp), %r15
testq %r15, %r15
jne 0x164b8
jmp 0x164c5
movq %rax, %r14
movq %r15, %rdi
callq 0x21b0
jmp 0x164c5
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x164e3
movq (%rdi), %r15
callq 0x21b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x164ce
jmp 0x164e3
movq %rax, %r14
leaq -0x170(%rbp), %rdi
callq 0xaf82
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_empty()
void
test_stack_empty()
{
	ft::vector<int> vec(5, 42);
	ft::stack<int, ft::vector<int> > stack(vec);
	ft::stack<int> empty;

	if (!stack.empty())
		std::cout << "Valid" << std::endl;
	if (empty.empty())
		std::cout << "Valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movl $0x14, %edi
callq 0x2200
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x28(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x1651e
leaq -0x38(%rbp), %rsi
movq %rcx, 0x8(%rsi)
leaq -0x20(%rbp), %rdi
callq 0x1767e
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xafdc
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x165b4
movq 0x1da5b(%rip), %rbx     # 0x33fd0
leaq 0x102d8(%rip), %rsi     # 0x26854
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1da29(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x60(%rbp), %rax
cmpq -0x80(%rbp), %rax
jne 0x16604
movq 0x1da0b(%rip), %rbx     # 0x33fd0
leaq 0x10288(%rip), %rsi     # 0x26854
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1d9d9(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x90(%rbp), %rdi
callq 0xaf82
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1661e
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1662c
callq 0x21b0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x1664f
movq %rax, %rbx
jmp 0x1665d
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xaf82
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1665d
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1666b
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_size()
void
test_stack_size()
{
	ft::vector<int> vec(5, 42);
	ft::stack<int, ft::vector<int> > stack(vec);
	ft::stack<int> empty;

	std::cout << stack.size() << std::endl;
	std::cout << empty.size() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movl $0x14, %edi
callq 0x2200
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x28(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x1669a
leaq -0x38(%rbp), %rsi
movq %rcx, 0x8(%rsi)
leaq -0x20(%rbp), %rdi
callq 0x1767e
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xafdc
movq -0x18(%rbp), %rsi
subq -0x20(%rbp), %rsi
sarq $0x2, %rsi
movq 0x1d8dd(%rip), %rdi     # 0x33fd0
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x48(%rbp), %rax
movq %rax, %rcx
subq -0x68(%rbp), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x7, %rcx
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rax
subq -0x58(%rbp), %rax
subq -0x80(%rbp), %rsi
sarq $0x2, %rax
sarq $0x2, %rsi
addq %rax, %rsi
addq %rcx, %rsi
movq 0x1d86e(%rip), %rdi     # 0x33fd0
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x90(%rbp), %rdi
callq 0xaf82
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x167ab
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x167b9
callq 0x21b0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x167dc
movq %rax, %rbx
jmp 0x167ea
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xaf82
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x167ea
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x167f8
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_top()
void
test_stack_top()
{
	ft::vector<int> vec;

	for (int i = 0; i < 100; i++) vec.push_back(i);

	ft::stack<int, ft::vector<int> > stack(vec);

	std::cout << stack.top() << std::endl;
	stack.top() = 42;
	std::cout << stack.top() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x28(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x16840
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x1684b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x28(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x63, %ecx
jl 0x1682a
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1767e
movq -0x20(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1d75c(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x20(%rbp), %rax
movl $0x2a, -0x4(%rax)
movq 0x1d71b(%rip), %rdi     # 0x33fd0
movl $0x2a, %esi
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x168f7
callq 0x21b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x16905
callq 0x21b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x16923
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x16926
callq 0x21b0
jmp 0x16926
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x16934
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_push_pop()
void
test_stack_push_pop()
{
	ft::stack<int> stack;

	for (int i = 0; i < 5; i++)
	{
		stack.push(i);
		std::cout << stack.top() << std::endl;
	}

	std::cout << "Popping out elements...";
	while (!stack.empty())
	{
		std::cout << stack.top() << std::endl;
		stack.pop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rbx
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xafdc
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
movl $0x200, %r13d           # imm = 0x200
movq 0x1d644(%rip), %r15     # 0x33fd0
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x169aa
movl %r12d, (%rax)
addq $0x4, %rax
movq %rax, -0x50(%rbp)
jmp 0x169b9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x178ba
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x169ca
movq -0x38(%rbp), %rax
movq -0x8(%rax), %rax
addq %r13, %rax
movl -0x4(%rax), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl -0x2c(%rbp), %eax
leal 0x1(%rax), %r12d
movl %r12d, -0x2c(%rbp)
cmpl $0x4, %eax
jl 0x1698c
movq 0x1d5b6(%rip), %rdi     # 0x33fd0
leaq 0xfe39(%rip), %rsi      # 0x2685a
movl $0x17, %edx
callq 0x2230
movq -0x50(%rbp), %rax
cmpq -0x70(%rbp), %rax
je 0x16adb
movq -0x48(%rbp), %rdi
movl $0x200, %r15d           # imm = 0x200
movq 0x1d586(%rip), %rbx     # 0x33fd0
cmpq %rdi, %rax
jne 0x16a5a
movq -0x38(%rbp), %rax
movq -0x8(%rax), %rax
addq %r15, %rax
movl -0x4(%rax), %esi
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
cmpq %rdi, %rax
je 0x16aa2
addq $-0x4, %rax
jmp 0x16acd
callq 0x21b0
movq -0x38(%rbp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq -0x8(%rax), %rdi
movq %rdi, -0x48(%rbp)
leaq 0x200(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x1fc(%rdi), %rax
movq %rax, -0x50(%rbp)
cmpq -0x70(%rbp), %rax
jne 0x16a4a
leaq -0x80(%rbp), %rdi
callq 0xaf82
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16af7
jmp 0x16af7
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xaf82
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack()
void
test_stack()
{
	test_wrapper(test_stack_constructors, "stack_constructors");
	test_wrapper(test_stack_empty, "stack_empty");
	test_wrapper(test_stack_size, "stack_size");
	test_wrapper(test_stack_top, "stack_top");
	test_wrapper(test_stack_push_pop, "stack_push & pop");
	test_wrapper(test_stack_relational_operators, "stack_relational_operators");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq -0xc0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf96d(%rip), %rsi      # 0x26872
leaq 0xf978(%rip), %rdx      # 0x26884
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0xc4a(%rip), %rdi      # 0x162d8
movq %rbx, %rsi
callq 0x25dae
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x16f3b
callq 0x21b0
leaq -0xa0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf938(%rip), %rsi      # 0x26885
leaq 0xf93c(%rip), %rdx      # 0x26890
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0xa73(%rip), %rdi      # 0x164f7
movq %rbx, %rsi
callq 0x25dae
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
je 0x16f83
callq 0x21b0
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf8ff(%rip), %rsi      # 0x26891
leaq 0xf902(%rip), %rdx      # 0x2689b
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x93c(%rip), %rdi      # 0x16673
movq %rbx, %rsi
callq 0x25dae
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x16fc8
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf8c5(%rip), %rsi      # 0x2689c
leaq 0xf8c7(%rip), %rdx      # 0x268a5
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x7f1(%rip), %rdi      # 0x16800
movq %rbx, %rsi
callq 0x25dae
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x17007
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf890(%rip), %rsi      # 0x268a6
leaq 0xf899(%rip), %rdx      # 0x268b6
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x6f4(%rip), %rdi      # 0x1693c
movq %rbx, %rsi
callq 0x25dae
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x17046
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf862(%rip), %rsi      # 0x268b7
leaq 0xf875(%rip), %rdx      # 0x268d1
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x564(%rip), %rdi      # 0x16b0b
movq %rbx, %rsi
callq 0x25dae
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x17085
callq 0x21b0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x170ce
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x170ce
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0x170ce
movq %rax, %rbx
movq -0x90(%rbp), %rdi
jmp 0x170ce
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
jmp 0x170ce
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x170d8
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_constructors_base()
void
test_vector_reverse_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;
	typedef ft::vector<int>::reverse_iterator rev_iter_type;

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

	rev_iter_type rev_until(from);
	rev_iter_type rev_from(until);

	iter_type it_end = rev_until.base();
	iter_type it_begin = rev_from.base();

	if (it_end == from && it_begin == until)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17b04
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17b0f
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17aee
movq 0x1c4ac(%rip), %rbx     # 0x33fd0
leaq 0xf96b(%rip), %rsi      # 0x27496
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1c47a(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17b71
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17b7c
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17b8d
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_star()
void
test_vector_reverse_iterators_operator_star()
{
	ft::vector<int> myvector;

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

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

	iter_type until(myvector.end());

	rev_iter_type rev_from(until);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17bd5
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17be0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17bbf
movq -0x28(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1c3d4(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17c39
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17c44
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17c55
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_brackets()
void
test_vector_reverse_iterators_operator_brackets()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = myvector.rbegin();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17c9d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17ca8
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17c87
movq -0x28(%rbp), %rbx
movq 0x1c30f(%rip), %rdi     # 0x33fd0
leaq 0xec0a(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c2f4(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17d19
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17d24
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17d35
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_plus()
void
test_vector_reverse_iterators_operator_plus()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = 3 + myvector.rbegin();

	std::cout << "The fourth element from the end is: " << *rev_it << std::endl;

	rev_it = myvector.rbegin() + 3;

	std::cout << "The fourth element from the end is: " << *rev_it << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17d7d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17d88
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17d67
movq -0x28(%rbp), %rbx
movq 0x1c22f(%rip), %rdi     # 0x33fd0
leaq 0xeb2a(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c214(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x28(%rbp), %rbx
movq 0x1c1da(%rip), %rdi     # 0x33fd0
leaq 0xead5(%rip), %rsi      # 0x268d2
movl $0x24, %edx
callq 0x2230
movl -0x10(%rbx), %esi
movq 0x1c1bf(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17e4e
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17e59
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17e6a
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_minus()
void
test_vector_reverse_iterators_operator_minus()
{
	ft::vector<int> myvector;
	for (int i = 0; i < 10; i++)
		myvector.push_back(i);

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

	ft::reverse_iterator<iter_type> rev_it;

	rev_it = myvector.rend() - 3;

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

	ft::reverse_iterator<iter_type> from, until;

	from = myvector.rbegin();
	until = myvector.rend();

	std::cout << "myvector has " << (until - from) << " elements." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x17eb2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x17ebd
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x17e9c
movq -0x30(%rbp), %rbx
movq 0x1c0fa(%rip), %rdi     # 0x33fd0
leaq 0xea1a(%rip), %rsi      # 0x268f7
movl $0x1f, %edx
callq 0x2230
movl 0x8(%rbx), %esi
movq 0x1c0df(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %rbx
movq 0x1c0a1(%rip), %rdi     # 0x33fd0
leaq 0xe9e1(%rip), %rsi      # 0x26917
movl $0xd, %edx
callq 0x2230
subq %r14, %rbx
sarq $0x2, %rbx
movq 0x1c082(%rip), %rdi     # 0x33fd0
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rbx
leaq 0xe7ab(%rip), %rsi      # 0x2670b
movl $0xa, %edx
movq %rax, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17fa2
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17faf
jmp 0x17faf
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x17fc0
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_increment()
void
test_vector_reverse_iterators_operator_increment()
{
	ft::vector<int> myvector;

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

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

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

	ft::reverse_iterator<iter_type> rev_until(from);
	ft::reverse_iterator<iter_type> rev_from(until);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x1800c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x18017
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x24(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x9, %ecx
jl 0x17ff6
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
movq 0x1bf9c(%rip), %rdi     # 0x33fd0
leaq 0xe8ea(%rip), %rsi      # 0x26925
movl $0x9, %edx
callq 0x2230
movq 0x1bf84(%rip), %rbx     # 0x33fd0
leaq -0x24(%rbp), %r14
cmpq %r15, %r12
je 0x1807c
movb $0x20, -0x24(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movl -0x4(%r12), %esi
addq $-0x4, %r12
movq %rax, %rdi
callq 0x2330
jmp 0x18050
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1bf36(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x180b5
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x180c6
jmp 0x180c6
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x180d7
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_decrement()
void
test_vector_reverse_iterators_operator_decrement()
{
	ft::vector<int> myvector;

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

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

	ft::reverse_iterator<iter_type> rev_begin (myvector.end());
	ft::reverse_iterator<iter_type> rev_end (myvector.begin());

	ft::reverse_iterator<iter_type> rev_iterator = rev_begin;
	while (rev_iterator != rev_end)
		std::cout << *rev_iterator++ << ' ';
	std::cout << std::endl;

	while (rev_iterator != rev_begin)
		std::cout << *(--rev_iterator) << ' ';
	std::cout << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x18125
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x18130
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x1810f
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r12
movq %r12, %r13
cmpq %r15, %r12
je 0x18185
movq 0x1be7b(%rip), %rbx     # 0x33fd0
leaq -0x2c(%rbp), %r14
movq %r12, %r13
movl -0x4(%r13), %esi
movq %rbx, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
addq $-0x4, %r13
cmpq %r15, %r13
jne 0x1815c
movq 0x1be44(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1be29(%rip), %rbx     # 0x33fd0
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r12, %r13
je 0x181f0
movq 0x1be0d(%rip), %r14     # 0x33fd0
leaq -0x2c(%rbp), %r15
movl (%r13), %esi
movq %r14, %rdi
callq 0x2330
movb $0x20, -0x2c(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
addq $0x4, %r13
cmpq %r12, %r13
jne 0x181c7
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1bdc2(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x18229
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1823e
jmp 0x1823e
jmp 0x1823e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1824f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_plus_equal()
void
test_vector_reverse_iterators_operator_plus_equal()
{
	ft::vector<int> myvector;

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

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

	ft::reverse_iterator<iter_type> rev_iterator = myvector.rbegin();

	rev_iterator += 2;

	std::cout << "The third element from the end is: " << *rev_iterator << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x18297
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x182a2
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x18281
movq -0x28(%rbp), %rbx
movq 0x1bd15(%rip), %rdi     # 0x33fd0
leaq 0xe66d(%rip), %rsi      # 0x2692f
movl $0x23, %edx
callq 0x2230
movl -0xc(%rbx), %esi
movq 0x1bcfa(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x18313
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1831e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1832f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_minus_equal()
void
test_vector_reverse_iterators_operator_minus_equal()
{
	ft::vector<int> myvector;

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

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

	ft::reverse_iterator<iter_type> rev_iterator = myvector.rend();

	rev_iterator -= 4;

	std::cout <<  "rev_iterator now points to: " << *rev_iterator << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x18377
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x18382
movq %rbx, %rdi
movq %r14, %rdx
callq 0x177a0
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x18361
movq -0x30(%rbp), %rbx
movq 0x1bc35(%rip), %rdi     # 0x33fd0
leaq 0xe5b1(%rip), %rsi      # 0x26953
movl $0x1c, %edx
callq 0x2230
movl 0xc(%rbx), %esi
movq 0x1bc1a(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x183f3
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x183fe
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1840f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_empty_vectors()
void
test_vector_reverse_iterators_empty_vectors()
{
	ft::vector<int> vec;
	ft::vector<int> const const_vec;

	if (vec.rbegin() == vec.rend())
		std::cout << "correct" << std::endl;

	if (const_vec.rbegin() == const_vec.rend())
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1bbab(%rip), %rbx     # 0x33fd0
leaq 0xdd03(%rip), %r14      # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x7, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_100_size_vector()
void
test_vector_reverse_iterators_100_size_vector()
{
	typedef ft::vector<int>::reverse_iterator reverse_iterator;

	ft::vector<int> vec;

	srand(g_seed);

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

	for (reverse_iterator it = vec.rbegin(); it != vec.rend(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x1bd1c(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0xa, %r15d
leaq -0x1c(%rbp), %r14
callq 0x2070
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x32, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x18513
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x1851e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18afe
decl %r15d
jne 0x184d5
movq -0x38(%rbp), %r15
movq 0x1baa2(%rip), %rbx     # 0x33fd0
leaq 0xedd5(%rip), %r14      # 0x2730a
movq -0x40(%rbp), %rdi
cmpq %rdi, %r15
je 0x18560
movl -0x4(%r15), %esi
movq %rbx, %rdi
callq 0x2330
addq $-0x4, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
jmp 0x18535
testq %r15, %r15
je 0x1856a
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18577
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x18588
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_100_size_const_vector()
void
test_vector_reverse_iterators_100_size_const_vector()
{
	typedef ft::vector<int>::const_reverse_iterator const_reverse_iterator;

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

	for (const_reverse_iterator it = const_vec.rbegin(); it != const_vec.rend(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x190, %edi            # imm = 0x190
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x190, %rax            # imm = 0x190
jne 0x185aa
movl $0x190, %r12d           # imm = 0x190
movq 0x1ba06(%rip), %r14     # 0x33fd0
leaq 0xed39(%rip), %r15      # 0x2730a
testq %r12, %r12
je 0x185f9
movl -0x4(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
addq $-0x4, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
jmp 0x185d1
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_copy()
void
test_vector_reverse_iterators_copy()
{
	typedef ft::vector<int>::reverse_iterator reverse_iterator;
	typedef ft::vector<int>::const_reverse_iterator const_reverse_iterator;

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

	reverse_iterator it(vec.rbegin());
	*it = 3;
	*(it + 1) = 4;
	const_reverse_iterator const_it(it);

	for (const_reverse_iterator it = const_it; it != vec.rend(); it++)
		std::cout << *it << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x18, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl $0x2a, (%rbx,%rax)
addq $0x4, %rax
cmpq $0x18, %rax
jne 0x18636
movabsq $0x300000004, %rax      # imm = 0x300000004
movq %rax, 0x10(%rbx)
movl $0x18, %r12d
movq 0x1b96e(%rip), %r14     # 0x33fd0
leaq 0xeca1(%rip), %r15      # 0x2730a
testq %r12, %r12
je 0x18691
movl -0x4(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2330
addq $-0x4, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
jmp 0x18669
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_non_member_overloads.cpp
// Function: test_vector_non_member_overloads_swap_ints()
void
test_vector_non_member_overloads_swap_ints()
{
	ft::vector<int> v1(5, 42), v2(100, -42);

	print_vec_info(v1);
	print_vec_info(v2);

	swap(v1, v2);

	print_vec_info(v1);
	print_vec_info(v2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movl $0x14, %edi
callq 0x2200
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x28(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x190e6
movq %rcx, -0x30(%rbp)
movl $0x190, %edi            # imm = 0x190
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, %rcx
addq $0x190, %rcx            # imm = 0x190
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0xffffffd6, (%rax,%rdx) # imm = 0xFFFFFFD6
addq $0x4, %rdx
cmpq $0x190, %rdx            # imm = 0x190
jne 0x19119
movq %rcx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x193f4
leaq -0x20(%rbp), %rdi
callq 0x193f4
leaq -0x38(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x18(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x20(%rbp)
movq %rax, -0x10(%rbp)
callq 0x193f4
leaq -0x20(%rbp), %rdi
callq 0x193f4
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x19181
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1918f
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x191ac
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x191ac
callq 0x21b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x191ba
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_non_member_overloads.cpp
// Function: test_vector_non_member_overloads_swap_strings()
void
test_vector_non_member_overloads_swap_strings()
{
	ft::vector<std::string> v1(5, "42"), v2(100, "-42");

	print_vec_info(v1);
	print_vec_info(v2);

	v1.swap(v2);

	print_vec_info(v1);
	print_vec_info(v2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd8aa(%rip), %rsi      # 0x26a86
leaq 0xd8a5(%rip), %rdx      # 0x26a88
leaq -0x50(%rbp), %rdi
callq 0x2f88
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x5, %esi
callq 0x1955c
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x19210
callq 0x21b0
leaq -0x50(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xd867(%rip), %rsi      # 0x26a85
leaq 0xd863(%rip), %rdx      # 0x26a88
callq 0x2f88
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x11(%rbp), %rcx
movl $0x64, %esi
callq 0x1955c
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x1924e
callq 0x21b0
leaq -0x68(%rbp), %rdi
callq 0x195f2
leaq -0x30(%rbp), %rdi
callq 0x195f2
leaq -0x68(%rbp), %rdi
movups (%rdi), %xmm0
movq 0x10(%rdi), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rdi)
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, -0x30(%rbp)
movq %rax, -0x20(%rbp)
callq 0x195f2
leaq -0x30(%rbp), %rdi
callq 0x195f2
leaq -0x30(%rbp), %rdi
callq 0xacd4
leaq -0x68(%rbp), %rdi
callq 0xacd4
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x192e7
callq 0x21b0
jmp 0x192e7
movq %rax, %rbx
jmp 0x192e7
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x192f0
callq 0x21b0
jmp 0x192f0
movq %rax, %rbx
jmp 0x192f0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xacd4
leaq -0x68(%rbp), %rdi
callq 0xacd4
movq %rbx, %rdi
callq 0x2340