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

	mymap['x'] = 1001;
	mymap['y'] = 2002;
	mymap['z'] = 3003;

	std::cout << "mymap contains:\n";

	ft::pair<char, int> highest = *mymap.rbegin();          // last element

	ft::map<char, int>::iterator it = mymap.begin();
	do {
		std::cout << " [" << it->first << "] = " << it->second;
	} while ( mymap.value_comp()(*it++, highest) );
	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), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x29(%rbp), %rsi
movb $0x78, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xce98
movl $0x3e9, (%rax)          # imm = 0x3E9
leaq -0x29(%rbp), %rsi
movb $0x79, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xce98
movl $0x7d2, (%rax)          # imm = 0x7D2
leaq -0x29(%rbp), %rsi
movb $0x7a, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xce98
movl $0xbbb, (%rax)          # imm = 0xBBB
movq 0x20838(%rip), %rdi     # 0x33fd0
leaq 0x130a2(%rip), %rsi     # 0x26841
movl $0x10, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x2220
movb 0x20(%rax), %r12b
movq -0x48(%rbp), %r14
movq 0x20810(%rip), %rbx     # 0x33fd0
leaq 0x12e73(%rip), %r13     # 0x2663a
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x12e61(%rip), %rsi     # 0x26637
callq 0x2230
movb 0x20(%r14), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2230
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movl 0x24(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %r14, %rdi
callq 0x2160
cmpb %r12b, 0x20(%r14)
movq %rax, %r14
jl 0x137c7
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2078f(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xcf00
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13870
jmp 0x13870
jmp 0x13870
jmp 0x13870
jmp 0x13870
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x78(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x2054f(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r12d
leaq -0x80(%rbp), %r14
leaq -0x50(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r12, %rax
movq %rax, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x12fac
incq %r12
cmpq $0x7b, %r12
jne 0x13ca6
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x14612
leaq -0x80(%rbp), %rdi
callq 0xcd41
leaq -0x50(%rbp), %rdi
callq 0xcd41
leaq -0x50(%rbp), %rdi
callq 0xcf00
leaq -0x80(%rbp), %rdi
callq 0xcf00
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d43
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xcf00
jmp 0x13d46
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x98, %rsp
leaq -0x40(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x20456(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r15d
leaq -0x48(%rbp), %rbx
leaq -0x78(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x78(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12fac
incq %r15
cmpq $0x7b, %r15
jne 0x13d9f
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14a66
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14a66
leaq -0x48(%rbp), %rdi
callq 0xcd41
leaq -0x78(%rbp), %rdi
callq 0xcd41
leaq -0xa8(%rbp), %rdi
callq 0xcd41
leaq -0xa8(%rbp), %rdi
callq 0xcf00
leaq -0x78(%rbp), %rdi
callq 0xcf00
leaq -0x48(%rbp), %rdi
callq 0xcf00
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13e68
jmp 0x13e73
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0xcf00
leaq -0x78(%rbp), %rdi
callq 0xcf00
jmp 0x13e76
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x2031f(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x70(%rbp), %r13
movb $0x61, %bl
leaq -0x48(%rbp), %r12
leaq -0xb8(%rbp), %r14
leaq -0x88(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
leaq -0x58(%rbp), %rdi
callq 0x42cc
movb %bl, -0x88(%rbp)
movq %r13, -0x80(%rbp)
movq -0x58(%rbp), %rax
cmpq %r12, %rax
je 0x13f36
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x13f40
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %r12, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x14fc6
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x13f71
callq 0x21b0
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x13f7f
callq 0x21b0
incb %bl
cmpb $0x7b, %bl
jne 0x13ee0
leaq -0x88(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x14c0a
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x14c0a
leaq -0xb8(%rbp), %rdi
callq 0x1465b
leaq -0x88(%rbp), %rdi
callq 0x1465b
leaq -0x58(%rbp), %rdi
callq 0x1465b
leaq -0x58(%rbp), %rdi
callq 0xfb68
leaq -0x88(%rbp), %rdi
callq 0xfb68
leaq -0xb8(%rbp), %rdi
callq 0xfb68
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14014
jmp 0x14022
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xfb68
leaq -0x88(%rbp), %rdi
callq 0xfb68
jmp 0x14046
movq %rax, %rbx
jmp 0x14046
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x14038
callq 0x21b0
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x14046
callq 0x21b0
leaq -0xb8(%rbp), %rdi
callq 0xfb68
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x20156(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x61, %r15d
leaq -0x50(%rbp), %rbx
leaq -0x20(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0xc, %ecx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
shlq $0x20, %rax
addq %r15, %rax
movq %rax, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x150c4
incq %r15
cmpq $0x7b, %r15
jne 0x1409f
leaq -0x50(%rbp), %rdi
callq 0x147b5
leaq -0x50(%rbp), %rdi
callq 0x14e2a
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1410a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x14e2a
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x2008b(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
leaq -0x60(%rbp), %r13
movb $0x61, %bl
leaq -0x38(%rbp), %r12
leaq -0xa0(%rbp), %r14
leaq -0x70(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
leaq -0x48(%rbp), %rdi
callq 0x42cc
movq %r13, -0x70(%rbp)
movq -0x48(%rbp), %rax
cmpq %r12, %rax
je 0x141c1
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x141cb
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %r12, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movb %bl, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x15214
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x141ff
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1420d
callq 0x21b0
incb %bl
cmpb $0x7b, %bl
jne 0x14171
leaq -0xa0(%rbp), %rdi
callq 0x1490b
leaq -0xa0(%rbp), %rdi
callq 0x14e82
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14241
movq %rax, %rbx
jmp 0x14265
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x14257
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x14265
callq 0x21b0
leaq -0xa0(%rbp), %rdi
callq 0x14e82
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x38(%rbp), %rsi
movb $0x61, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xce98
movl $0xa, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x62, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xce98
movl $0x1e, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x63, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xce98
movl $0x32, (%rax)
leaq -0x38(%rbp), %rsi
movb $0x64, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0xce98
movl $0x46, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x14612
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14a66
leaq -0xc0(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x71b(%rip), %rax      # 0x13c20
leaq -0x90(%rbp), %rdx
movq %rax, -0x8(%rdx)
movl %ecx, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rcx, 0x20(%rdx)
leaq -0x98(%rbp), %rdi
callq 0x14f16
leaq -0xc8(%rbp), %rdi
callq 0x14f6e
leaq -0xf8(%rbp), %rdi
callq 0xcf00
leaq -0x38(%rbp), %rdi
callq 0xcf00
leaq -0x68(%rbp), %rdi
callq 0xcf00
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xcf00
jmp 0x143b1
jmp 0x143ae
jmp 0x143ae
jmp 0x143ae
jmp 0x143ae
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xcf00
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe114
addq %r13, %r15
decq %r12
jne 0x1545f
movq 0x1eb53(%rip), %rbx     # 0x33fd0
leaq 0x12012(%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 0x1eb21(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe0bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x154d6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe0bc
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe114
addq %r13, %r15
decq %r12
jne 0x15539
movq -0x48(%rbp), %r14
movq 0x1ea75(%rip), %rdi     # 0x33fd0
leaq 0x110d6(%rip), %rsi     # 0x26638
movl $0x1, %edx
callq 0x2230
movl 0x20(%r14), %esi
movq 0x1ea59(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
leaq 0x110b4(%rip), %rsi     # 0x2663a
movl $0x4, %edx
movq %rax, %rdi
callq 0x2230
movb 0x24(%r14), %al
leaq -0x30(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2230
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 -0x60(%rbp), %rdi
callq 0xe0bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x155ee
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe0bc
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe114
addq %r13, %r15
decq %r12
jne 0x15651
movq -0x48(%rbp), %r14
movq 0x1e95d(%rip), %rdi     # 0x33fd0
leaq 0x10fc8(%rip), %rsi     # 0x26642
movl $0x4, %edx
callq 0x2230
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
je 0x156fd
movq 0x1e93c(%rip), %r15     # 0x33fd0
leaq 0x10f9f(%rip), %r13     # 0x2663a
leaq -0x30(%rbp), %rbx
movl $0x2, %edx
movq %r15, %rdi
leaq 0x10f89(%rip), %rsi     # 0x26637
callq 0x2230
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movb 0x24(%r14), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
jne 0x1569f
movq 0x1e8cc(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e8b1(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe0bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15748
jmp 0x15748
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe0bc
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movabsq $0x3000000030, %r15     # imm = 0x3000000030
movl $0xa, %r12d
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe114
addq %r13, %r15
decq %r12
jne 0x157ab
movq -0x48(%rbp), %r13
movq %r13, %r12
leaq -0x58(%rbp), %rax
cmpq %rax, %r13
je 0x15840
movq 0x1e7f7(%rip), %r14     # 0x33fd0
movq %r13, %rbx
movl $0x2, %edx
movq %r14, %rdi
leaq 0x10e4c(%rip), %rsi     # 0x26637
callq 0x2230
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0x10e2d(%rip), %rsi     # 0x2663a
callq 0x2230
movq %rbx, %rdi
callq 0x2160
movq %rax, %r12
movb 0x24(%rbx), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2230
movq %r12, %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %r12
jne 0x157dc
movq 0x1e789(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e76e(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r13, %r12
je 0x158dd
movq 0x1e755(%rip), %r15     # 0x33fd0
leaq -0x30(%rbp), %r14
movl $0x2, %edx
movq %r15, %rdi
leaq 0x10da9(%rip), %rsi     # 0x26637
callq 0x2230
movq %r12, %rdi
callq 0x2220
movq %rax, %r12
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0x10d7f(%rip), %rsi     # 0x2663a
callq 0x2230
movb 0x24(%r12), %al
movb %al, -0x30(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
cmpq %r13, %r12
jne 0x1587f
movq 0x1e6ec(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e6d1(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xe0bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1592c
jmp 0x1592c
jmp 0x1592c
jmp 0x1592c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xe0bc
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x68(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x38(%rbp), %r14
movl %ecx, (%r14)
movq %rcx, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rcx, 0x20(%r14)
movq 0x1e64f(%rip), %rbx     # 0x33fd0
leaq 0x107a7(%rip), %rsi     # 0x2612f
movl $0x7, %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 0x1e61d(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq %r14, -0x28(%rbp)
jne 0x15a0c
movq 0x1e603(%rip), %rbx     # 0x33fd0
leaq 0x1075b(%rip), %rsi     # 0x2612f
movl $0x7, %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 0x1e5d1(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x40(%rbp), %rdi
callq 0xaeae
leaq -0x70(%rbp), %rdi
callq 0xaeae
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xaeae
leaq -0x70(%rbp), %rdi
callq 0xaeae
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e767(%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 0xb3c2
incq %r15
cmpq $0x64, %r15
jne 0x15a88
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15b3e
movq 0x1e4ed(%rip), %r14     # 0x33fd0
leaq 0x10b4d(%rip), %r15     # 0x26637
leaq 0x10b49(%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 0x15af1
movq 0x1e48b(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e470(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaeae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15b89
jmp 0x15b89
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaeae
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e60e(%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 0xb3c2
incq %r15
cmpq $0x64, %r15
jne 0x15be1
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15c97
movq 0x1e394(%rip), %r14     # 0x33fd0
leaq 0x109f4(%rip), %r15     # 0x26637
leaq 0x109f0(%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 0x15c4a
movq 0x1e332(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e317(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaeae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15ce2
jmp 0x15ce2
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaeae
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e4b5(%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 0xb3c2
incq %r15
cmpq $0xa, %r15
jne 0x15d3a
movq -0x48(%rbp), %rbx
leaq -0x58(%rbp), %rax
cmpq %rax, %rbx
je 0x15df0
movq 0x1e23b(%rip), %r14     # 0x33fd0
leaq 0x1089b(%rip), %r15     # 0x26637
leaq 0x10897(%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 0x15da3
movq 0x1e1d9(%rip), %rdi     # 0x33fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x1e1be(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0xaeae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15e3b
jmp 0x15e3b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xaeae
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16f40
movl %r14d, (%rbx)
leaq -0x48(%rbp), %rbx
leaq -0xd0(%rbp), %rdx
leaq -0x120(%rbp), %rcx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x16fa0
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x8, %edi
callq 0x2200
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
xorl %edx, %edx
movl $0xc8, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x8, %rdx
jne 0x1617f
movq %rcx, -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 0xaf62
leaq -0x120(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x170a2
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 0xaf62
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x174e8
leaq -0x78(%rbp), %r15
leaq -0x48(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x17568
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x16228
movq (%rdi), %rbx
callq 0x21b0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x16218
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x16236
callq 0x21b0
leaq -0x1c0(%rbp), %rdi
callq 0xaf14
leaq -0x120(%rbp), %rdi
callq 0xaf14
leaq -0xd0(%rbp), %rdi
callq 0xaf14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x16268
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x16281
movq (%rdi), %rbx
callq 0x21b0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x16271
leaq -0x170(%rbp), %rdi
callq 0xaf14
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 0x162b1
callq 0x21b0
jmp 0x162b1
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0xaf14
jmp 0x162c2
movq %rax, %r14
leaq -0x120(%rbp), %rdi
callq 0xaf14
jmp 0x162d3
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0xaf14
jmp 0x162e4
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x162f7
callq 0x21b0
jmp 0x162f7
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x16315
movq (%rdi), %r15
callq 0x21b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x16300
jmp 0x16315
movq %rax, %r14
leaq -0x170(%rbp), %rdi
callq 0xaf14
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x14, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x16363
leaq -0x20(%rbp), %rsi
movq %rcx, 0x8(%rsi)
leaq -0x38(%rbp), %rdi
callq 0x174e8
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 0xaf62
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x163f9
movq 0x1dc16(%rip), %rbx     # 0x33fd0
leaq 0x10493(%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 0x1dbe4(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x60(%rbp), %rax
cmpq -0x80(%rbp), %rax
jne 0x16449
movq 0x1dbc6(%rip), %rbx     # 0x33fd0
leaq 0x10443(%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 0x1db94(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x90(%rbp), %rdi
callq 0xaf14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x16463
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x16471
callq 0x21b0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x16494
movq %rax, %rbx
jmp 0x164a2
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xaf14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x164a2
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x164b0
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x14, %edi
callq 0x2200
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x10(%rbp)
xorl %edx, %edx
movl $0x2a, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x14, %rdx
jne 0x164f2
leaq -0x20(%rbp), %rsi
movq %rcx, 0x8(%rsi)
leaq -0x38(%rbp), %rdi
callq 0x174e8
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 0xaf62
movq -0x30(%rbp), %rsi
subq -0x38(%rbp), %rsi
sarq $0x2, %rsi
movq 0x1da85(%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 0x1da16(%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 0xaf14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x16603
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x16611
callq 0x21b0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x16634
movq %rax, %rbx
jmp 0x16642
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xaf14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x16642
callq 0x21b0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x16650
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16698
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x166a3
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x28(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x63, %ecx
jl 0x16682
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x174e8
movq -0x20(%rbp), %rax
movl -0x4(%rax), %esi
movq 0x1d904(%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 0x1d8c3(%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 0x1674f
callq 0x21b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1675d
callq 0x21b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1677b
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x1677e
callq 0x21b0
jmp 0x1677e
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1678c
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaf62
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
movl $0x200, %r13d           # imm = 0x200
movq 0x1d7ec(%rip), %r15     # 0x33fd0
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x16802
movl %r12d, (%rax)
addq $0x4, %rax
movq %rax, -0x50(%rbp)
jmp 0x1680d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17724
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x16822
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 0x167e4
movq 0x1d75e(%rip), %rdi     # 0x33fd0
leaq 0xffe1(%rip), %rsi      # 0x2685a
movl $0x17, %edx
callq 0x2230
movq -0x50(%rbp), %rax
cmpq -0x70(%rbp), %rax
je 0x1692f
movl $0x200, %r15d           # imm = 0x200
movq 0x1d732(%rip), %rbx     # 0x33fd0
cmpq -0x48(%rbp), %rax
jne 0x168af
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 0x168f7
addq $-0x4, %rax
jmp 0x16921
callq 0x21b0
movq -0x38(%rbp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x48(%rbp)
leaq 0x200(%rax), %rcx
movq %rcx, -0x40(%rbp)
addq $0x1fc, %rax            # imm = 0x1FC
movq %rax, -0x50(%rbp)
cmpq -0x70(%rbp), %rax
jne 0x1689e
leaq -0x80(%rbp), %rdi
callq 0xaf14
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1694b
jmp 0x1694b
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xaf14
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfb0d(%rip), %rsi      # 0x26872
leaq 0xfb18(%rip), %rdx      # 0x26884
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0xc8e(%rip), %rdi      # 0x160f4
movq %rbx, %rsi
callq 0x25e66
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x16d9b
callq 0x21b0
leaq -0xa0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfad8(%rip), %rsi      # 0x26885
leaq 0xfadc(%rip), %rdx      # 0x26890
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0xaa1(%rip), %rdi      # 0x16329
movq %rbx, %rsi
callq 0x25e66
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
je 0x16de3
callq 0x21b0
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfa9f(%rip), %rsi      # 0x26891
leaq 0xfaa2(%rip), %rdx      # 0x2689b
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x957(%rip), %rdi      # 0x164b8
movq %rbx, %rsi
callq 0x25e66
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x16e28
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfa65(%rip), %rsi      # 0x2689c
leaq 0xfa67(%rip), %rdx      # 0x268a5
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x7f9(%rip), %rdi      # 0x16658
movq %rbx, %rsi
callq 0x25e66
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x16e67
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfa30(%rip), %rsi      # 0x268a6
leaq 0xfa39(%rip), %rdx      # 0x268b6
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x6fc(%rip), %rdi      # 0x16794
movq %rbx, %rsi
callq 0x25e66
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x16ea6
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfa02(%rip), %rsi      # 0x268b7
leaq 0xfa15(%rip), %rdx      # 0x268d1
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x570(%rip), %rdi      # 0x1695f
movq %rbx, %rsi
callq 0x25e66
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x16ee5
callq 0x21b0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x16f2e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x16f2e
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0x16f2e
movq %rax, %rbx
movq -0x90(%rbp), %rdi
jmp 0x16f2e
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
jmp 0x16f2e
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x16f38
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17970
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x1797b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1760a
movl -0x14(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %ecx
jl 0x1795a
movq 0x1c640(%rip), %rbx     # 0x33fd0
leaq 0xfaff(%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 0x1c60e(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x179dd
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x179e8
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x179f9
callq 0x21b0
movq %rbx, %rdi
callq 0x2340