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

	std::cout << "Empty: " << map.empty() << std::endl;
	std::cout << "Size: " << map.size() << std::endl;
	std::cout << "Max size: " << map.max_size() << std::endl;

	srand(g_seed);

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

	std::cout << "Empty: " << map.empty() << std::endl;
	std::cout << "Size: " << map.size() << std::endl;
	std::cout << "Max size: " << map.max_size() << 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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x202fb(%rip), %rdi     # 0x31fb8
leaq 0xf687(%rip), %rsi      # 0x2134b
callq 0x31d0
xorl %esi, %esi
cmpq $0x0, -0x38(%rbp)
sete %sil
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x202cd(%rip), %rdi     # 0x31fb8
leaq 0xf38f(%rip), %rsi      # 0x21081
callq 0x31d0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
movq 0x202a6(%rip), %rdi     # 0x31fb8
leaq 0xf63a(%rip), %rsi      # 0x21353
callq 0x31d0
movabsq $0x333333333333333, %rsi # imm = 0x333333333333333
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq 0x20499(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x2a
popq %r12
pushq $0x64
popq %r13
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
subl $0x1, %r12d
jb 0x11d90
callq 0x3070
cltd
idivl %r13d
movl %edx, %r15d
addl $-0x32, %r15d
callq 0x3070
cltd
idivl %r13d
addl $-0x32, %edx
shlq $0x20, %rdx
orq %rdx, %r15
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
jmp 0x11d56
movq 0x20221(%rip), %rdi     # 0x31fb8
leaq 0xf5ad(%rip), %rsi      # 0x2134b
callq 0x31d0
xorl %esi, %esi
cmpq $0x0, -0x38(%rbp)
sete %sil
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq 0x201f3(%rip), %rdi     # 0x31fb8
leaq 0xf2b5(%rip), %rsi      # 0x21081
callq 0x31d0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
movq 0x201cc(%rip), %rdi     # 0x31fb8
leaq 0xf560(%rip), %rsi      # 0x21353
callq 0x31d0
movabsq $0x333333333333333, %rsi # imm = 0x333333333333333
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11e2c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_range()
void
test_map_constructors_range()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	ft::map<char, int> range(map.begin(), map.end());

	print_map_info(map);
	print_map_info(range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x80(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x2032b(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x61
popq %r12
movl $0x2710, %r13d          # imm = 0x2710
leaq -0x88(%rbp), %r14
leaq -0x58(%rbp), %r15
cmpq $0x7b, %r12
je 0x11ef9
callq 0x3070
cltd
idivl %r13d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
shlq $0x20, %rdx
addq %r12, %rdx
movq %rdx, -0x58(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x112b4
incq %r12
jmp 0x11ec9
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rbx, %rdx
callq 0x12722
leaq -0x88(%rbp), %rdi
callq 0xc1a3
leaq -0x58(%rbp), %rdi
callq 0xc1a3
leaq -0x58(%rbp), %rdi
callq 0xc2f0
leaq -0x88(%rbp), %rdi
callq 0xc2f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11f52
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc2f0
jmp 0x11f55
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_int()
void
test_map_constructors_copy_int()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	{
		ft::map<char, int> cpy1(map);
		ft::map<char, int> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2023d(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x61
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x50(%rbp), %rbx
leaq -0x80(%rbp), %r14
cmpq $0x7b, %r15
je 0x11fe4
callq 0x3070
cltd
idivl %r12d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x80(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x112b4
incq %r15
jmp 0x11fb4
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x129e8
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x129e8
leaq -0x50(%rbp), %rdi
callq 0xc1a3
leaq -0x80(%rbp), %rdi
callq 0xc1a3
leaq -0xb0(%rbp), %rdi
callq 0xc1a3
leaq -0xb0(%rbp), %rdi
callq 0xc2f0
leaq -0x80(%rbp), %rdi
callq 0xc2f0
leaq -0x50(%rbp), %rdi
callq 0xc2f0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x12063
jmp 0x1206e
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0xc2f0
leaq -0x80(%rbp), %rdi
callq 0xc2f0
jmp 0x12071
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_string()
void
test_map_constructors_copy_string()
{
	ft::map<char, std::string> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, ft_itoa(rand() % 10000 - 10000 / 2)));

	{
		ft::map<char, std::string> cpy1(map);
		ft::map<char, std::string> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq -0xb0(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2011f(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
leaq -0x70(%rbp), %r13
movb $0x61, %bl
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
leaq -0x88(%rbp), %r12
cmpb $0x7b, %bl
je 0x1215f
callq 0x3070
cltd
movl $0x2710, %ecx           # imm = 0x2710
idivl %ecx
leal -0x1388(%rdx), %esi
movq %r14, %rdi
callq 0x4d7a
movb %bl, -0x88(%rbp)
movq %r13, -0x80(%rbp)
movq -0x58(%rbp), %rax
cmpq %r15, %rax
je 0x1211a
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x12123
movups (%r15), %xmm0
movups %xmm0, (%r13)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %r15, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
leaq -0xb8(%rbp), %rdi
movq %r12, %rsi
callq 0x12f7a
leaq -0x80(%rbp), %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x30d0
incb %bl
jmp 0x120d5
leaq -0x88(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x12bb8
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x12bb8
leaq -0xb8(%rbp), %rdi
callq 0x12765
leaq -0x88(%rbp), %rdi
callq 0x12765
leaq -0x58(%rbp), %rdi
callq 0x12765
leaq -0x58(%rbp), %rdi
callq 0xe916
leaq -0x88(%rbp), %rdi
callq 0xe916
leaq -0xb8(%rbp), %rdi
callq 0xe916
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x121e9
jmp 0x121f7
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xe916
leaq -0x88(%rbp), %rdi
callq 0xe916
jmp 0x12211
movq %rax, %r14
jmp 0x12211
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x30d0
leaq -0x58(%rbp), %rdi
callq 0x30d0
leaq -0xb8(%rbp), %rdi
callq 0xe916
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_char()
void
test_map_constructors_custom_compare_char()
{
	ft::map<char, int, greater<char> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x1ff84(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x61
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x58(%rbp), %rbx
leaq -0x28(%rbp), %r14
cmpq $0x7b, %r15
je 0x1229d
callq 0x3070
cltd
idivl %r12d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x28(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13042
incq %r15
jmp 0x1226d
leaq -0x58(%rbp), %rdi
callq 0x1283b
leaq -0x58(%rbp), %rdi
callq 0x12e00
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x122be
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x12e00
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_string()
void
test_map_constructors_custom_compare_string()
{
	ft::map<std::string, char, greater<std::string> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(ft_itoa(rand() % 10000 - 10000 / 2), i));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x98(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x1fed2(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
leaq -0x60(%rbp), %r12
movb $0x61, %r13b
leaq -0x38(%rbp), %r14
leaq -0x48(%rbp), %rbx
leaq -0x70(%rbp), %r15
cmpb $0x7b, %r13b
je 0x123a5
callq 0x3070
cltd
movl $0x2710, %ecx           # imm = 0x2710
idivl %ecx
leal -0x1388(%rdx), %esi
movq %rbx, %rdi
callq 0x4d7a
movq %r12, -0x70(%rbp)
movq -0x48(%rbp), %rax
cmpq %r14, %rax
je 0x1235c
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x12365
movups (%r14), %xmm0
movups %xmm0, (%r12)
movq -0x40(%rbp), %rax
movq %r14, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movq %rax, -0x68(%rbp)
movb $0x0, -0x38(%rbp)
movb %r13b, -0x50(%rbp)
leaq -0xa0(%rbp), %rdi
movq %r15, %rsi
callq 0x131a8
movq %r15, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
incb %r13b
jmp 0x12320
leaq -0xa0(%rbp), %rdi
callq 0x12911
leaq -0xa0(%rbp), %rdi
callq 0x12e56
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x123ce
movq %rax, %rbx
jmp 0x123e8
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x30d0
leaq -0xa0(%rbp), %rdi
callq 0x12e56
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_cplusplus()
void
test_map_constructors_cplusplus()
{
	ft::map<char, int> first;

	first['a'] = 10;
	first['b'] = 30;
	first['c'] = 50;
	first['d'] = 70;

	ft::map<char, int> second(first.begin(), first.end());

	ft::map<char, int> third(second);

	ft::map<char, int, classcomp> fourth;

	bool(*fn_pt)(char, char) = fncomp;
	ft::map<char, int, bool(*)(char, char)> fifth(fn_pt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xf8, %rsp
leaq -0x60(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x38(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xc29e
movl $0xa, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xc29e
movl $0x1e, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xc29e
movl $0x32, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xc29e
movl $0x46, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x12722
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x129e8
leaq -0xc0(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x67c(%rip), %rax      # 0x11e40
leaq -0x90(%rbp), %rcx
movq %rax, -0x8(%rcx)
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x98(%rbp), %rdi
callq 0x12ece
leaq -0xc8(%rbp), %rdi
callq 0x12f24
leaq -0xf8(%rbp), %rdi
callq 0xc2f0
leaq -0x38(%rbp), %rdi
callq 0xc2f0
leaq -0x68(%rbp), %rdi
callq 0xc2f0
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc2f0
jmp 0x12535
jmp 0x12532
jmp 0x12532
jmp 0x12532
jmp 0x12532
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xc2f0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors()
void
test_map_constructors()
{
	test_wrapper(test_map_constructors_empty, "empty");
	test_wrapper(test_map_constructors_range, "range");
	test_wrapper(test_map_constructors_copy_int, "copy int");
	test_wrapper(test_map_constructors_copy_string, "copy string");
	test_wrapper(test_map_constructors_custom_compare_char, "custom_compare_int");
	test_wrapper(test_map_constructors_custom_compare_string, "custom_compare_string");
	test_wrapper(test_map_constructors_cplusplus, "cplusplus");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
leaq 0xf7ea(%rip), %rsi      # 0x21d43
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x724(%rip), %rdi      # 0x11e4c
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0xfc79(%rip), %rsi      # 0x22208
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x72a(%rip), %rdi      # 0x11e7c
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0xead9(%rip), %rsi      # 0x2109e
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x673(%rip), %rdi      # 0x11f69
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0xeaac(%rip), %rsi      # 0x210a7
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x590(%rip), %rdi      # 0x12082
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0xea82(%rip), %rsi      # 0x210b3
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x420(%rip), %rdi      # 0x12225
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0xea68(%rip), %rsi      # 0x210c6
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x3a0(%rip), %rdi      # 0x122d2
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0xfa83(%rip), %rsi      # 0x2210e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x2a3(%rip), %rdi      # 0x123fc
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x12710
jmp 0x12717
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x30d0
jmp 0x1271a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_constructors_base()
void
test_map_iterators_constructors_base()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

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

	if (from == cpy)
		std::cout << "valid" << 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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0x13414
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0x133fa
movq 0x1eb9d(%rip), %rdi     # 0x31fb8
leaq 0xf0bb(%rip), %rsi      # 0x224dd
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13449
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_star()
void
test_map_iterators_operator_star()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type from(map.begin());

	std::cout << "[" << from->first << "] = " << from->second << 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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0x134c1
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0x134a7
movq -0x48(%rbp), %rbx
movq 0x1eaec(%rip), %rdi     # 0x31fb8
leaq 0xe137(%rip), %rsi      # 0x2160a
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
leaq 0xe122(%rip), %rsi      # 0x2160c
movq %rax, %rdi
callq 0x31d0
movsbl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13520
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_increment()
void
test_map_iterators_operator_increment()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

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

	std::cout << "map:";
	while (from != until)
	{
		std::cout << " [" << from->first << "] = " << from->second;
		from++;
	}
	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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0x13598
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0x1357e
movq -0x48(%rbp), %rbx
movq 0x1ea15(%rip), %rdi     # 0x31fb8
leaq 0xe06a(%rip), %rsi      # 0x21614
callq 0x31d0
movq 0x1ea02(%rip), %r14     # 0x31fb8
leaq 0xe04c(%rip), %r15      # 0x21609
leaq 0xe048(%rip), %r12      # 0x2160c
leaq -0x58(%rbp), %r13
cmpq %r13, %rbx
je 0x13607
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movsbl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3150
movq %rax, %rbx
jmp 0x135c8
movq 0x1e9aa(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1362f
jmp 0x1362f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_decrement()
void
test_map_iterators_operator_decrement()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type begin(map.begin());
	iter_type end(map.end());

	iter_type it(begin);
	while (it != end)
		std::cout << " [" << it->first << "] = " << (it++)->second;
	std::cout << std::endl;

	while (it != begin)
		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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0xa
popq %r15
movabsq $0x3000000030, %r12     # imm = 0x3000000030
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
subq $0x1, %r15
jb 0x136a7
movq %r12, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd392
addq %r13, %r12
jmp 0x1368d
movq -0x48(%rbp), %r15
leaq 0xdf5a(%rip), %r12      # 0x2160c
movq %r15, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x13706
movq 0x1e8f3(%rip), %rdi     # 0x31fb8
leaq 0xdf3d(%rip), %rsi      # 0x21609
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x3150
movq %rax, %r14
movsbl 0x24(%rbx), %esi
movq %r13, %rdi
callq 0x3210
movq %r14, %rbx
jmp 0x136b5
movq 0x1e8ab(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq 0xdef0(%rip), %r14      # 0x21609
leaq 0xdeec(%rip), %r12      # 0x2160c
cmpq %r15, %rbx
je 0x13766
movq 0x1e88c(%rip), %rdi     # 0x31fb8
movq %r14, %rsi
callq 0x31d0
movq %rax, %r13
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rbx
movl 0x20(%rax), %esi
movq %r13, %rdi
callq 0x3320
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movsbl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x3210
jmp 0x13720
movq 0x1e84b(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xd33c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13792
jmp 0x13792
jmp 0x13792
jmp 0x13792
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd33c
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_empty_maps()
void
test_map_iterators_empty_maps()
{
	ft::map<int, int> map;
	ft::map<int, int> const const_map;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x60(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x30(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq 0x1e7d0(%rip), %rdi     # 0x31fb8
leaq 0xd8fe(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
cmpq %rbx, -0x20(%rbp)
jne 0x1381d
movq 0x1e7af(%rip), %rdi     # 0x31fb8
leaq 0xd8dd(%rip), %rsi      # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x38(%rbp), %rdi
callq 0xa648
leaq -0x68(%rbp), %rdi
callq 0xa648
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa648
leaq -0x68(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq 0x1e952(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
cmpq $0x64, %r15
je 0x138c9
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0x1389c
movq -0x48(%rbp), %r12
movq 0x1e6e4(%rip), %rbx     # 0x31fb8
leaq 0xdd2e(%rip), %r14      # 0x21609
leaq 0xdd2a(%rip), %r15      # 0x2160c
cmpq %r13, %r12
je 0x13924
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movl 0x24(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %r12, %rdi
callq 0x3150
movq %rax, %r12
jmp 0x138e2
movq 0x1e68d(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1394c
jmp 0x1394c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq 0x1e845(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
cmpq $0x64, %r15
je 0x139d6
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0x139a9
movq -0x48(%rbp), %r12
movq 0x1e5d7(%rip), %rbx     # 0x31fb8
leaq 0xdc21(%rip), %r14      # 0x21609
leaq 0xdc1d(%rip), %r15      # 0x2160c
cmpq %r13, %r12
je 0x13a31
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movl 0x24(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %r12, %rdi
callq 0x3200
movq %rax, %r12
jmp 0x139ef
movq 0x1e580(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a59
jmp 0x13a59
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq 0x1e738(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
cmpq $0xa, %r15
je 0x13ae3
callq 0x3070
cltd
idivl %r12d
addl $-0x32, %edx
shlq $0x20, %rdx
addq %r15, %rdx
movq %rdx, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad0a
incq %r15
jmp 0x13ab6
movq -0x48(%rbp), %r12
movq 0x1e4ca(%rip), %rbx     # 0x31fb8
leaq 0xdb14(%rip), %r14      # 0x21609
leaq 0xdb10(%rip), %r15      # 0x2160c
cmpq %r13, %r12
je 0x13b3e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movl 0x24(%r12), %esi
movq %rax, %rdi
callq 0x3320
movq %r12, %rdi
callq 0x3200
movq %rax, %r12
jmp 0x13afc
movq 0x1e473(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0xa648
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b66
jmp 0x13b66
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators()
void
test_map_iterators()
{
	test_wrapper(test_map_iterators_constructors_base, "constructors base");
	test_wrapper(test_map_iterators_operator_star, "operator*()");
	test_wrapper(test_map_iterators_operator_increment, "operator++()");
	test_wrapper(test_map_iterators_operator_decrement, "operator--()");
	test_wrapper(test_map_iterators_empty_maps, "empty maps");
	test_wrapper(test_map_iterators_100_size_map, "100 size map");
	test_wrapper(test_map_iterators_100_size_const_map, "100 size const map");
	test_wrapper(test_map_iterators_copy, "copy");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0xd756(%rip), %rsi      # 0x212e3
leaq -0x110(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x7f4(%rip), %rdi      # 0x133b0
leaq -0x110(%rbp), %rsi
callq 0x20ca4
leaq -0x110(%rbp), %rdi
callq 0x30d0
leaq 0xd732(%rip), %rsi      # 0x212f5
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x77d(%rip), %rdi      # 0x1345d
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0xd708(%rip), %rsi      # 0x21301
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x6dc(%rip), %rdi      # 0x13534
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0xd6df(%rip), %rsi      # 0x2130e
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x603(%rip), %rdi      # 0x13643
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0xd9b4(%rip), %rsi      # 0x21619
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x4d6(%rip), %rdi      # 0x137a6
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0xd989(%rip), %rsi      # 0x21624
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x45c(%rip), %rdi      # 0x13853
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0xd969(%rip), %rsi      # 0x21631
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x37c(%rip), %rdi      # 0x13960
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0xd651(%rip), %rsi      # 0x21346
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x29c(%rip), %rdi      # 0x13a6d
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
jmp 0x13d88
jmp 0x13d8f
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x30d0
jmp 0x13d92
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x64
popq %r15
leaq -0x118(%rbp), %rbx
movl %r15d, (%rbx)
leaq -0x168(%rbp), %rdi
pushq $0x3
popq %r14
leaq -0xc8(%rbp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x145ca
movl %r15d, (%rbx)
leaq -0x48(%rbp), %rdi
leaq -0x118(%rbp), %rdx
leaq -0xc8(%rbp), %rcx
movq %r14, %rsi
callq 0x14626
leaq -0x118(%rbp), %rdx
movl $0xc8, (%rdx)
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rsi
leaq -0xc8(%rbp), %rcx
callq 0x1465a
leaq -0x118(%rbp), %rdi
callq 0xa2ca
leaq -0xc8(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x14954
leaq -0x1b8(%rbp), %rdi
callq 0xa2ca
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14fea
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x15042
leaq -0x78(%rbp), %rdi
callq 0x14710
leaq -0x60(%rbp), %rdi
callq 0xa746
leaq -0x1b8(%rbp), %rdi
callq 0xa6b6
leaq -0xc8(%rbp), %rdi
callq 0xa6b6
leaq -0x118(%rbp), %rdi
callq 0xa6b6
leaq -0x30(%rbp), %rdi
callq 0xa746
leaq -0x48(%rbp), %rdi
callq 0x14710
leaq -0x168(%rbp), %rdi
callq 0xa6b6
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa746
jmp 0x13ecc
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0xa6b6
jmp 0x13edd
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0xa6b6
jmp 0x13eee
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0xa6b6
jmp 0x13eff
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
leaq -0x48(%rbp), %rdi
callq 0x14710
leaq -0x168(%rbp), %rdi
callq 0xa6b6
movq %rbx, %rdi
callq 0x3330
movq %rax, %rbx
jmp 0x13f08
movq %rax, %rbx
jmp 0x13f11
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x88(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x5
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x14fea
leaq -0x88(%rbp), %rdi
callq 0xa2ca
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x13f98
movq 0x1e034(%rip), %rdi     # 0x31fb8
leaq 0xd89b(%rip), %rsi      # 0x21826
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq -0x58(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0x13fbd
movq 0x1e00f(%rip), %rdi     # 0x31fb8
leaq 0xd876(%rip), %rsi      # 0x21826
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x88(%rbp), %rdi
callq 0xa6b6
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x13ffe
movq %rax, %rbx
jmp 0x14007
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xa6b6
leaq -0x20(%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/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
leaq -0x88(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x38(%rbp), %rbx
pushq $0x5
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x14fea
leaq -0x88(%rbp), %rdi
callq 0xa2ca
movq -0x18(%rbp), %rsi
subq -0x20(%rbp), %rsi
sarq $0x2, %rsi
movq 0x1df49(%rip), %rdi     # 0x31fb8
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x88(%rbp), %rdi
callq 0x14a28
movq 0x1df29(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x88(%rbp), %rdi
callq 0xa6b6
leaq -0x20(%rbp), %rdi
callq 0xa746
leaq -0x38(%rbp), %rdi
callq 0xa746
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x140e0
movq %rax, %rbx
jmp 0x140e9
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xa6b6
leaq -0x20(%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/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
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %eax, %eax
leaq -0x28(%rbp), %r14
movl %eax, -0x28(%rbp)
cmpl $0x64, %eax
jge 0x14134
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x28(%rbp), %eax
incl %eax
jmp 0x1411a
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14fea
movq -0x20(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1de69(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x20(%rbp), %rax
movl $0x2a, -0x4(%rax)
movq 0x1de4a(%rip), %rdi     # 0x31fb8
pushq $0x2a
popq %rsi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa746
leaq -0x40(%rbp), %rdi
callq 0xa746
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x141a9
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
jmp 0x141ac
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/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 %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
callq 0xa2ca
xorl %eax, %eax
leaq -0x24(%rbp), %r14
movl $0x200, %r12d           # imm = 0x200
movq 0x1ddcd(%rip), %r15     # 0x31fb8
movl %eax, -0x24(%rbp)
cmpl $0x5, %eax
jge 0x1422d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x151c8
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x14213
movq -0x30(%rbp), %rax
movq -0x8(%rax), %rax
addq %r12, %rax
movl -0x4(%rax), %esi
movq %r15, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movl -0x24(%rbp), %eax
incl %eax
jmp 0x141eb
movq 0x1dd84(%rip), %rdi     # 0x31fb8
leaq 0xd5f1(%rip), %rsi      # 0x2182c
callq 0x31d0
movl $0x200, %r15d           # imm = 0x200
movq 0x1dd6b(%rip), %rbx     # 0x31fb8
leaq -0x78(%rbp), %r14
movq -0x48(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x14289
cmpq -0x40(%rbp), %rax
jne 0x1426c
movq -0x30(%rbp), %rax
movq -0x8(%rax), %rax
addq %r15, %rax
movl -0x4(%rax), %esi
movq %rbx, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x153c4
jmp 0x14251
leaq -0x78(%rbp), %rdi
callq 0xa6b6
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x142a3
jmp 0x142a3
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xa6b6
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/stack/test_stack.cpp
// Function: test_stack_relational_operators()
void
test_stack_relational_operators()
{
	ft::stack<int, ft::vector<int> > stack1;
	ft::stack<int, ft::vector<int> > stack2;

	for (int i = 0; i < 10; i++) stack1.push(i);
	for (int i = 0; i < 5; i++) stack2.push(i);

	std::cout << (stack1 == stack2) << std::endl;
	std::cout << (stack1 != stack2) << std::endl;
	std::cout << (stack1 < stack2) << std::endl;
	std::cout << (stack1 <= stack2) << std::endl;
	std::cout << (stack1 > stack2) << std::endl;
	std::cout << (stack1 >= stack2) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
andq $0x0, -0x20(%rbp)
movaps %xmm0, (%rbx)
movaps %xmm0, -0x30(%rbp)
xorl %eax, %eax
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x142fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x142e0
xorl %eax, %eax
leaq -0x30(%rbp), %rbx
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0x5, %eax
jge 0x1431e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x14304
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15424
movzbl %al, %esi
movq 0x1dc83(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146df
movzbl %al, %esi
movq 0x1dc5f(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1549f
movzbl %al, %esi
movq 0x1dc3b(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146ec
movzbl %al, %esi
movq 0x1dc17(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1549f
movzbl %al, %esi
movq 0x1dbf3(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14702
movzbl %al, %esi
movq 0x1dbcf(%rip), %rdi     # 0x31fb8
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
leaq -0x50(%rbp), %rdi
callq 0xa746
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14415
jmp 0x14415
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
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/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 %rbx
subq $0xc8, %rsp
leaq 0xd3ff(%rip), %rsi      # 0x21844
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x6c0(%rip), %rdi      # 0x13d9c
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0xd3dc(%rip), %rsi      # 0x21857
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x563(%rip), %rdi      # 0x13f2f
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0xd3b2(%rip), %rsi      # 0x21863
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x4b0(%rip), %rdi      # 0x14018
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0xd387(%rip), %rsi      # 0x2186e
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x401(%rip), %rdi      # 0x140fa
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0xd364(%rip), %rsi      # 0x21878
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x36b(%rip), %rdi      # 0x141bd
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0xd348(%rip), %rsi      # 0x21889
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x29e(%rip), %rdi      # 0x142b7
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x145b8
jmp 0x145bf
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x145b8
jmp 0x145bf
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x145b8
jmp 0x145bf
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x145b8
jmp 0x145bf
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x145b8
jmp 0x145bf
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x30d0
jmp 0x145c2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_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
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 0x1553a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x15520
movq 0x1ca77(%rip), %rdi     # 0x31fb8
leaq 0xcf95(%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 0x15569
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_reverse_iterators.cpp
// Function: test_vector_reverse_iterators_operator_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
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 0x155b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1559d
movq -0x28(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1c9f3(%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 0x155e6
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330