LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/task/task.cpp
// Function: Task::logStr[abi:cxx11]()
std::string Task::logStr() {
  std::string str;
  str += "[task] ";
  str += "id:" + std::to_string(id);
  str += ",start:" + std::to_string(startTime);
  str += ",end:" + std::to_string(endTime);
  str += ",service time:" + std::to_string(endTime - startTime);
  str += ",nodes:";
  for (auto v : G_CLOSE) str += std::to_string(v->getId()) + ",";
  str += "\n";
  return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x502d(%rip), %rsi      # 0x3e3d2
callq 0x66a0
movl 0x30(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x943e
leaq 0x2100(%rip), %rsi      # 0x3b4bf
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movl 0x34(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x943e
leaq 0x4fd6(%rip), %rsi      # 0x3e3da
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movl 0x38(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x943e
leaq 0x4f99(%rip), %rsi      # 0x3e3e2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movl 0x38(%r14), %esi
subl 0x34(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x943e
leaq 0x4f56(%rip), %rsi      # 0x3e3e8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x4f2e(%rip), %rsi      # 0x3e3f7
movq %rbx, %rdi
callq 0x66a0
movq 0x18(%r14), %r13
movq 0x20(%r14), %rbp
leaq 0x8(%rsp), %r14
leaq 0x1feb(%rip), %r15      # 0x3b4d0
leaq 0x28(%rsp), %r12
cmpq %rbp, %r13
je 0x3952c
movq (%r13), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0x943e
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x93fb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x66c0
movq %r12, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x61d0
addq $0x8, %r13
jmp 0x394ea
leaq 0x1030(%rip), %rsi      # 0x3a563
movq %rbx, %rdi
callq 0x66a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39571
jmp 0x3956c
jmp 0x39567
jmp 0x39571
jmp 0x3956c
jmp 0x39567
jmp 0x39571
jmp 0x3956c
jmp 0x39567
jmp 0x39571
jmp 0x3956c
jmp 0x39567
jmp 0x39567
movq %rax, %r14
jmp 0x39588
movq %rax, %r14
jmp 0x3957e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: print(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void print(const Vec<string>& svec)
{
	// c++11 Vec iterator
	for (auto it : svec)
		cout << it << " " ;
	cout <<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %r13
leaq -0x48(%rbp), %r14
movq 0x2d01(%rip), %r15      # 0x3fd0
leaq 0xd32(%rip), %r12       # 0x2008
cmpq %r13, %rbx
je 0x130a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1110
movq %r15, %rdi
movq %r14, %rsi
callq 0x10b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x10c0
movq %r14, %rdi
callq 0x1060
addq $0x20, %rbx
jmp 0x12d6
movq 0x2cbf(%rip), %rdi      # 0x3fd0
callq 0x1070
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: getVec[abi:cxx11](std::istream&)
Vec<string> getVec(istream& is)
{
	Vec<string> svec;
	string s;
	while (is >> s)
		svec.push_back(s);
	return svec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb $0x0, (%rax)
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1391
movq %rbx, %rdi
movq %r15, %rsi
callq 0x154e
jmp 0x136b
leaq -0x38(%rbp), %rdi
callq 0x1060
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x1578
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	Vec<string> svec = getVec(cin);
	print(svec);

	cout << "copy " << svec.size() << endl;
	auto svec2 = svec;
	print(svec2);

	cout << "assign" << endl;
	Vec<string> svec3;
	svec3 = svec2;
	print(svec3);

	Vec<string> v1, v2;
	Vec<string> getVec(istream &);
	v1 = v2;           // copy assignment
	v2 = getVec(cin);  // move assignment

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq 0x2c07(%rip), %rsi      # 0x3fe0
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x1339
movq %rbx, %rdi
callq 0x12ac
movq 0x2bdc(%rip), %rdi      # 0x3fd0
leaq 0xc09(%rip), %rsi       # 0x2004
callq 0x10c0
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1070
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x158c
leaq -0x40(%rbp), %rdi
callq 0x12ac
movq 0x2b97(%rip), %rdi      # 0x3fd0
leaq 0xbca(%rip), %rsi       # 0x200a
callq 0x10c0
movq %rax, %rdi
callq 0x1070
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x40(%rbp), %rsi
callq 0x15c2
leaq -0x60(%rbp), %rdi
callq 0x12ac
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x80(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x15c2
movq 0x2b48(%rip), %rsi      # 0x3fe0
leaq -0xb8(%rbp), %rdi
callq 0x1339
leaq -0x80(%rbp), %rbx
leaq -0xb8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1606
movq %r14, %rdi
callq 0x1578
movq %rbx, %rdi
callq 0x1578
leaq -0xa0(%rbp), %rdi
callq 0x1578
leaq -0x60(%rbp), %rdi
callq 0x1578
leaq -0x40(%rbp), %rdi
callq 0x1578
leaq -0x28(%rbp), %rdi
callq 0x1578
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1501
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x1578
leaq -0xa0(%rbp), %rdi
callq 0x1578
jmp 0x1520
jmp 0x1539
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x1578
jmp 0x152e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1578
jmp 0x153c
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1578
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Vec(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
inline Vec<T>::Vec(const Vec& s)
{
	// call copy to allocate exactly as many elements as in s
	auto newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x17a6
movq %rax, (%rbx)
movq %rdx, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
inline Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
	// call copy to allocate exactly as many elements as in rhs
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x17a6
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0x1660
movq %r14, (%rbx)
movq %r15, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&)
inline Vec<T>& Vec<T>::operator=(Vec&& rhs) noexcept
{
	// direct test for self-assignment
	if (this != &rhs)
		free();  // free existing elements if appropriate

	elements = rhs.elements;  // take over resources from rhs
	first_free = rhs.first_free;
	cap = rhs.cap;

	// leave rhs in a destructible state
	rhs.elements = rhs.first_free = rhs.cap = nullptr;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1620
movq %rbx, %rdi
callq 0x1660
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x1652
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::free()
inline void Vec<T>::free()
{
	// destroy the old elements in reverse order
	for (auto p = first_free; p != elements; /* empty */)
		alloc.destroy(--p);  // destroy elements in reverse order

	// deallocate cannot be called on a 0 pointer
	if (elements)
		alloc.deallocate(elements, cap - elements);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %r14
movq (%rbx), %rdi
cmpq %rdi, %r14
je 0x168e
addq $-0x20, %r14
movq %r14, %rdi
callq 0x1060
addq $-0x20, %r15
jmp 0x1674
testq %r14, %r14
je 0x16a9
movq 0x10(%rbx), %rsi
subq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reallocate()
inline void Vec<T>::reallocate()
{
	// we'll allocate space for twice as many elements as current size
	auto newcapacity = size() ? 2 * size() : 2;

	// allocate new space
	auto first = alloc.allocate(newcapacity);
	auto dest = first;
	auto elem = elements;

	// move the elements
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free();  // free the old space once we've moved the elements

	// update our data structure point to the new elements
	elements = first;
	first_free = dest;
	cap = elements + newcapacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rcx, %rax
pushq $0x2
popq %rsi
cmovneq %rdx, %rsi
leaq 0x29ca(%rip), %rdi      # 0x40ca
xorl %r13d, %r13d
movq %rsi, -0x38(%rbp)
xorl %edx, %edx
callq 0x177c
movq %rax, %r12
movq (%rbx), %rax
movq %r12, -0x30(%rbp)
movq %rax, %rsi
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rcx, %r13
je 0x174a
leaq 0x20(%r12), %r15
leaq 0x20(%rsi), %r14
movq %r12, %rdi
callq 0x1100
incq %r13
movq (%rbx), %rax
movq %r15, %r12
movq %r14, %rsi
jmp 0x171b
movq %rbx, %rdi
callq 0x1660
movq -0x30(%rbp), %rcx
movq %rcx, (%rbx)
movq %r12, 0x8(%rbx)
movq -0x38(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::operator*((anonymous namespace)::Matrix<float> const&) const
constexpr Matrix operator*(const Matrix& matrix) const noexcept
        {
            Matrix temp;
            for (auto i = 0; i < 4; ++i)
                for (auto j = 0; j < 4; ++j)
                    for (auto k = 0; k < 4; ++k)
                        *(temp.data + i * 4 + j) += *(data + i * 4 + k) * *(matrix.data + k * 4 + j);

            return temp;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2ed4
movq %rcx, %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %rdx, %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x2ecb
movss (%rdi,%r9,4), %xmm0
xorl %r10d, %r10d
cmpq $0x10, %r10
je 0x2ebc
movss (%rsi,%r10), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
jmp 0x2ea0
movss %xmm0, (%rdi,%r9,4)
incq %r9
addq $0x4, %r8
jmp 0x2e91
incq %rcx
addq $0x10, %rsi
jmp 0x2e7b
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::operator*((anonymous namespace)::Matrix<float> const&, (anonymous namespace)::Vector<float> const&)
constexpr Vector operator*(const Matrix<T>& matrix, const Vector& vector) noexcept
        {
            Vector temp;
            for (auto i = 0; i < 4; ++i)
                *(temp.data + i) = matrix(i, 0) * *vector.data + matrix(i, 1) * *(vector.data + 1) +
                                                                 matrix(i, 2) * *(vector.data + 2) +
                                                                 matrix(i, 3) * *(vector.data + 3);
            return temp;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss 0x8(%rsi), %xmm2
movss 0xc(%rsi), %xmm3
xorl %eax, %eax
cmpq $0x10, %rax
je 0x4000
movss 0x4(%rdi,%rax,4), %xmm4
mulss %xmm1, %xmm4
movss (%rdi,%rax,4), %xmm5
mulss %xmm0, %xmm5
addss %xmm4, %xmm5
movss 0x8(%rdi,%rax,4), %xmm4
mulss %xmm2, %xmm4
addss %xmm5, %xmm4
movss 0xc(%rdi,%rax,4), %xmm5
mulss %xmm3, %xmm5
addss %xmm4, %xmm5
movss %xmm5, -0x10(%rbp,%rax)
addq $0x4, %rax
jmp 0x3fbb
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Joke-Shi[P]astrunc/sample/sample_zh.cc
// Function: main
int main( int argc, const char **argv)
{
    std::string s_zh = "Prometheus，它的价值在于可靠性，甚至在很恶劣的环境下，你都可以随时访问它和查"
                       "书名《恶搞》““ABC等。”“。””，《你好啊《是的》。是吗》，“不知道怎说才好”“哎！”"
                       "看系统服务各种指标的统计信息。 如果你对统计数据需要100%的精确，它并不适用，例"
                       "如：它不适用于实时计费系统。";

    std::vector< std::string> vec_s;
    int rc = astrunc::access::split( vec_s, s_zh, astrunc::access::ZH, 32);
    if ( 0 == rc) {
        for ( auto const &__s : vec_s) {
            std::cout << __s << std::endl;
            std::cout << "------------------------------------------------------------------\n";
        }
    } else { std::cerr << "[Error]: Split error\n"; }


    return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0xc17(%rip), %rsi       # 0x6320
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5800
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rsp, %rdi
pushq $0x46
popq %rdx
pushq $0x20
popq %rcx
movq %rbx, %rsi
callq 0x2f16
movl %eax, %ebx
testl %eax, %eax
je 0x5774
movq 0x38aa(%rip), %rdi      # 0x8ff0
leaq 0xda1(%rip), %rsi       # 0x64ee
callq 0x2120
movq %rsp, %rdi
callq 0x5872
leaq 0x20(%rsp), %rdi
callq 0x21e8
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rsp), %r14
movq 0x8(%rsp), %r13
movq 0x384c(%rip), %r15      # 0x8fd0
leaq 0xd1f(%rip), %r12       # 0x64aa
cmpq %r13, %r14
je 0x5752
movq %r15, %rdi
movq %r14, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
addq $0x20, %r14
jmp 0x578b
jmp 0x57b6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5872
leaq 0x20(%rsp), %rdi
callq 0x21e8
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/working-with-functors/main.cpp
// Function: main
int main() {
  // Producer and consumer thread pools.
  thread::pool::pool_t pool_of_consumers(5);

  // Counting the start time.
  auto start = std::chrono::high_resolution_clock::now();

  // Creating the callable.
  auto callable = thread::pool::bind(pool_of_consumers, static_void_function);

  // Scheduling the producers.
  for (size_t i = 0; i < work_to_spawn; ++i) {
    auto result = callable(i);
    assert(result.get() == (int) (i + 1));
  }
  
  // Waiting for the consumers to complete.
  while (count < work_to_spawn)
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

  // Measuring and dumping the elapsed time.
  auto end = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> diff = end - start;
  std::cout << "Elasped time : " << diff.count() << " ms" << std::endl;

  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e0, %rsp            # imm = 0x2E0
leaq 0x48(%rsp), %r15
pushq $0x5
popq %rsi
movq %r15, %rdi
callq 0x36e8
callq 0x3040
movq %rsp, %rbx
andq $0x0, 0x8(%rbx)
movq %rax, %r14
leaq -0x43(%rip), %rax       # 0x350c
movq %rax, (%rbx)
leaq 0x15ad(%rip), %rax      # 0x4b06
movq %rax, 0x18(%rbx)
leaq 0x15aa(%rip), %rax      # 0x4b0e
movq %rax, 0x10(%rbx)
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4b30
leaq 0x20(%rsp), %rbx
movq %r15, 0x20(%rbx)
movq %rsp, %r12
movq %r12, %rdi
callq 0x5400
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
cmpq $0x3e8, %r13            # imm = 0x3E8
je 0x35c9
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x37aa
movq %r12, %rdi
callq 0x37d2
leal 0x1(%r13), %ecx
cmpl %eax, %ecx
jne 0x365e
movq %r15, %rdi
callq 0x3898
incq %r13
jmp 0x3591
movq %rsp, %r15
movq 0x9c55(%rip), %rax      # 0xd228
cmpq $0x3e7, %rax            # imm = 0x3E7
ja 0x35ed
movq $0x64, (%rsp)
movq %r15, %rdi
callq 0x3803
jmp 0x35cc
callq 0x3040
movq %rax, %r15
movq 0x99bc(%rip), %rdi      # 0xcfb8
leaq 0x3a4f(%rip), %rsi      # 0x7052
callq 0x3250
subq %r14, %r15
cvtsi2sd %r15, %xmm0
divsd 0x39f0(%rip), %xmm0     # 0x7008
movq %rax, %rdi
callq 0x3320
leaq 0x3a3b(%rip), %rsi      # 0x7062
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3110
leaq 0x20(%rsp), %rdi
callq 0x5400
leaq 0x48(%rsp), %rdi
callq 0x3858
xorl %eax, %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x39bb(%rip), %rdi      # 0x7020
leaq 0x39d2(%rip), %rsi      # 0x703e
leaq 0x39d4(%rip), %rcx      # 0x7047
pushq $0x2a
popq %rdx
callq 0x3180
jmp 0x3681
jmp 0x3681
jmp 0x3681
movq %rax, %r14
jmp 0x3691
movq %rax, %r14
movq %r15, %rdi
callq 0x3898
movq %rbx, %rdi
callq 0x5400
leaq 0x48(%rsp), %rdi
callq 0x3858
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/example-test.cc
// Function: SimpleThing::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<kvtest::GetValue>&)
void get(std::string &key, kvtest::Callback<kvtest::GetValue> &cb) {
        std::map<std::string, std::string>::iterator it = storage.find(key);
        bool success = it != storage.end();
        kvtest::GetValue rv(success ? it->second : std::string(":("),
                            success);
        cb.callback(rv);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x3e00
movq %rax, %r15
addq $0x10, %r14
cmpq %r14, %rax
je 0x37aa
leaq 0x40(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x32f0
jmp 0x37c0
leaq 0x489e(%rip), %rsi      # 0x804f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3cf4
xorl %edx, %edx
cmpq %r14, %r15
setne %dl
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3dc6
leaq 0x8(%rsp), %rdi
callq 0x30d0
cmpq %r14, %r15
movq (%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x30d0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x382a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x382a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30d0
cmpq %r14, %r15
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/example-test.cc
// Function: SimpleThing::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void del(std::string &key, kvtest::Callback<bool> &cb) {
        bool rv = true;
        if(storage.find(key) == storage.end()) {
            rv = false;
        }
        storage.erase(key);
        cb.callback(rv);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movb $0x1, 0x7(%rsp)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x3e00
addq $0x10, %r12
cmpq %r12, %rax
jne 0x3862
movb $0x0, 0x7(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e3e
movq (%rbx), %rax
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/tests.cc
// Function: setup_alarm(int)
static void setup_alarm(int duration) {
    struct sigaction sig_handler;

    sig_handler.sa_handler = caught_alarm;
    sig_handler.sa_flags = 0;

    sigaction(SIGALRM, &sig_handler, NULL);

    alarmed = false;
    alarm(duration);
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movl %edi, %ebx
leaq 0x28e(%rip), %rax       # 0x4ab1
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x88(%rsi)
pushq $0xe
popq %rdi
xorl %edx, %edx
callq 0x32e0
movb $0x0, 0x8a00(%rip)      # 0xd243
movl %ebx, %edi
callq 0x3400
addq $0xa0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<kvtest::GetValue>::RememberingCallback()
RememberingCallback() {
            if(pthread_mutex_init(&mutex, NULL) != 0) {
                throw std::runtime_error("Failed to initialize mutex.");
            }
            if(pthread_cond_init(&cond, NULL) != 0) {
                throw std::runtime_error("Failed to initialize condition.");
            }
            fired = false;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7fdd(%rip), %rax      # 0xccc8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
addq $0x38, %rdi
xorl %esi, %esi
callq 0x3330
testl %eax, %eax
jne 0x4d27
leaq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x32b0
testl %eax, %eax
jne 0x4d43
movb $0x0, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %r14
leaq 0x34e1(%rip), %rsi      # 0x821a
movq %rax, %rdi
callq 0x30a0
jmp 0x4d5d
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %r14
leaq 0x34e1(%rip), %rsi      # 0x8236
movq %rax, %rdi
callq 0x30a0
movq 0x828c(%rip), %rsi      # 0xcff0
movq 0x824d(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33a0
jmp 0x4d75
movq %rax, %r15
movq %r14, %rdi
callq 0x31a0
jmp 0x4d85
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<bool>::waitForValue()
void waitForValue() {
            LockHolder lh(&mutex);
            if (!fired) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Failed to wait for condition.");
                }
            }
            assert(fired);
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x516e
movb 0x9(%rbx), %al
testb %al, %al
jne 0x4bdd
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x3340
testl %eax, %eax
jne 0x4c10
movb 0x9(%rbx), %al
testb $0x1, %al
je 0x4bf3
leaq 0x8(%rsp), %rdi
callq 0x51d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x348a(%rip), %rdi      # 0x8084
leaq 0x368f(%rip), %rsi      # 0x8290
leaq 0x3697(%rip), %rcx      # 0x829f
pushq $0x4d
popq %rdx
callq 0x3140
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x3650(%rip), %rsi      # 0x8272
movq %rax, %rdi
callq 0x30a0
movq 0x83bf(%rip), %rsi      # 0xcff0
movq 0x8380(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x33a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
jmp 0x4c50
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x51d4
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/./locks.hh
// Function: kvtest::LockHolder::LockHolder(pthread_mutex_t*)
LockHolder(pthread_mutex_t *m) {
            mutex = m;
            if(pthread_mutex_lock(mutex) != 0) {
                throw std::runtime_error("Failed to acquire lock.");
            }
            unlocked = false;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, %rdi
callq 0x3320
testl %eax, %eax
jne 0x5190
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x302c(%rip), %rsi      # 0x81ce
movq %rax, %rdi
callq 0x30a0
movq 0x7e3f(%rip), %rsi      # 0xcff0
movq 0x7e00(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x33a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<bool>::callback(bool&)
void callback(T &value) {
            LockHolder lh(&mutex);
            val = value;
            fired = true;
            if(pthread_cond_broadcast(&cond) != 0) {
                throw std::runtime_error("Failed to broadcast change.");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x516e
movb (%rbx), %al
movb %al, 0x8(%r14)
movb $0x1, 0x9(%r14)
addq $0x38, %r14
movq %r14, %rdi
callq 0x3080
testl %eax, %eax
jne 0x524a
leaq 0x8(%rsp), %rdi
callq 0x51d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x2ffa(%rip), %rsi      # 0x8256
movq %rax, %rdi
callq 0x30a0
movq 0x7d85(%rip), %rsi      # 0xcff0
movq 0x7d46(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x33a0
movq %rax, %r14
jmp 0x528a
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
leaq 0x8(%rsp), %rdi
callq 0x51d4
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/suite.cc
// Function: kvtest::TestSuite::initTests()
void TestSuite::initTests() {
    const char *req = getenv("KVTEST_SUITE");
    if (req == NULL || (strcmp(req, "full") == 0)) {
        addTest(new TestTest());
        addTest(new WriteTest());
    } else if (strcmp(req, "test") == 0) {
        addTest(new TestTest());
    } else if (strcmp(req, "endurance") == 0) {
        addTest(new EnduranceTest());
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x307c(%rip), %rdi      # 0x843a
callq 0x32c0
testq %rax, %rax
je 0x540c
movq %rax, %r14
leaq 0x3075(%rip), %rsi      # 0x8447
movq %rax, %rdi
callq 0x3300
testl %eax, %eax
je 0x540c
leaq 0x2e30(%rip), %rsi      # 0x8215
movq %r14, %rdi
callq 0x3300
testl %eax, %eax
je 0x5455
leaq 0x3054(%rip), %rsi      # 0x844c
movq %r14, %rdi
callq 0x3300
testl %eax, %eax
je 0x545e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x3250
leaq 0x76cd(%rip), %rcx      # 0xcae8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x549e
leaq 0x76fc(%rip), %r14      # 0xcb30
addq $0x10, %r14
pushq $0x8
popq %rdi
callq 0x3250
movq %r14, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x549e
leaq 0x768c(%rip), %r14      # 0xcae8
jmp 0x5434
leaq 0x7713(%rip), %r14      # 0xcb78
jmp 0x5434
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/suite.cc
// Function: kvtest::TestSuite::run()
bool TestSuite::run() {
    std::list<Test*>::iterator it;
    bool success = true;
    for (it=tests.begin() ; it != tests.end(); it++ ) {
        success = false;
        Test *t = *it;
        std::cout << "Running test ``" << *t << "'' ";
        try {
            tut->reset();
            t->run(tut);
            std::cout << "PASS" << std::endl;
            success = true;
        } catch(AssertionError &e) {
            std::cout << "FAIL: " << e.what() << std::endl;
        } catch(std::runtime_error &e) {
            std::cout << "EXCEPTION: " << e.what() << std::endl;
        } catch(...) {
            std::cout << "EXCEPTION (unknown)" << std::endl;
        }
    }
    return success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movb $0x1, %al
movq 0x7af9(%rip), %r14      # 0xcfc8
leaq 0x2f94(%rip), %r13      # 0x846a
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x55e7
movq 0x10(%r15), %rbp
movq %r14, %rdi
leaq 0x2f63(%rip), %rsi      # 0x8456
callq 0x3240
movq %rax, %rdi
movq %rbp, %rsi
callq 0x5624
movq %rax, %rdi
leaq 0x2f59(%rip), %rsi      # 0x8466
callq 0x3240
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rsi
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %r13, %rsi
callq 0x3240
movq %rax, %rdi
callq 0x30e0
movb $0x1, %al
jmp 0x54d9
movq %rdx, %rbp
movq %rax, %rdi
cmpl $0x3, %ebp
jne 0x5585
callq 0x30b0
movq %rax, %rbp
movq %r14, %rdi
leaq 0x2f33(%rip), %rsi      # 0x848f
callq 0x3240
movq %rax, (%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3240
movq %rax, %rdi
callq 0x30e0
jmp 0x55db
callq 0x30b0
movq %rax, (%rsp)
cmpl $0x2, %ebp
jne 0x55c4
movq %r14, %rdi
leaq 0x2ee6(%rip), %rsi      # 0x8483
callq 0x3240
movq %rax, %rbp
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3240
movq %rax, %rdi
callq 0x30e0
jmp 0x55db
movq %r14, %rdi
leaq 0x2ea1(%rip), %rsi      # 0x846f
callq 0x3240
movq %rax, %rdi
callq 0x30e0
callq 0x3390
xorl %eax, %eax
jmp 0x54d9
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
callq 0x3390
jmp 0x5614
movq %rax, %rbx
callq 0x3390
jmp 0x5614
movq %rax, %rbx
callq 0x3390
movq %rbx, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x388d
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/keys.cc
// Function: kvtest::generateKey()
static const char* generateKey() {
        char *rv = (char *)calloc(1, KEY_LEN + 1);
        assert(rv);
        for (int i = 0; i < KEY_LEN; i++) {
            rv[i] = nextChar();
        }
        return rv;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
pushq $0x11
popq %rsi
callq 0x3150
testq %rax, %rax
je 0x5837
movq %rax, %rbx
xorl %r14d, %r14d
pushq $0x3d
popq %r15
leaq 0x2ce4(%rip), %r12      # 0x84ef
cmpq $0x10, %r14
je 0x5828
callq 0x3100
xorl %edx, %edx
divq %r15
movb (%rdx,%r12), %al
movb %al, (%rbx,%r14)
incq %r14
jmp 0x580b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c8c(%rip), %rdi      # 0x84ca
leaq 0x2c62(%rip), %rsi      # 0x84a7
leaq 0x2c81(%rip), %rcx      # 0x84cd
pushq $0x39
popq %rdx
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/values.cc
// Function: kvtest::Values::Values(unsigned long, unsigned long, unsigned long)
Values::Values(size_t n, size_t lower, size_t upper) : values(n) {
        for (int i = 0; i < (int)n; i++) {
            values[i] = generateValue(lower, upper);
        }
        assert(values.size() == n);

        it = values.begin();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x7(%rsp), %rdx
callq 0x58ae
andq $0x0, 0x18(%r13)
movq %r14, 0x10(%rsp)
movq %r15, 0x20(%rsp)
subq %r15, %r14
movq %r14, 0x18(%rsp)
testl %ebx, %ebx
movl $0x0, %eax
movq %rbx, 0x8(%rsp)
cmovgl %ebx, %eax
movq %rax, 0x28(%rsp)
pushq $0x3d
popq %r12
leaq 0x2a65(%rip), %rbx      # 0x84ef
xorl %r14d, %r14d
cmpq 0x28(%rsp), %r14
je 0x5b0d
callq 0x3100
movq %rax, %rbp
andq 0x18(%rsp), %rbp
addq 0x20(%rsp), %rbp
jb 0x5b36
movq %r14, 0x30(%rsp)
cmpq 0x10(%rsp), %rbp
ja 0x5b4f
movq %r13, %r15
leaq 0x1(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x3150
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x5af6
callq 0x3100
xorl %edx, %edx
divq %r12
movb (%rdx,%rbx), %al
movb %al, (%r14,%r13)
incq %r13
jmp 0x5adb
movq %r15, %r13
movq (%r15), %rax
movq 0x30(%rsp), %rcx
movq %r14, (%rax,%rcx,8)
movq %rcx, %r14
incq %r14
jmp 0x5a8d
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq 0x8(%rsp), %rcx
jne 0x5b6c
movq %rax, 0x18(%r13)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a6d(%rip), %rdi      # 0x85aa
leaq 0x2a2d(%rip), %rsi      # 0x8571
leaq 0x2a6b(%rip), %rcx      # 0x85b6
pushq $0x17
jmp 0x5b66
leaq 0x2a92(%rip), %rdi      # 0x85e8
leaq 0x2a14(%rip), %rsi      # 0x8571
leaq 0x2a52(%rip), %rcx      # 0x85b6
pushq $0x18
popq %rdx
callq 0x3140
leaq 0x29eb(%rip), %rdi      # 0x855e
leaq 0x29f7(%rip), %rsi      # 0x8571
leaq 0x29fa(%rip), %rcx      # 0x857b
pushq $0x29
jmp 0x5b66
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::EventuallyPersistentStore(kvtest::KVStore*, unsigned long)
EventuallyPersistentStore::EventuallyPersistentStore(KVStore *t,
                                                         size_t est) {

        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
        est_size = est;
        towrite = NULL;
        initQueue();
        flusher = new Flusher(this);

        // Run in a thread...
        if(pthread_create(&thread, NULL, launch_flusher_thread, flusher)
           != 0) {
            throw std::runtime_error("Error initializing queue thread");
        }

        underlying = t;
        assert(underlying);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7120(%rip), %rax      # 0xcd18
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
movl $0x30005, %esi          # imm = 0x30005
movl $0xc1, %edx
movq %rbx, %rdi
callq 0x6454
leaq 0x48(%r15), %rdi
xorl %esi, %esi
callq 0x3330
leaq 0x70(%r15), %rdi
xorl %esi, %esi
callq 0x32b0
movq %r12, 0x10(%r15)
andq $0x0, 0xa0(%r15)
movq %r15, %rdi
callq 0x5cec
pushq $0x10
popq %rdi
callq 0x3250
movq %r15, (%rax)
movb $0x1, 0x8(%rax)
movq %rax, 0x18(%r15)
leaq 0xa8(%r15), %rdi
leaq 0xf6(%rip), %rdx        # 0x5d52
xorl %esi, %esi
movq %rax, %rcx
callq 0x33e0
testl %eax, %eax
jne 0x5c7f
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x5caf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %r14
leaq 0x2963(%rip), %rsi      # 0x85f4
movq %rax, %rdi
callq 0x30a0
movq 0x7350(%rip), %rsi      # 0xcff0
movq 0x7311(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33a0
leaq 0x295e(%rip), %rdi      # 0x8614
leaq 0x2962(%rip), %rsi      # 0x861f
leaq 0x2961(%rip), %rcx      # 0x8625
pushq $0x23
popq %rdx
callq 0x3140
movq %rax, %r15
movq %r14, %rdi
callq 0x31a0
jmp 0x5cdc
movq %rax, %r15
movq %rbx, %rdi
callq 0x64c4
movq %r15, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::launch_flusher_thread(void*)
static void* launch_flusher_thread(void* arg) {
        Flusher *flusher = (Flusher*) arg;
        try {
            flusher->run();
        } catch(...) {
            std::cerr << "Caught a fatal exception in the thread" << std::endl;
        }
        return NULL;
    }

// Assembly:
pushq %rbx
callq 0x68fa
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x30b0
movq 0x727d(%rip), %rdi      # 0xcfe8
leaq 0x29a6(%rip), %rsi      # 0x8718
callq 0x3240
movq %rax, %rdi
callq 0x30e0
callq 0x3390
jmp 0x5d58
movq %rax, %rbx
callq 0x3390
movq %rbx, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x388d
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::~EventuallyPersistentStore()
EventuallyPersistentStore::~EventuallyPersistentStore() {
        LockHolder lh(&mutex);
        flusher->stop();
        if(pthread_cond_signal(&cond) != 0) {
            throw std::runtime_error("Error signaling change.");
        }
        lh.unlock();
        pthread_join(thread, NULL);
        delete flusher;
        delete towrite;
        pthread_cond_destroy(&cond);
        pthread_mutex_destroy(&mutex);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6f65(%rip), %rax      # 0xcd18
movq %rax, (%rdi)
leaq 0x48(%rdi), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x516e
movq 0x18(%rbx), %rax
movb $0x0, 0x8(%rax)
leaq 0x70(%rbx), %r15
movq %r15, %rdi
callq 0x3030
testl %eax, %eax
jne 0x5e5d
leaq 0x8(%rsp), %rdi
callq 0x51d4
movq 0xa8(%rbx), %rdi
xorl %esi, %esi
callq 0x3210
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5e04
movb $0x0, 0x8(%rdi)
pushq $0x10
popq %rsi
callq 0x3260
movq 0xa0(%rbx), %r12
testq %r12, %r12
je 0x5e20
movq %r12, %rdi
callq 0x69b6
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x3260
movq %r15, %rdi
callq 0x3410
movq %r14, %rdi
callq 0x3290
leaq 0x8(%rsp), %rdi
callq 0x51d4
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x64c4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x2806(%rip), %rsi      # 0x8675
movq %rax, %rdi
callq 0x30a0
movq 0x7172(%rip), %rsi      # 0xcff0
movq 0x7133(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x388d
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void EventuallyPersistentStore::set(std::string &key, std::string &val,
                                        Callback<bool> &cb) {
        mutation_type_t mtype = storage.set(key, val);

        if (mtype == WAS_CLEAN || mtype == NOT_FOUND) {
            LockHolder lh(&mutex);
            queueDirty(key);
        }
        bool rv = true;
        cb.callback(rv);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0x6538
cmpl $0x1, %eax
ja 0x5eed
leaq 0x48(%r15), %rsi
movq %rsp, %rdi
callq 0x516e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f1a
movq %rsp, %rdi
callq 0x51d4
movq %rsp, %rsi
movb $0x1, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51d4
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::queueDirty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void EventuallyPersistentStore::queueDirty(std::string &key) {
        // Assume locked.
        towrite->push(key);
        if(pthread_cond_signal(&cond) != 0) {
            throw std::runtime_error("Error signaling change.");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
callq 0x6d9c
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x3030
testl %eax, %eax
jne 0x5f45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x271e(%rip), %rsi      # 0x8675
movq %rax, %rdi
callq 0x30a0
movq 0x708a(%rip), %rsi      # 0xcff0
movq 0x704b(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x33a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, kvtest::Callback<bool>&)
void EventuallyPersistentStore::set(std::string &key, const char *val,
                                        Callback<bool> &cb) {
        mutation_type_t mtype = storage.set(key, val);

        if (mtype == WAS_CLEAN || mtype == NOT_FOUND) {
            LockHolder lh(&mutex);
            queueDirty(key);
        }
        bool rv = true;
        cb.callback(rv);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0x6540
cmpl $0x1, %eax
ja 0x5fc7
leaq 0x48(%r15), %rsi
movq %rsp, %rdi
callq 0x516e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f1a
movq %rsp, %rdi
callq 0x51d4
movq %rsp, %rsi
movb $0x1, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51d4
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::reset()
void EventuallyPersistentStore::reset() {
        flush(false);
        LockHolder lh(&mutex);
        underlying->reset();
        delete towrite;
        towrite = NULL;
        initQueue();
        storage.clear();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x6080
leaq 0x48(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x516e
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xa0(%rbx), %r14
testq %r14, %r14
je 0x6031
movq %r14, %rdi
callq 0x69b6
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3260
andq $0x0, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x5cec
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x6630
leaq 0x8(%rsp), %rdi
callq 0x51d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51d4
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::flush(bool)
void EventuallyPersistentStore::flush(bool shouldWait) {
        LockHolder lh(&mutex);

        if (towrite->empty()) {
            if (shouldWait) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Error waiting for signal.");
                }
            }
        } else {
            std::queue<std::string> *q = towrite;
            towrite = NULL;
            initQueue();
            lh.unlock();

            RememberingCallback<bool> cb;
            assert(underlying);

            underlying->begin();
            while (!q->empty()) {
                flushSome(q, cb);
            }
            underlying->commit();

            delete q;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x48(%rdi), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x516e
movq 0xa0(%rbx), %r14
movq 0x30(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x6128
andq $0x0, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x5cec
movq %rsp, %rdi
callq 0x51d4
leaq 0x10(%rsp), %rdi
callq 0x4aba
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6153
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x10(%rsp), %r15
movq 0x30(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x60ff
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x632c
jmp 0x60e5
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %r14, %rdi
callq 0x69b6
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3260
leaq 0x10(%rsp), %rdi
callq 0x4eee
jmp 0x6140
testb %bpl, %bpl
je 0x6140
addq $0x70, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3340
testl %eax, %eax
jne 0x6172
movq %rsp, %rdi
callq 0x51d4
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24ba(%rip), %rdi      # 0x8614
leaq 0x24be(%rip), %rsi      # 0x861f
leaq 0x257c(%rip), %rcx      # 0x86e4
movl $0x88, %edx
callq 0x3140
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %r14
leaq 0x2546(%rip), %rsi      # 0x86ca
movq %rax, %rdi
callq 0x30a0
movq 0x6e5d(%rip), %rsi      # 0xcff0
movq 0x6e1e(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
jmp 0x61c7
jmp 0x61b3
jmp 0x61b3
movq %rax, %rbx
jmp 0x61c7
jmp 0x61ba
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4eee
movq %rsp, %rdi
callq 0x51d4
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<kvtest::GetValue>&)
void EventuallyPersistentStore::get(std::string &key,
                                        Callback<kvtest::GetValue> &cb) {
        int bucket_num = storage.bucket(key);
        LockHolder lh(storage.getMutex(bucket_num));
        StoredValue *v = storage.unlocked_find(key, bucket_num);
        bool success = v != NULL;
        const char *sval = v ? v->getValue() : NULL;
        kvtest::GetValue rv(success ? sval : std::string(":("),
                            success);
        cb.callback(rv);
        lh.unlock();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %r15
movq %r15, %rdi
callq 0x66d0
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x671e
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x516e
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x67c0
movq %rax, %r14
testq %rax, %rax
je 0x623a
movq 0x28(%r14), %rsi
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3cf4
jmp 0x6250
leaq 0x1e0e(%rip), %rsi      # 0x804f
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3cf4
xorl %edx, %edx
testq %r14, %r14
setne %dl
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3dc6
leaq 0x20(%rsp), %rdi
callq 0x30d0
testq %r14, %r14
movq (%rbx), %rax
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x51d4
leaq 0x40(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x51d4
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x62d1
jmp 0x62d1
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30d0
jmp 0x62d4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30d0
testq %r14, %r14
jmp 0x62d4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x51d4
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void EventuallyPersistentStore::del(std::string &key, Callback<bool> &cb) {
        bool existed = storage.del(key);
        if (existed) {
            queueDirty(key);
        }
        cb.callback(existed);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0x67fc
movb %al, 0xf(%rsp)
testb %al, %al
je 0x6314
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f1a
movq (%rbx), %rax
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq