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

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);
	}
	print_vec_info(vec);

	std::cout << vec[2] << std::endl;
	vec[2] = 42;
	std::cout << vec[2] << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x1e6fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1e6e4
leaq -0x30(%rbp), %rdi
callq 0x16817
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x138a3(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
movq -0x30(%rbp), %rax
movl $0x2a, 0x8(%rax)
movq 0x13884(%rip), %rdi     # 0x31fb8
pushq $0x2a
popq %rsi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1e758
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_element_access.cpp
// Function: test_vector_element_access_at()
void
test_vector_element_access_at()
{
	ft::vector<int> vec;

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);
	}
	print_vec_info(vec);

	std::cout << vec.at(2) << std::endl;
	vec.at(2) = 42;
	std::cout << vec.at(2) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x1e865
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146ba
movl -0x14(%rbp), %eax
incl %eax
jmp 0x1e84b
leaq -0x30(%rbp), %rdi
callq 0x16817
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x1ee48
movl (%rax), %esi
movq 0x13735(%rip), %rdi     # 0x31fb8
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x1ee48
movl $0x2a, (%rax)
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x1ee48
movl (%rax), %esi
movq 0x13701(%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 0x1e8d8
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_element_access.cpp
// Function: test_vector_element_access_front()
void
test_vector_element_access_front()
{
	ft::vector<int> vec(10, 10);
	print_vec_info(vec);

	vec.front() = 42;
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0xa, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0xa
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
movq (%rdi), %rax
movl $0x2a, (%rax)
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_back()
void
test_vector_element_access_back()
{
	ft::vector<int> vec(10, 10);
	print_vec_info(vec);

	vec.back() = 42;
	print_vec_info(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0xa, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0xa
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rax
movl $0x2a, -0x4(%rax)
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/vector/test_vector_element_access.cpp
// Function: test_vector_element_access_front_back_mix()
void
test_vector_element_access_front_back_mix()
{
	ft::vector<int> myvector;

	myvector.push_back(78);
	myvector.push_back(16);

	myvector.front() -= myvector.back();

	std::cout << "myvector.front() is now " << myvector.front() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x30(%rbp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq -0xc(%rbp), %rsi
movl $0x4e, (%rsi)
callq 0x160d0
leaq -0xc(%rbp), %rsi
movl $0x10, (%rsi)
leaq -0x30(%rbp), %rdi
callq 0x160d0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x4(%rcx), %ecx
subl %ecx, (%rax)
movq 0x134cc(%rip), %rdi     # 0x31fb8
leaq 0x36dd(%rip), %rsi      # 0x221d0
callq 0x31d0
movq -0x30(%rbp), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1eb22
jmp 0x1eb22
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_element_access.cpp
// Function: test_vector_element_access_data()
void
test_vector_element_access_data()
{
	ft::vector<int> myvector(5);

	print_vec_info(myvector);

	int* p = myvector.data();

	*p = 10;
	++p;
	*p = 20;
	p[2] = 100;

	print_vec_info(myvector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
pushq $0x5
popq %rsi
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x1ee8c
movq %rbx, %rdi
callq 0x16817
leaq -0x28(%rbp), %rdi
movq (%rdi), %rax
movabsq $0x140000000a, %rcx     # imm = 0x140000000A
movq %rcx, (%rax)
movl $0x64, 0xc(%rax)
callq 0x16817
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1eb8c
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_less.cpp
// Function: test_less()
void test_less()
{
	int foo[]={10, 20, 5, 15, 25};
	int bar[]={15, 10, 20};
	std::sort(foo, foo + 5, ft::less<int>());  // 5 10 15 20 25
	std::sort(bar, bar + 3, ft::less<int>());  //   10 15 20
	if (std::includes (foo, foo + 5, bar, bar + 3, ft::less<int>()))
		std::cout << "foo includes bar." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movaps 0x331a(%rip), %xmm0     # 0x22250
leaq -0x3c(%rbp), %rbx
movaps %xmm0, -0x14(%rbx)
movl $0x19, -0x4(%rbx)
movabsq $0xa0000000f, %rax      # imm = 0xA0000000F
leaq -0x24(%rbp), %r14
movq %rax, -0xc(%r14)
movl $0x14, -0x4(%r14)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1efba
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1efba
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1f40a
testb %al, %al
je 0x1efad
movq 0x1301f(%rip), %rdi     # 0x31fb8
leaq 0x32d0(%rip), %rsi      # 0x22270
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_constructors()
void
test_pair_constructors()
{
	ft::pair<std::string, double> product1;
	ft::pair<std::string, double> product2("tomatoes", 2.30);
	ft::pair<std::string, double> product3(product2);

	product2.first = "shoes";
	product2.second = 39.90;

	std::cout << "The price of " << product1.first << " is $" << product1.second << std::endl;
	std::cout << "The price of " << product2.first << " is $" << product2.second << std::endl;
	std::cout << "The price of " << product3.first << " is $" << product3.second << std::endl;

	{
		ft::pair<std::string, double> cpy1 = product1;
		ft::pair<std::string, double> cpy2 = product2;
		ft::pair<std::string, double> cpy3 = product3;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xf8, %rsp
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andq $0x0, 0x10(%rax)
movabsq $0x4002666666666666, %rax # imm = 0x4002666666666666
leaq -0x58(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x2e09(%rip), %rsi      # 0x22282
leaq -0x30(%rbp), %rdi
callq 0x1fa18
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fa46
leaq 0x2df5(%rip), %rsi      # 0x2228b
leaq -0x30(%rbp), %rdi
callq 0x3340
movabsq $0x4043f33333333333, %rax # imm = 0x4043F33333333333
movq %rax, -0x10(%rbp)
movq 0x12b04(%rip), %rdi     # 0x31fb8
leaq 0x2dd6(%rip), %rsi      # 0x22291
callq 0x31d0
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x2dcc(%rip), %rsi      # 0x2229f
movq %rax, %rdi
callq 0x31d0
movsd -0x60(%rbp), %xmm0
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x30e0
movq 0x12ac1(%rip), %rdi     # 0x31fb8
leaq 0x2d93(%rip), %rsi      # 0x22291
callq 0x31d0
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x2d89(%rip), %rsi      # 0x2229f
movq %rax, %rdi
callq 0x31d0
movsd -0x10(%rbp), %xmm0
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x30e0
movq 0x12a7e(%rip), %rdi     # 0x31fb8
leaq 0x2d50(%rip), %rsi      # 0x22291
callq 0x31d0
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x2d46(%rip), %rsi      # 0x2229f
movq %rax, %rdi
callq 0x31d0
movsd -0x38(%rbp), %xmm0
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x30e0
leaq -0xd0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1fa46
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fa46
leaq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1fa46
leaq -0xf8(%rbp), %rdi
callq 0x30d0
leaq -0xa8(%rbp), %rdi
callq 0x30d0
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq -0x58(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x80(%rbp), %rdi
callq 0x30d0
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x30d0
jmp 0x1f603
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x30d0
jmp 0x1f620
jmp 0x1f61d
movq %rax, %rbx
jmp 0x1f629
movq %rax, %rbx
jmp 0x1f632
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x80(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_assignement_overload()
void
test_pair_assignement_overload()
{
	ft::pair<std::string, int> planet, homeplanet;

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

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

	homeplanet = planet;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
leaq 0x2c27(%rip), %rsi      # 0x222a5
leaq -0x30(%rbp), %rdi
callq 0x3340
movl $0x18e3, -0x10(%rbp)    # imm = 0x18E3
movq 0x12923(%rip), %rdi     # 0x31fb8
leaq 0x2c0f(%rip), %rsi      # 0x222ab
callq 0x31d0
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x128fc(%rip), %rdi     # 0x31fb8
leaq 0x2bf1(%rip), %rsi      # 0x222b4
callq 0x31d0
movl -0x10(%rbp), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fa68
movq 0x128c9(%rip), %rdi     # 0x31fb8
leaq 0x2bcc(%rip), %rsi      # 0x222c2
callq 0x31d0
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30e0
movq 0x128a2(%rip), %rdi     # 0x31fb8
leaq 0x2bb3(%rip), %rsi      # 0x222d0
callq 0x31d0
movl -0x38(%rbp), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fa8a
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1fa8a
leaq -0xa8(%rbp), %rdi
callq 0x30d0
leaq -0x80(%rbp), %rdi
callq 0x30d0
leaq -0x58(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x30d0
jmp 0x1f796
jmp 0x1f793
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_relational_operators()
void
test_pair_relational_operators()
{
	ft::pair<int, char> foo(10, 'z');
	ft::pair<int, char> bar(90, 'a');

	if (foo == bar) std::cout << "foo and bar are equal" << std::endl;
	if (foo != bar) std::cout << "foo and bar are not equal" << std::endl;
	if (foo < bar) std::cout << "foo is less than bar" << std::endl;
	if (foo > bar) std::cout << "foo is greater than bar" << std::endl;
	if (foo <= bar) std::cout << "foo is less than or equal to bar" << std::endl;
	if (foo >= bar) std::cout << "foo is greater than or equal to bar" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq -0x28(%rbp), %rbx
movl $0xa, (%rbx)
movb $0x7a, 0x4(%rbx)
leaq -0x20(%rbp), %r14
movl $0x5a, (%r14)
movb $0x61, 0x4(%r14)
movq 0x127d6(%rip), %r15     # 0x31fb8
leaq 0x1c4f(%rip), %rsi      # 0x21438
movq %r15, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq 0x1c52(%rip), %rsi      # 0x21452
movq %r15, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fac7
testb %al, %al
je 0x1f83a
movq 0x12792(%rip), %rdi     # 0x31fb8
leaq 0x1c52(%rip), %rsi      # 0x2147f
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1fadd
testb %al, %al
je 0x1f866
movq 0x12766(%rip), %rdi     # 0x31fb8
leaq 0x1c47(%rip), %rsi      # 0x214a0
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair_make_pair()
void
test_pair_make_pair()
{
	ft::pair<int, int> foo;
	ft::pair<int, int> bar;

	foo = ft::make_pair(10, 20);
	bar = ft::make_pair(10.5, 'A');

	std::cout << "foo: " << foo.first << ", " << foo.second << std::endl;
	std::cout << "bar: " << bar.first << ", " << bar.second << std::endl;

	{
		ft::pair<int, int> cpy1 = foo;
		(void)cpy1;
		ft::pair<int, int> cpy2 = bar;
		(void)cpy2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x12736(%rip), %rbx     # 0x31fb8
leaq 0x2a5a(%rip), %rsi      # 0x222e3
movq %rbx, %rdi
callq 0x31d0
pushq $0xa
popq %r14
movq %rax, %rdi
movl %r14d, %esi
callq 0x3320
leaq 0x2a42(%rip), %r15      # 0x222e9
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
pushq $0x14
popq %rsi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq 0x2a20(%rip), %rsi      # 0x222ec
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x3320
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
pushq $0x41
popq %rsi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_pair.cpp
// Function: test_pair()
void
test_pair()
{
	test_wrapper(test_pair_constructors, "constructors");
	test_wrapper(test_pair_assignement_overload, "assignement overload");
	test_wrapper(test_pair_relational_operators, "relational operators");
	test_wrapper(test_pair_make_pair, "make_pair");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
leaq 0x1f30(%rip), %rsi      # 0x2184a
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x4f1(%rip), %rdi      # 0x1f440
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x29a2(%rip), %rsi      # 0x222f2
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x321(%rip), %rdi      # 0x1f643
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x298a(%rip), %rsi      # 0x22307
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x1e1(%rip), %rdi      # 0x1f7b0
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x2ab9(%rip), %rsi      # 0x22463
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x14d(%rip), %rdi      # 0x1f871
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x1fa05
jmp 0x1fa0c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x1fa05
jmp 0x1fa0c
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x1fa05
jmp 0x1fa0c
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x30d0
jmp 0x1fa0f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_equal.cpp
// Function: test_equal()
void
test_equal()
{
	int myints[] = {20, 40, 60, 80, 100};
	ft::vector<int> myvector(myints, myints + 5);

	// using default comparison:
	if (ft::equal(myvector.begin(), myvector.end(), myints))
		std::cout << "The contents of both sequences are equal." << std::endl;
	else
		std::cout << "The contents of both sequences differ." << std::endl;

	myvector[3] = 81;

	// using predicate comparison:
	if (std::equal (myvector.begin(), myvector.end(), myints, mypredicate))
		std::cout << "The contents of both sequences are equal." << std::endl;
	else
		std::cout << "The contents of both sequences differ." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movaps 0x2817(%rip), %xmm0     # 0x22320
leaq -0x3c(%rbp), %rdx
movaps %xmm0, -0x14(%rdx)
movl $0x64, -0x4(%rdx)
leaq -0x30(%rbp), %rbx
leaq -0x50(%rbp), %r14
leaq -0x11(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fbd2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x15454
leaq 0x27ef(%rip), %rbx      # 0x22334
leaq 0x2812(%rip), %r14      # 0x2235e
testb %al, %al
movq %r14, %rsi
cmovneq %rbx, %rsi
movq 0x1245c(%rip), %rdi     # 0x31fb8
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
movq -0x30(%rbp), %rax
movl $0x51, 0xc(%rax)
xorl %ecx, %ecx
movq -0x28(%rbp), %rdx
leaq (%rax,%rcx), %rsi
cmpq %rdx, %rsi
je 0x1fb94
movl (%rsi), %esi
cmpl -0x50(%rbp,%rcx), %esi
jne 0x1fb91
addq $0x4, %rcx
jmp 0x1fb7a
movq %r14, %rbx
movq 0x1241d(%rip), %rdi     # 0x31fb8
movq %rbx, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0xa746
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_distance.cpp
// Function: test_distance()
void
test_distance()
{
	ft::vector<int> vec(5, 42);

	std::cout << vec.end() - vec.begin() << std::endl;
	std::cout <<
		ft::distance<ft::vector<int>::iterator>(vec.begin(), vec.end())
		<< std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x10(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x28(%rbp), %rbx
pushq $0x5
popq %rsi
leaq -0x9(%rbp), %rcx
movq %rbx, %rdi
callq 0x1465a
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq 0x12320(%rip), %rdi     # 0x31fb8
callq 0x31b0
movq %rax, %rdi
callq 0x30e0
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
sarq $0x2, %rsi
movq 0x12300(%rip), %rdi     # 0x31fb8
callq 0x31b0
movq %rax, %rdi
callq 0x30e0
leaq -0x28(%rbp), %rdi
callq 0xa746
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1fcd7
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa746
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_lexicographical_compare.cpp
// Function: test_lexicographical_compare()
void
test_lexicographical_compare()
{
    char foo[] = "Apple";
    char bar[] = "apartment";

    std::cout << std::boolalpha;

    std::cout << "Comparing foo and bar lexicographically (foo < bar):" << std::endl;

    std::cout << "Using default comparison (operator<): ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9);
    std::cout << std::endl;

    std::cout << "Using mycomp as comparison object: ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9, mycomp);
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x2b(%rbp), %r14
movw $0x65, -0x1(%r14)
movl $0x6c707041, -0x5(%r14) # imm = 0x6C707041
movabsq $0x6e656d7472617061, %rax # imm = 0x6E656D7472617061
leaq -0x37(%rbp), %r15
movq %rax, -0x9(%r15)
movw $0x74, -0x1(%r15)
movq 0x12265(%rip), %rbx     # 0x31fb8
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%rbx,%rax)
leaq 0x262f(%rip), %rsi      # 0x22395
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq 0x264d(%rip), %rsi      # 0x223ca
movq %rbx, %rdi
callq 0x31d0
leaq -0x30(%rbp), %r12
leaq -0x40(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x1fdfa
movzbl %al, %esi
movq %rbx, %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x30e0
leaq 0x2639(%rip), %rsi      # 0x223f1
movq %rbx, %rdi
callq 0x31d0
leaq -0xdb(%rip), %r8        # 0x1fcec
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x1fe43
movzbl %al, %esi
movq %rbx, %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x30e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_others.cpp
// Function: test_others()
void
test_others()
{
	test_wrapper(test_distance, "distance");
	test_wrapper(test_is_const, "is_const");
	test_wrapper(test_is_integral, "is_integral");
	test_wrapper(test_iterator_traits, "iterator_traits");
	test_wrapper(test_lexicographical_compare, "lexicographical_compare");
	test_wrapper(test_equal, "equal");
	subsection_wrapper(test_pair, "pair && make_pair");
	test_wrapper(test_less, "less");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x2546(%rip), %rsi      # 0x22415
leaq -0x110(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x286(%rip), %rdi      # 0x1fc60
leaq -0x110(%rbp), %rsi
callq 0x20ca4
leaq -0x110(%rbp), %rdi
callq 0x30d0
leaq 0x2519(%rip), %rsi      # 0x2241e
leaq -0xf0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0xbe4(%rip), %rdi       # 0x20b00
leaq -0xf0(%rbp), %rsi
callq 0x20ca4
leaq -0xf0(%rbp), %rdi
callq 0x30d0
leaq 0x24ec(%rip), %rsi      # 0x22427
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x3ca(%rip), %rdi       # 0x2031c
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x24c2(%rip), %rsi      # 0x22433
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x154(%rip), %rdi       # 0x200dc
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x249c(%rip), %rsi      # 0x22443
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x2af(%rip), %rdi      # 0x1fd0f
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x1455(%rip), %rsi      # 0x21432
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x4fa(%rip), %rdi      # 0x1faf7
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x2451(%rip), %rsi      # 0x2245b
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x717(%rip), %rdi      # 0x1f907
leaq -0x50(%rbp), %rsi
callq 0x20c00
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x2436(%rip), %rsi      # 0x2246d
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x112b(%rip), %rdi     # 0x1ef20
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 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
jmp 0x200ca
jmp 0x200d1
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x30d0
jmp 0x200d4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_iterator_traits.cpp
// Function: void test_single_iterator_traits<std::iterator_traits<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>, long, int, int*, int&, std::random_access_iterator_tag>()
void
test_single_iterator_traits()
{
	if (!(typeid(typename it::difference_type) == typeid(diff_type))) {
		std::cout << "difference_type invalid" << std::endl;
	} else if (!(typeid(typename it::value_type) == typeid(value_types))) {
		std::cout << "value_type invalid" << std::endl;
	} else if (!(typeid(typename it::pointer) == typeid(ptr))) {
		std::cout << "pointer invalid" << std::endl;
	} else if (!(typeid(typename it::reference) == typeid(ref))) {
		std::cout << "reference invalid" << std::endl;
	} else if (!(typeid(typename it::iterator_category) == typeid(cat))) {
		std::cout << "iterator_category invalid" << std::endl;
	} else {
		std::cout << "all valid" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x11ecd(%rip), %rdi     # 0x31fc8
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x20165
movq 0x11e82(%rip), %rdi     # 0x31f90
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x2016e
movq 0x11e87(%rip), %rdi     # 0x31fa8
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x20177
movq 0x11e5c(%rip), %rdi     # 0x31f90
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x20180
leaq 0x11be1(%rip), %rdi     # 0x31d28
movq %rdi, %rsi
callq 0x202f4
leaq 0x2383(%rip), %rcx      # 0x224d9
leaq 0x2362(%rip), %rsi      # 0x224bf
testb %al, %al
cmovneq %rcx, %rsi
jmp 0x20187
leaq 0x2306(%rip), %rsi      # 0x22472
jmp 0x20187
leaq 0x2315(%rip), %rsi      # 0x2248a
jmp 0x20187
leaq 0x231f(%rip), %rsi      # 0x2249d
jmp 0x20187
leaq 0x2326(%rip), %rsi      # 0x224ad
movq 0x11e2a(%rip), %rdi     # 0x31fb8
callq 0x31d0
movq %rax, %rdi
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_is_integral.cpp
// Function: void test_single_is_integral<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
test_single_is_integral(std::string const& type_tested)
{
	int value = ft::is_integral<T>::value;
	typedef typename ft::is_integral<T>::value_type value_type;
	typedef typename ft::is_integral<T>::type type;

	if (value
			&& typeid(value_type) == typeid(bool)
			&& typeid(type) == typeid(ft::true_type)
			&& ft::is_integral<T>() == value)
	{
		std::cout << type_tested << " is integral" << std::endl;
	}
	else
	{
		std::cout << type_tested << " is not integral" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x119e8(%rip), %rdi     # 0x31fb0
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x205f0
leaq 0x11795(%rip), %rdi     # 0x31d70
movq %rdi, %rsi
callq 0x202f4
testb %al, %al
je 0x205f0
leaq 0x204b(%rip), %r14      # 0x22639
jmp 0x205f7
leaq 0x204f(%rip), %r14      # 0x22646
movq 0x119ba(%rip), %rdi     # 0x31fb8
movq %rbx, %rsi
callq 0x3190
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/others/test_is_const.cpp
// Function: test_is_const()
void
test_is_const()
{
	std::cout << ft::is_const<int>::value << std::endl
		<< ft::is_const<int const>::value << std::endl
		<< ft::is_const<char>::value << std::endl
		<< ft::is_const<char const>::value << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x114ab(%rip), %rdi     # 0x31fb8
xorl %esi, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
pushq $0x1
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3310
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: section_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
section_wrapper(void f(), std::string section_name)
{
	std::cout << "====== test_" << section_name << " ======" << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x11448(%rip), %rdi     # 0x31fb8
leaq 0x1afd(%rip), %rsi      # 0x22674
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3190
leaq 0x1af3(%rip), %rsi      # 0x22681
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq *%r14
movq 0x11410(%rip), %rdi     # 0x31fb8
popq %rbx
popq %r14
popq %rbp
jmp 0x30e0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x20bf0
movq %rbx, %rdi
callq 0x30b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x113e7(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq 0x3300
jmp 0x20ba1
movq %rax, %rbx
callq 0x3300
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x41f4
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: subsection_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
subsection_wrapper(void f(), std::string subsection_name)
{
	std::cout << "*** test_" << subsection_name << " ***" << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x113a4(%rip), %rdi     # 0x31fb8
leaq 0x1a6e(%rip), %rsi      # 0x22689
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3190
leaq 0x8ee(%rip), %rsi       # 0x21520
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq *%r14
movq 0x1136c(%rip), %rdi     # 0x31fb8
popq %rbx
popq %r14
popq %rbp
jmp 0x30e0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x20c94
movq %rbx, %rdi
callq 0x30b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x11343(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq 0x3300
jmp 0x20c45
movq %rax, %rbx
callq 0x3300
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x41f4
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/utils/test_wrappers.cpp
// Function: test_wrapper(void (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
test_wrapper(void f(), std::string test_name)
{
	std::cout << "# test_" << test_name << ": " << std::endl;

	try
	{
		f();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x11300(%rip), %rdi     # 0x31fb8
leaq 0x19d4(%rip), %rsi      # 0x22693
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3190
leaq 0x1718(%rip), %rsi      # 0x223ee
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq *%r14
movq 0x112c8(%rip), %rdi     # 0x31fb8
popq %rbx
popq %r14
popq %rbp
jmp 0x30e0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x20d38
movq %rbx, %rdi
callq 0x30b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x1129f(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
callq 0x3300
jmp 0x20ce9
movq %rax, %rbx
callq 0x3300
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x41f4
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/leb128.cpp
// Function: leb128_encode(std::vector<unsigned long, std::allocator<unsigned long>> const&)
vector<uint8_t> leb128_encode(const vector<uint64_t> &in) {
  vector<uint8_t> out;
  for (auto x : in) {
    while (x > 127) {
      out.push_back(x | 0x80);
      x >>= 7;
    }
    out.push_back(x);
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
leaq 0x7(%rsp), %r14
leaq 0x6(%rsp), %r15
cmpq %r13, %r12
je 0x1317
movq (%r12), %rbp
cmpq $0x80, %rbp
jb 0x1301
movl %ebp, %eax
orb $-0x80, %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13b8
shrq $0x7, %rbp
jmp 0x12df
movb %bpl, 0x6(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13b8
addq $0x8, %r12
jmp 0x12d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x132b
movq %rax, %r14
movq %rbx, %rdi
callq 0x138c
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/leb128.cpp
// Function: leb128_decode(unsigned char const*, unsigned long*, unsigned long)
void leb128_decode(const uint8_t *in, uint64_t *out, size_t count) {
  while (count-- > 0) {
    uint8_t byte = *in++;
    if (LIKELY(byte < 128)) {
      *out++ = byte;
      continue;
    }
    uint64_t value = byte & 0x7f;
    unsigned shift = 7;
    do {
      byte = *in++;
      value |= uint64_t(byte & 0x7f) << shift;
      shift += 7;
    } while (byte >= 128);
    *out++ = value;
  }
}

// Assembly:
pushq $0x7
popq %rax
subq $0x1, %rdx
jb 0x1380
movsbq (%rdi), %r8
incq %rdi
testq %r8, %r8
js 0x135c
movq %r8, (%rsi)
addq $0x8, %rsi
jmp 0x1341
andl $0x7f, %r8d
movl %eax, %ecx
movzbl (%rdi), %r9d
movl %r9d, %r10d
andl $0x7f, %r10d
shlq %cl, %r10
incq %rdi
orq %r10, %r8
addl $0x7, %ecx
testb %r9b, %r9b
js 0x1362
jmp 0x1353
retq
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/lesqlite.cpp
// Function: lesqlite_encode(std::vector<unsigned long, std::allocator<unsigned long>> const&)
vector<uint8_t> lesqlite_encode(const vector<uint64_t> &in) {
  vector<uint8_t> out;
  for (auto x : in) {
    if (x < cut1) {
      // 1 byte.
      out.push_back(x);
    } else if (x <= cut1 + 255 + 256 * (cut2 - 1 - cut1)) {
      // 2 bytes.
      x -= cut1;
      out.push_back(cut1 + (x >> 8));
      out.push_back(x & 0xff);
    } else {
      // 3-9 bytes.
      unsigned bits = 64 - count_leading_zeros_64(x);
      unsigned bytes = (bits + 7) / 8;
      out.push_back(cut2 + (bytes - 2));
      for (unsigned n = 0; n < bytes; n++) {
        out.push_back(x & 0xff);
        x >>= 8;
      }
    }
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x3(%rsp), %rbp
cmpq %r12, %r15
je 0x15e0
movq (%r15), %r13
cmpq $0xb8, %r13
ja 0x155e
movb %r13b, 0x7(%rsp)
movq %rbx, %rdi
leaq 0x7(%rsp), %rsi
callq 0x13b8
jmp 0x1599
cmpq $0x40b8, %r13           # imm = 0x40B8
ja 0x159f
addq $-0xb9, %r13
movl %r13d, %eax
shrl $0x8, %eax
addb $-0x47, %al
movb %al, 0x6(%rsp)
movq %rbx, %rdi
leaq 0x6(%rsp), %rsi
callq 0x13b8
movb %r13b, 0x5(%rsp)
movq %rbx, %rdi
leaq 0x5(%rsp), %rsi
callq 0x13b8
addq $0x8, %r15
jmp 0x1535
bsrq %r13, %r14
xorl $-0x40, %r14d
addl $0x48, %r14d
shrl $0x3, %r14d
leal -0x9(%r14), %eax
movb %al, 0x4(%rsp)
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x13b8
subl $0x1, %r14d
jb 0x1599
movb %r13b, 0x3(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x13b8
shrq $0x8, %r13
jmp 0x15c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15fa
jmp 0x15fa
jmp 0x15fa
jmp 0x15fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x138c
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/lesqlite.cpp
// Function: lesqlite_decode(unsigned char const*, unsigned long*, unsigned long)
void lesqlite_decode(const uint8_t *in, uint64_t *out, size_t count) {
  while (count-- > 0) {
    uint8_t b0 = *in++;
    if (LIKELY(b0 < cut1)) {
      *out++ = b0;
    } else if (b0 < cut2) {
      uint8_t b1 = *in++;
      *out++ = cut1 + b1 + ((b0 - cut1) << 8);
    } else {
      size_t sh = b0 - cut2;
      *out++ = unaligned_load_u64(in) & ((uint64_t(1) << 8 * sh << 16) - 1);
      in += 2 + sh;
    }
  }
}

// Assembly:
xorl %eax, %eax
cmpq %rax, %rdx
je 0x167b
leaq 0x1(%rdi), %r8
movzbl (%rdi), %ecx
cmpl $0xb8, %ecx
ja 0x162f
movq %rcx, (%rsi,%rax,8)
incq %rax
movq %r8, %rdi
jmp 0x160f
cmpb $-0x8, %cl
ja 0x1652
movzbl 0x1(%rdi), %r8d
addq $0x2, %rdi
shll $0x8, %ecx
addl %r8d, %ecx
addl $0xffff47b9, %ecx       # imm = 0xFFFF47B9
movq %rcx, (%rsi,%rax,8)
movq %rdi, %r8
jmp 0x1627
leal -0xf9(%rcx), %edi
leal -0x7c8(,%rcx,8), %ecx
movl $0x10000, %r9d          # imm = 0x10000
shlq %cl, %r9
decq %r9
andq (%r8), %r9
movq %r9, (%rsi,%rax,8)
addq %rdi, %r8
addq $0x2, %r8
jmp 0x1627
retq
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/lesqlite2.cpp
// Function: lesqlite2_encode(std::vector<unsigned long, std::allocator<unsigned long>> const&)
vector<uint8_t> lesqlite2_encode(const vector<uint64_t> &in) {
  vector<uint8_t> out;
  for (auto x : in) {
    if (x < cut1) {
      // 1 byte.
      out.push_back(x);
    } else if (x < limit1) {
      // 2 bytes encode 14 bits.
      x -= offset1;
      out.push_back(cut1 + (x >> 8));
      out.push_back(x & 0xff);
    } else if (x < limit2) {
      // 3 bytes encode 19 bits.
      x -= offset2;
      out.push_back(cut2 + (x >> 16));
      // Next 2 bytes in little-endian.
      out.push_back(x & 0xff);
      x >>= 8;
      out.push_back(x & 0xff);
    } else {
      // 4-9 bytes, no offset.
      unsigned bits = 64 - count_leading_zeros_64(x);
      unsigned bytes = (bits + 7) / 8;
      out.push_back(cut3 + (bytes - 3));
      for (unsigned n = 0; n < bytes; n++) {
        out.push_back(x & 0xff);
        x >>= 8;
      }
    }
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rbp
movq 0x8(%rsi), %r15
movq %rsp, %r13
cmpq %r15, %rbp
je 0x1798
movq (%rbp), %rbx
cmpq $0xb1, %rbx
ja 0x16cb
movb %bl, 0x7(%rsp)
movq %r12, %rdi
leaq 0x7(%rsp), %rsi
callq 0x13b8
jmp 0x1750
cmpq $0x40b1, %rbx           # imm = 0x40B1
ja 0x1706
addq $-0xb2, %rbx
movl %ebx, %eax
shrl $0x8, %eax
addb $-0x4e, %al
movb %al, 0x6(%rsp)
movq %r12, %rdi
leaq 0x6(%rsp), %rsi
callq 0x13b8
movb %bl, 0x5(%rsp)
movq %r12, %rdi
leaq 0x5(%rsp), %rsi
callq 0x13b8
jmp 0x1750
cmpq $0x840b1, %rbx          # imm = 0x840B1
ja 0x1759
addq $-0x40b2, %rbx          # imm = 0xBF4E
movl %ebx, %eax
shrl $0x10, %eax
addb $-0xe, %al
movb %al, 0x4(%rsp)
movq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x13b8
movb %bl, 0x3(%rsp)
movq %r12, %rdi
leaq 0x3(%rsp), %rsi
callq 0x13b8
movb %bh, 0x2(%rsp)
movq %r12, %rdi
leaq 0x2(%rsp), %rsi
callq 0x13b8
addq $0x8, %rbp
jmp 0x169f
bsrq %rbx, %r14
xorl $-0x40, %r14d
addl $0x48, %r14d
shrl $0x3, %r14d
leal -0x9(%r14), %eax
movb %al, 0x1(%rsp)
movq %r12, %rdi
leaq 0x1(%rsp), %rsi
callq 0x13b8
subl $0x1, %r14d
jb 0x1750
movb %bl, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x13b8
shrq $0x8, %rbx
jmp 0x177e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17b8
jmp 0x17b8
jmp 0x17b8
jmp 0x17b8
jmp 0x17b8
jmp 0x17b8
jmp 0x17b8
movq %rax, %r14
movq %r12, %rdi
callq 0x138c
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/lesqlite2.cpp
// Function: lesqlite2_decode(unsigned char const*, unsigned long*, unsigned long)
void lesqlite2_decode(const uint8_t *in, uint64_t *out, size_t count) {
  while (count-- > 0) {
    uint8_t b0 = *in++;
    if (LIKELY(b0 < cut1)) {
      *out++ = b0;
    } else if (b0 < cut2) {
      b0 -= cut1;
      uint8_t b1 = *in++;
      *out++ = offset1 + b1 + (b0 << 8);
    } else if (b0 < cut3) {
      b0 -= cut2;
      *out++ = offset2 + unaligned_load_u16(in) + (b0 << 16);
      in += 2;
    } else {
      b0 -= cut3;
      *out++ = unaligned_load_u64(in) & ((uint64_t(1) << 8 * b0 << 24) - 1);
      in += 3 + b0;
    }
  }
}

// Assembly:
xorl %eax, %eax
cmpq %rax, %rdx
je 0x186a
leaq 0x1(%rdi), %r8
movzbl (%rdi), %ecx
cmpq $0xb1, %rcx
ja 0x17f2
movq %rcx, (%rsi,%rax,8)
incq %rax
movq %r8, %rdi
jmp 0x17cd
cmpb $-0xf, %cl
ja 0x1819
addb $0x4e, %cl
movzbl 0x1(%rdi), %r8d
addq $0x2, %rdi
movzbl %cl, %ecx
shll $0x8, %ecx
addq %r8, %rcx
addq $0xb2, %rcx
movq %rcx, (%rsi,%rax,8)
jmp 0x183e
cmpb $-0x7, %cl
ja 0x1843
addb $0xe, %cl
movzwl 0x1(%rdi), %r8d
movzbl %cl, %ecx
shll $0x10, %ecx
addq %r8, %rcx
addq $0x40b2, %rcx           # imm = 0x40B2
movq %rcx, (%rsi,%rax,8)
addq $0x3, %rdi
movq %rdi, %r8
jmp 0x17ea
addb $0x6, %cl
movzbl %cl, %edi
movl %edi, %ecx
shll $0x3, %ecx
movl $0x1000000, %r9d        # imm = 0x1000000
shlq %cl, %r9
decq %r9
andq (%r8), %r9
movq %r9, (%rsi,%rax,8)
addq %rdi, %r8
addq $0x3, %r8
jmp 0x17ea
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/prefix_varint.cpp
// Function: prefix_encode(std::vector<unsigned long, std::allocator<unsigned long>> const&)
vector<uint8_t> prefix_encode(const vector<uint64_t> &in) {
  vector<uint8_t> out;
  for (auto x : in) {
    unsigned bits = 64 - count_leading_zeros_64(x | 1);
    unsigned bytes = 1 + (bits - 1) / 7;
    if (bits > 56) {
      out.push_back(0);
      bytes = 8;
    } else {
      x = (2 * x + 1) << (bytes - 1);
    }
    for (unsigned n = 0; n < bytes; n++) {
      out.push_back(x & 0xff);
      x >>= 8;
    }
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
leaq 0x6(%rsp), %r15
cmpq %r13, %r12
je 0x1903
movq (%r12), %rbp
movq %rbp, %rax
shrq $0x38, %rax
je 0x18bb
movb $0x0, 0x7(%rsp)
movq %rbx, %rdi
leaq 0x7(%rsp), %rsi
callq 0x13b8
pushq $0x8
popq %r14
jmp 0x18f7
movq %rbp, %rax
orq $0x1, %rax
bsrq %rax, %rax
movzbl %al, %eax
movb $0x7, %cl
divb %cl
leal 0x1(%rax), %ecx
movzbl %cl, %r14d
leaq 0x1(,%rbp,2), %rbp
movl %eax, %ecx
shlq %cl, %rbp
jmp 0x18f7
movb %bpl, 0x6(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13b8
shrq $0x8, %rbp
subl $0x1, %r14d
jae 0x18e3
addq $0x8, %r12
jmp 0x1891
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1917
movq %rax, %r14
movq %rbx, %rdi
callq 0x138c
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/prefix_varint.cpp
// Function: prefix_decode(unsigned char const*, unsigned long*, unsigned long)
void prefix_decode(const uint8_t *in, uint64_t *out, size_t count) {
  while (count-- > 0) {
    if (LIKELY(*in & 1)) {
      *out++ = *in++ >> 1;
    } else {
      size_t length = prefix_length(in);
      *out++ = prefix_get(in, length);
      in += length;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x1977
movzbl (%r15), %eax
testb $0x1, %al
je 0x195a
incq %r15
shrl %eax
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x193f
orl $0x100, %eax            # imm = 0x100
bsfl %eax, %r13d
leaq 0x1(%r13), %rsi
movq %r15, %rdi
callq 0x1981
addq %r13, %r15
incq %r15
jmp 0x1951
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/prefix_varint.cpp
// Function: prefix_get(unsigned char const*, unsigned long)
inline uint64_t prefix_get(const uint8_t *p, size_t length) {
  if (length < 9) {
    size_t unused = 64 - 8 * length;
    return unaligned_load_u64(p) << unused >> (unused + length);
  } else {
    return unaligned_load_u64(p + 1);
  }
}

// Assembly:
cmpq $0x8, %rsi
ja 0x19a6
leaq (,%rsi,8), %rcx
pushq $0x40
popq %rdx
subq %rcx, %rdx
movq (%rdi), %rax
negq %rcx
shlq %cl, %rax
addl %edx, %esi
movl %esi, %ecx
shrq %cl, %rax
retq
movq 0x1(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/varint.cpp
// Function: gen_log_uniform()
vector<uint64_t> gen_log_uniform() {

  // How many uint64_t numbers in the vector we're compressing.
  const size_t N = 100000;

  // Maximum significant bits in the log-uniform random numbers.
  const unsigned random_bits = 64;

  default_random_engine gen;
  uniform_real_distribution<double> dist(0.0, random_bits * log(2));
  vector<uint64_t> vec;

  vec.reserve(N);
  while (vec.size() < N)
    vec.push_back(exp(dist(gen)));
  return vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $0x1, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x1677(%rip), %xmm1     # xmm1 = xmm1[0,1],mem[0,1]
movaps %xmm1, 0x10(%rsp)
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0x186a0, %esi          # imm = 0x186A0
callq 0x1ec4
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0xc34ff, %rax          # imm = 0xC34FF
ja 0x1a45
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f5a
callq 0x1180
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x162b(%rip), %xmm0     # 0x3050
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21b6
jmp 0x19f6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1a56
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ffc
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/ledbit[P]varint/varint.cpp
// Function: read_test_vector(char const*)
vector<uint64_t> read_test_vector(const char *filename) {
  FILE *f = fopen(filename, "r");
  if (!f) {
    perror(filename);
    exit(1);
  }

  vector<uint64_t> vec;
  while (!feof(f)) {
    uint64_t val;
    int rc = fscanf(f, "%" SCNu64 "\n", &val);
    if (rc == 1) {
      vec.push_back(val);
    } else if (rc == EOF) {
      if (ferror(f)) {
        perror(filename);
        exit(1);
      } else {
        break;
      }
    }
  }
  return vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1615(%rip), %rsi      # 0x3098
movq %r14, %rdi
callq 0x1130
testq %rax, %rax
je 0x1afc
movq %rax, %r15
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x15f5(%rip), %r12      # 0x309a
leaq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0x1150
testl %eax, %eax
jne 0x1aeb
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1190
cmpl $0x1, %eax
je 0x1ad2
cmpl $-0x1, %eax
jne 0x1aaa
jmp 0x1adf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1f62
jmp 0x1aaa
movq %r15, %rdi
callq 0x11a0
testl %eax, %eax
jne 0x1afc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1140
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ffc
movq %r14, %rdi
callq 0x1170