LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: Word_ID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int Word_ID(string wd, string py)
{
	int H = PinyinHash(py);
	if (Word_map.count(make_pair(wd, H)))
		return Word_map[make_pair(wd, H)];

	WordTotal ++;
	Word[WordTotal] = wd;
	Word_map[make_pair(wd, H)] = WordTotal;
	SplitPinyin(WordTotal, py);

	return WordTotal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x2230
movq %r15, %rdi
callq 0x2fd5
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x20d0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2230
movl %ebp, 0x20(%r15)
leaq 0x5024f4d(%rip), %rdi   # 0x5027d80
movq %r15, %rsi
callq 0x30d2
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x20d0
testq %r15, %r15
je 0x2e80
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movl %ebp, 0x20(%rbx)
leaq 0x5024f19(%rip), %rdi   # 0x5027d80
movq %rbx, %rsi
callq 0x30ec
movl (%rax), %ebx
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x2f0d
movslq 0x5341(%rip), %rax      # 0x81c8
incq %rax
movl %eax, 0x5338(%rip)      # 0x81c8
shlq $0x5, %rax
leaq 0x91e5(%rip), %rdi      # 0xc080
addq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movl 0x531b(%rip), %r12d     # 0x81c8
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2230
movl %ebp, 0x20(%r15)
leaq 0x5024eb8(%rip), %rdi   # 0x5027d80
movq %r15, %rsi
callq 0x30ec
movl %r12d, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x20d0
movl 0x52e5(%rip), %ebp      # 0x81c8
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2230
movl %ebp, %edi
movq %r14, %rsi
callq 0x3152
leaq 0x30(%rsp), %rdi
callq 0x20d0
movl 0x52bb(%rip), %ebx      # 0x81c8
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x2f3c
jmp 0x2f2a
jmp 0x2f2a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2f3c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: PinyinHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int PinyinHash(string py)
{
	int L = py.length();
	int num = 0;
	int S = 0, E = py.find('-', S);

	while (E != -1)
	{
		num = (2333LL * num + Pinyin_ID(py.substr(S, E-S))) % 1000000007;
		S = E + 1;
		E = py.find('-', S);
	}
	num = (2333LL * num + Pinyin_ID(py.substr(S, L-S))) % 1000000007;
	return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
pushq $0x2d
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x2220
movq %rax, %r15
leaq 0x28(%rsp), %rbx
movl $0x3b9aca07, %r13d      # imm = 0x3B9ACA07
xorl %ecx, %ecx
movslq %ecx, %rdx
movslq %r12d, %r12
cmpl $-0x1, %r15d
je 0x3067
movl %r15d, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x3250
imulq $0x91d, %r12, %rcx      # imm = 0x91D
cltq
addq %rcx, %rax
cqto
idivq %r13
movq %rdx, %r12
movq %rbx, %rdi
callq 0x20d0
incl %r15d
movslq %r15d, %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x2220
movl %r15d, %ecx
movq %rax, %r15
jmp 0x300c
movl 0x4(%rsp), %eax
subl %edx, %eax
movslq %eax, %rcx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x3250
imulq $0x91d, %r12, %rcx      # imm = 0x91D
cltq
addq %rcx, %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movq %rdx, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30be
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: SplitPinyin(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline void SplitPinyin(int id, string py)
{
	int L = py.length();
	int S = 0, E = py.find('-', S);

	while (E != -1)
	{
		Word_pinyin[id].push_back(Pinyin_ID(py.substr(S, E-S)));
		S = E + 1;
		E = py.find('-', S);
	}

	Word_pinyin[id].push_back(Pinyin_ID(py.substr(S, L-S)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movl %edi, %ebx
movl 0x8(%rsi), %eax
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
pushq $0x2d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2220
movq %rax, %r15
movslq %ebx, %rax
imulq $0x18, %rax, %rax
leaq 0x2dcfaf4(%rip), %rbx   # 0x2dd2c80
addq %rax, %rbx
leaq 0x28(%rsp), %r12
movq %rsp, %r13
movslq %ebp, %rdx
cmpl $-0x1, %r15d
je 0x31ea
movl %r15d, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x21a0
movq %r12, %rdi
callq 0x3250
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3c62
movq %r12, %rdi
callq 0x20d0
incl %r15d
movslq %r15d, %rdx
movq %r14, %rdi
pushq $0x2d
popq %rsi
callq 0x2220
movl %r15d, %ebp
movq %rax, %r15
jmp 0x3197
movl 0x4(%rsp), %eax
subl %edx, %eax
movslq %eax, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x3250
movq %rsp, %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x3c62
leaq 0x8(%rsp), %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x3243
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: Pinyin_ID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int Pinyin_ID(string py)
{
	if (py=="n") py="en";
	if (py=="lve") py="lue";
	if (py=="nve") py="nue";

	if (Pinyin_map[py] == 0)
		return Pinyin[Pinyin_map[py] = ++PinyinTotal] = py, PinyinTotal;
	return Pinyin_map[py];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1e31(%rip), %rsi      # 0x5090
callq 0x332c
testb %al, %al
je 0x3277
leaq 0x1e20(%rip), %rsi      # 0x508f
movq %rbx, %rdi
callq 0x2310
leaq 0x1e14(%rip), %rsi      # 0x5092
movq %rbx, %rdi
callq 0x332c
testb %al, %al
je 0x3299
leaq 0x1e05(%rip), %rsi      # 0x5096
movq %rbx, %rdi
callq 0x2310
leaq 0x1dfa(%rip), %rsi      # 0x509a
movq %rbx, %rdi
callq 0x332c
testb %al, %al
je 0x32bb
leaq 0x1deb(%rip), %rsi      # 0x509e
movq %rbx, %rdi
callq 0x2310
leaq 0x8d8e(%rip), %rdi      # 0xc050
movq %rbx, %rsi
callq 0x333a
cmpl $0x0, (%rax)
je 0x32e3
leaq 0x8d7a(%rip), %rdi      # 0xc050
movq %rbx, %rsi
callq 0x333a
movq %rax, %r14
jmp 0x3323
leaq 0x4eda(%rip), %r14      # 0x81c4
movslq 0x4ed3(%rip), %r15      # 0x81c4
incq %r15
movl %r15d, 0x4ec9(%rip)     # 0x81c4
leaq 0x8d4e(%rip), %rdi      # 0xc050
movq %rbx, %rsi
callq 0x333a
movl %r15d, (%rax)
shlq $0x5, %r15
leaq 0x4eb8(%rip), %rdi      # 0x81d0
addq %r15, %rdi
movq %rbx, %rsi
callq 0x2100
movl (%r14), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: unsigned long list_populate<hm3::STLVectorList>(hm3::STLVectorList&)
static size_t list_populate(LIST &list){
	list.removeAll();

	size_t size = 0;

	size += list_add(list, {"3 city",	"Sofia"	});
	size += list_add(list, {"1 name",	"Niki"	});
	size += list_add(list, {"4 os",		"Linux"	});
	size += list_add(list, {"2 age",	"22"	});

	return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x6934
leaq 0x20(%rsp), %rsi
movq $0x6, (%rsi)
leaq 0x5214(%rip), %rax      # 0xb081
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq $0x5, (%rdx)
leaq 0x5204(%rip), %rax      # 0xb088
movq %rax, 0x8(%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9ed4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fec
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9eb4
leaq 0x20(%rsp), %rsi
movq $0x6, (%rsi)
leaq 0x51c9(%rip), %rax      # 0xb08e
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq $0x4, (%rdx)
leaq 0x51b9(%rip), %rax      # 0xb095
movq %rax, 0x8(%rdx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9ed4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fec
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x9eb4
leaq 0x20(%rsp), %rsi
movq $0x4, (%rsi)
leaq 0x517d(%rip), %rax      # 0xb09a
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq $0x5, (%rdx)
leaq 0x516b(%rip), %rax      # 0xb09f
movq %rax, 0x8(%rdx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9ed4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5fec
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x9eb4
leaq 0x20(%rsp), %rsi
movq $0x5, (%rsi)
leaq 0x5130(%rip), %rax      # 0xb0a5
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq $0x2, (%rdx)
leaq 0x511f(%rip), %rax      # 0xb0ab
movq %rax, 0x8(%rdx)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9ed4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5fec
addq %r14, %r15
addq %rax, %r12
addq %r15, %r12
leaq 0x8(%rsp), %rdi
callq 0x9eb4
movq %r12, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5fd7
jmp 0x5fd7
jmp 0x5fd7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9eb4
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/ilist.h
// Function: hm3::List<hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>>::print(unsigned long) const
void print(size_t count = PRINT_COUNT) const{
		for(const Pair &p : *self() ){
			p.print();
			if (--count == 0)
				return;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x7702
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7712
leaq 0x40(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7724
testb %al, %al
je 0x75a2
movq %r14, %rdi
callq 0x772e
movq %rax, %rdi
callq 0xa070
decq %rbx
je 0x75a2
movq %r14, %rdi
callq 0x773c
jmp 0x7574
movq %rsp, %rdi
callq 0x7786
leaq 0x40(%rsp), %rdi
callq 0x7786
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x75d3
jmp 0x75c8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7786
leaq 0x40(%rsp), %rdi
callq 0x7786
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: void iterator_get_test_deref<hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>>(char const*, hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>> const&, char const*, char const*)
inline void iterator_get_test_deref(const char *module, const LIST &list, const char *key, const char *value){
	auto it = list.lowerBound(key);
	auto et = list.end();

	if (value){
	PRINTF_TEST("*get it   deref",	it != et && (*it).getVal() == value	);
	PRINTF_TEST(" get it-> deref",	it != et &&   it->getVal() == value	);
	}else{
	PRINTF_TEST(".get it et",	it == et				);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x675a
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x826a
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x7712
testq %r14, %r14
je 0x815c
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7724
testb %al, %al
je 0x8192
leaq 0x18(%rsp), %rdi
callq 0x772e
movq %rax, %rdi
callq 0x9f5a
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r14, %rsi
callq 0x690c
leaq 0x2eda(%rip), %rdx      # 0xb027
leaq 0x2ed6(%rip), %rcx      # 0xb02a
testb %al, %al
cmovneq %rdx, %rcx
jmp 0x8199
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7bcc
leaq 0x2eb5(%rip), %rdx      # 0xb027
leaq 0x2eb1(%rip), %rcx      # 0xb02a
testb %al, %al
cmovneq %rdx, %rcx
leaq 0x2e7e(%rip), %rdi      # 0xb004
leaq 0x3022(%rip), %rdx      # 0xb1af
jmp 0x8215
leaq 0x2e91(%rip), %rcx      # 0xb02a
leaq 0x2e64(%rip), %rdi      # 0xb004
leaq 0x2fe8(%rip), %rdx      # 0xb18f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7724
testb %al, %al
je 0x8200
leaq 0x18(%rsp), %rdi
callq 0x772e
movq %rax, %rdi
callq 0x9f5a
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r14, %rsi
callq 0x690c
leaq 0x2e36(%rip), %rdx      # 0xb027
leaq 0x2e32(%rip), %rcx      # 0xb02a
testb %al, %al
cmovneq %rdx, %rcx
jmp 0x8207
leaq 0x2e23(%rip), %rcx      # 0xb02a
leaq 0x2df6(%rip), %rdi      # 0xb004
leaq 0x2f8a(%rip), %rdx      # 0xb19f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x58(%rsp), %rdi
callq 0x7786
leaq 0x18(%rsp), %rdi
callq 0x7786
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x824b
jmp 0x824b
movq %rax, %rbx
jmp 0x8258
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x7786
leaq 0x18(%rsp), %rdi
callq 0x7786
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/hashlist.h
// Function: hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::getBucketForKey_(StringRef const&) const
typename CONTAINER::size_type getBucketForKey_(const StringRef &key) const{
		/*
		Instead of modulo, this can be done with bit AND.
		Doing so, really increase the speed a bit,
		but code for file based operations get more complicated,
		and overal result will be low quality code.
		*/

		auto const result = calcHash_(key.data()) % container_.size();
		
		return (typename CONTAINER::size_type) result;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
addq $0x18, %rdi
callq 0x76e6
movq %rax, %rcx
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movl $0x218, %esi            # imm = 0x218
cqto
idivq %rsi
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/multitableiterator/collectioniterator_impl.h
// Function: hm3::multitableiterator::CollectionIterator<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::operator++()
auto CollectionIterator<CONTAINER>::operator++() -> CollectionIterator &{
	const Pair &pair = operator*();

	if ( ! pair ){
		// notice, there is no increment here !!!
		ended_ = true;
		return *this;
	}

	// step 2: increase all duplicates from the index
	for(const auto index : tmp_index)
		++it_[index];

	tmp_pair = nullptr;

	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x772e
cmpq $0x0, (%rax)
je 0x7778
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r15
cmpq %r15, %r14
je 0x7771
movq (%r14), %rdi
shlq $0x4, %rdi
addq (%rbx), %rdi
callq 0x9912
addq $0x8, %r14
jmp 0x7757
andq $0x0, 0x20(%rbx)
jmp 0x777c
movb $0x1, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/multitableiterator/collectioniterator_impl.h
// Function: hm3::multitableiterator::CollectionIterator<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::CollectionIterator<bool>(std::vector<hm3::SkipList, std::allocator<hm3::SkipList>> const&, bool const&, std::nullptr_t)
CollectionIterator<CONTAINER>::CollectionIterator(const CONTAINER &list, const T &param, std::nullptr_t){
	it_.reserve(list.size());

	// CONTAINER is responsible for ordering the tables,
	// in correct (probably reverse) order.
	for(const auto &table : list)
		it_.push_back({ table, param });

	tmp_index.reserve(list.size());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rdi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movl $0x218, %ecx            # imm = 0x218
cqto
idivq %rcx
movq %rax, %rsi
callq 0x7884
movq (%r15), %rbp
movq 0x8(%r15), %r14
leaq 0x8(%rsp), %r13
cmpq %r14, %rbp
je 0x7839
cmpb $0x0, (%r12)
jne 0x7818
movq 0x8(%rbp), %rax
jmp 0x781a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7a14
addq $0x218, %rbp            # imm = 0x218
jmp 0x7806
movq 0x8(%r15), %rax
subq (%r15), %rax
movl $0x218, %ecx            # imm = 0x218
cqto
idivq %rcx
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x792c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7867
movq %rax, %r15
movq (%rsp), %rdi
callq 0x7b90
movq %rbx, %rdi
callq 0x7bae
movq %r15, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/multitableiterator/collectioniterator_impl.h
// Function: hm3::multitableiterator::CollectionIterator<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::dereference_() const
const Pair &CollectionIterator<CONTAINER>::dereference_() const{
	std::vector<size_type>	indexes;
	const Pair		*cpair = nullptr;

	// step 1: find first minimal add other minimals into index
	for(size_type i = 0; i < it_.size(); ++i){
		const Pair &pair = *it_[i];

		// skip if is null
		if ( ! pair )
			continue;

		// initialize
		if (cpair == nullptr){
			indexes.clear();
			indexes.push_back(i);
			cpair = &pair;

			continue;
		}

		int const cmp = pair.cmp(*cpair);

		// if is smaller, start over
		if (cmp < 0){
			indexes.clear();
			indexes.push_back(i);
			cpair = &pair;

			continue;
		}

		// same, add to list.
		if (cmp == 0){
			indexes.push_back(i);

			// if newer, swap
			if ( pair.cmpTime(*cpair) > 0 )
				cpair = &pair;
		}
	}

	// SETTING MUTABLE VARIABLES
	if (cpair){
		tmp_pair = cpair;
		tmp_index = std::move(indexes);

		return *tmp_pair;
	}else{
		tmp_pair = cpair;

		return Pair::zero();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %eax, %eax
leaq 0x18(%rsp), %r15
xorl %r13d, %r13d
movq %rax, 0x18(%rsp)
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rax
jae 0x7d5b
shlq $0x4, %rax
addq %rax, %rdi
callq 0x7db0
movq %rax, %r12
cmpq $0x0, (%rax)
je 0x7d0e
testq %r13, %r13
je 0x7d13
movq %r12, %rdi
movq %r13, %rsi
callq 0x7df4
testl %eax, %eax
js 0x7d30
jne 0x7d0e
movq %r14, %rdi
movq %r15, %rsi
callq 0x7dd4
movq %r12, %rdi
movq %r13, %rsi
callq 0x9fec
testl %eax, %eax
jg 0x7d4b
movq %r13, %r12
jmp 0x7d4b
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x7d23
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7dd4
jmp 0x7d4b
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x7d40
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7dd4
movq 0x18(%rsp), %rax
incq %rax
movq %r12, %r13
jmp 0x7cad
testq %r13, %r13
je 0x7d76
movq %r13, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x7f30
movq 0x20(%rbx), %rbx
jmp 0x7d82
andq $0x0, 0x20(%rbx)
leaq 0x9756(%rip), %rbx      # 0x114d8
movq %rsp, %rdi
callq 0x7b90
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7d9d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7b90
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/stlvectorlist.cc
// Function: hm3::STLVectorList::remove(StringRef const&)
bool STLVectorList::remove(const StringRef &key){
	size_type result;
	bool const found = binarySearch_(key, result);

	if (! found){
		// the key does not exists in the vector.
		return true;
	}

	// Fix size
	Pair & data = container_[ result ];
	dataSize_ -= data.getBytes();

	// This is slow, might shiftL
	auto ptr = container_.begin() + (difference_type) result;
	container_.erase(ptr);

	return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x84dc
testb %al, %al
je 0x83e9
movq 0x8(%rsp), %rdi
shlq $0x3, %rdi
addq (%rbx), %rdi
callq 0xa04c
subq %rax, 0x18(%rbx)
movq 0x8(%rsp), %rsi
shlq $0x3, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x86a6
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/stlvectorlist.cc
// Function: bool hm3::STLVectorList::putT_<hm3::Pair>(hm3::Pair&&)
bool STLVectorList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	size_type result;
	bool const found = binarySearch_(key, result);

	if (found){
		// key exists, overwrite, do not shift

		Pair & olddata = container_[ result ];

		// check if the data in database is valid
		if (! newdata.valid(olddata) ){
			// newdata will be magically destroyed.
			return false;
		}

		dataSize_ = dataSize_
					- olddata.getBytes()
					+ newdata.getBytes();

		// copy assignment
		olddata = std::forward<UPAIR>(newdata);

		return true;
	}

	// key not exists
	dataSize_ += newdata.getBytes();

	try{
		if (result == container_.size()){
			// push_back micro-optimization :)
			container_.push_back(std::forward<UPAIR>(newdata));
		}else{
			// This is slow, might shiftR
			auto ptr = container_.cbegin() + (difference_type) result;
			container_.insert(ptr, std::forward<UPAIR>(newdata));
		}
	}catch(...){
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x9f38
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x84dc
testb %al, %al
je 0x8473
movq 0x8(%rsp), %r15
movq (%r14), %r12
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa038
testb %al, %al
je 0x84b9
leaq (%r12,%r15,8), %r15
movq 0x18(%r14), %r12
movq %r15, %rdi
callq 0xa04c
subq %rax, %r12
movq %rbx, %rdi
callq 0xa04c
addq %r12, %rax
movq %rax, 0x18(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9ec6
movb $0x1, %bpl
jmp 0x84b9
movq %rbx, %rdi
callq 0xa04c
addq %rax, 0x18(%r14)
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jne 0x84a7
movb $0x1, %bpl
movq %r14, %rdi
movq %rbx, %rsi
callq 0x880c
jmp 0x84b9
leaq (%rcx,%rax,8), %rsi
movb $0x1, %bpl
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a44
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x84ca
movq %rax, %rdi
callq 0x2070
callq 0x2200
xorl %ebp, %ebp
jmp 0x84b9
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::shiftR_(unsigned long)
bool VectorList::shiftR_(size_type const index){
	if (! resize_(1))
		return false;

	// LLVM static analyzer thinks this is an error,
	// so I add this unused branch
	if (buffer_){
		size_t const size = dataCount_ - index - 1;

		// this is the most slow operation of them all
		xmemmove(
			& buffer_[index + 1],
			& buffer_[index],
			size * ELEMENT_SIZE
		);
	}

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rsi
callq 0x8e16
movl %eax, %ebx
testb %al, %al
je 0x8c7d
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x8c7d
movq %r14, %rdx
notq %rdx
addq 0x18(%r15), %rdx
leaq (%rax,%r14,8), %rsi
leaq (%rax,%r14,8), %rdi
addq $0x8, %rdi
shlq $0x3, %rdx
callq 0x21f0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::clear_(bool)
void VectorList::clear_(bool const alsoFree){
	if (alsoFree && buffer_)
		xfree(buffer_);

	dataCount_	= 0;
	dataSize_	= 0;
	reservedCount_	= 0;
	buffer_		= nullptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x8caf
movq 0x8(%rbx), %rdi
callq 0x21a0
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::removeAll()
bool VectorList::removeAll(){
	for(auto &p : ArrayRef<Pair>{ buffer_, dataCount_ } )
		p.~Pair();

	clear_(true);

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x18(%rdi), %r15
shlq $0x3, %r15
testq %r15, %r15
je 0x8d19
movq %r14, %rdi
callq 0x9eb4
addq $0x8, %r14
addq $-0x8, %r15
jmp 0x8d02
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8c9e
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::remove(StringRef const&)
bool VectorList::remove(const StringRef &key){
	size_type result;
	bool const found = binarySearch_(key, result);

	if (! found){
		// the key does not exists in the vector.
		return true;
	}

	// proceed with remove
	Pair & data = buffer_[result];
	dataSize_ -= data.getBytes();
	data.~Pair();

	shiftL_(result);

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x8f96
testb %al, %al
je 0x8dd1
movq (%rsp), %r14
shlq $0x3, %r14
addq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0xa04c
subq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x9eb4
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x8ddc
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::shiftL_(unsigned long)
bool VectorList::shiftL_(size_type const index){
	// this is the most slow operation of them all
	xmemmove(
		& buffer_[index],
		& buffer_[index + 1],
		(dataCount_ - index - 1) * ELEMENT_SIZE
	);

	resize_(-1);

	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rax,%rsi,8), %rdi
leaq (%rax,%rsi,8), %rax
addq $0x8, %rax
notq %rsi
addq 0x18(%rbx), %rsi
leaq (,%rsi,8), %rdx
movq %rax, %rsi
callq 0x21f0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x8e16
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::resize_(int)
bool VectorList::resize_(int const delta){
	if (delta == 0){
		// already resized, done :)
		return true;
	}

	if (dataCount_ == 0 && delta < 0){
		// must be an error
		return true;
	}

	size_type const new_dataCount = dataCount_ + (size_type) sgn(delta);

	if (new_dataCount == 0){
		clear_(true);
		return true;
	}

	size_type const new_reservedCount = calcNewCount_(new_dataCount);

	if (reservedCount_ == new_reservedCount){
		// already resized, done :)
		dataCount_ = new_dataCount;

		return true;
	}

	Pair *new_buffer = (Pair *) xrealloc(buffer_, new_reservedCount * ELEMENT_SIZE);

	if (new_buffer == nullptr)
		return false;

	dataCount_	= new_dataCount;
	reservedCount_	= new_reservedCount;
	buffer_		= new_buffer;

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
testl %esi, %esi
je 0x8ea8
movq %rdi, %r14
movq 0x18(%rdi), %r15
testq %r15, %r15
sete %al
testl %esi, %esi
sets %cl
testb %al, %cl
jne 0x8ea8
sarl $0x1f, %esi
orl $0x1, %esi
movslq %esi, %rax
addq %rax, %r15
je 0x8e75
movq (%r14), %rcx
movq 0x10(%r14), %rsi
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r12
cmpq $0x1, %rdx
sbbq $-0x1, %r12
imulq %rcx, %r12
cmpq %r12, %rsi
jne 0x8e82
movq %r15, 0x18(%r14)
jmp 0x8ea8
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8c9e
jmp 0x8ea8
movq 0x8(%r14), %rdi
leaq (,%r12,8), %rsi
callq 0x2210
testq %rax, %rax
je 0x8ea6
movq %r15, 0x18(%r14)
movq %r12, 0x10(%r14)
movq %rax, 0x8(%r14)
jmp 0x8ea8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: bool hm3::VectorList::putT_<hm3::Pair>(hm3::Pair&&)
bool VectorList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	size_type result;
	bool const found = binarySearch_(key, result);

	if (found){
		// key exists, overwrite, do not shift

		Pair & olddata = buffer_[ result ];

		// check if the data in database is valid
		if (! newdata.valid(olddata) ){
			// newdata will be magically destroyed.
			return false;
		}

		dataSize_ = dataSize_
					- olddata.getBytes()
					+ newdata.getBytes();

		// copy assignment
		olddata = std::forward<UPAIR>(newdata);

		return true;
	}

	// key not exists, shift, then add
	if ( ! shiftR_( result ) ){
		return false;
	}

	dataSize_ += newdata.getBytes();

	// placement new with copy constructor
	void *placement = & buffer_[ result ];
	new(placement) Pair(std::forward<UPAIR>(newdata));

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x9f38
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x8f96
testb %al, %al
je 0x8f4d
movq 0x8(%r14), %r15
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa038
testb %al, %al
je 0x8f86
leaq (%r15,%r12,8), %r15
movq 0x20(%r14), %r12
movq %r15, %rdi
callq 0xa04c
subq %rax, %r12
movq %rbx, %rdi
callq 0xa04c
addq %r12, %rax
movq %rax, 0x20(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9ec6
jmp 0x8f7f
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8c3c
testb %al, %al
je 0x8f84
movq %rbx, %rdi
callq 0xa04c
addq %rax, 0x20(%r14)
movq 0x8(%rsp), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x9eba
movb $0x1, %bpl
jmp 0x8f86
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::removeAll()
bool LinkList::removeAll(){
	for(Node *node = head_; node; ){
		Node *copy = node;

		node = node->next;

		delete copy;
	}

	clear_();

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
pushq $0x10
popq %r14
testq %r15, %r15
je 0x91c1
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0x9eb4
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
movq %r12, %r15
jmp 0x91a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::locate_(StringRef const&, bool) const
const LinkList::Node *LinkList::locate_(const StringRef &key, bool const exact) const{
	for(const Node *node = head_; node; node = node->next){
		const Pair & data = node->data;

		int const cmp = data.cmp(key);

		if (cmp == 0)
			return node;

		if (cmp > 0)
			return exact ? nullptr : node;
			//break;
	}

	return nullptr;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x921d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7f24
testl %eax, %eax
je 0x922a
jg 0x9221
addq $0x8, %rbx
jmp 0x91fe
xorl %ebx, %ebx
jmp 0x922a
xorl %eax, %eax
testb %bpl, %bpl
cmovneq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::remove(StringRef const&)
bool LinkList::remove(const StringRef &key){
	Node *prev = nullptr;
	for(Node *node = head_; node; node = node->next){
		const Pair & data = node->data;
		int const cmp = data.cmp(key);

		if (cmp == 0){
			if (prev){
				prev->next = node->next;
			}else{
				// First node...
				head_ = node->next;
			}

			dataSize_ -= data.getBytes();
			--dataCount_;

			delete node;
			return true;
		}

		if (cmp > 0)
			break;

		prev = node;
	}

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rdi, %rax
movq (%rax), %r14
testq %r14, %r14
je 0x929e
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f24
testl %eax, %eax
je 0x9268
jg 0x929e
leaq 0x8(%r14), %rax
movq %r14, %r12
jmp 0x9246
leaq 0x8(%r12), %rax
testq %r12, %r12
movq 0x8(%r14), %rcx
cmoveq %rbx, %rax
movq %rcx, (%rax)
movq %r14, %rdi
callq 0xa04c
subq %rax, 0x10(%rbx)
decq 0x8(%rbx)
movq %r14, %rdi
callq 0x9eb4
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/linklist.cc
// Function: bool hm3::LinkList::putT_<hm3::Pair>(hm3::Pair&&)
bool LinkList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	Node *prev = nullptr;
	for(Node *node = head_; node; node = node->next){
		Pair & olddata = node->data;

		int const cmp = olddata.cmp(key);

		if (cmp == 0){
			// handle overwrite,
			// keep the node, overwrite the data

			// check if the data in database is valid
			if (! newdata.valid(olddata)){
				// newdata will be magically destroyed.
				return false;
			}

			dataSize_ = dataSize_
					- olddata.getBytes()
					+ newdata.getBytes();

			// copy assignment
			olddata = std::forward<UPAIR>(newdata);

			return true;
		}

		if (cmp > 0)
			break;

		prev = node;
	}

	size_t const size = newdata.getBytes();

	Node *newnode = new(std::nothrow) Node(std::forward<UPAIR>(newdata));
	if (newnode == nullptr){
		// newdata will be magically destroyed.
		return false;
	}

	// put new pair here...
	if (prev){
		// we are at the middle
		newnode->next = prev->next;
		prev->next = newnode;
	}else{
		newnode->next = head_;
		head_ = newnode;
	}

	dataSize_ += size;
	dataCount_++;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9f38
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
xorl %r13d, %r13d
movq %rbx, %rax
movq (%rax), %r15
testq %r15, %r15
je 0x931a
movq %r15, %rdi
movq %r12, %rsi
callq 0x7f24
testl %eax, %eax
je 0x9382
jg 0x931a
leaq 0x8(%r15), %rax
movq %r15, %r13
jmp 0x92f8
movq %r14, %rdi
callq 0xa04c
movq %rax, %r15
movq 0x6c94(%rip), %rsi      # 0xffc0
pushq $0x10
popq %rdi
callq 0x2240
testq %rax, %rax
je 0x93c0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x93ee
leaq 0x8(%r13), %rax
testq %r13, %r13
cmoveq %rbx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%r12)
movq %r12, (%rax)
movdqu 0x8(%rbx), %xmm0
movq %r15, %xmm1
movdqa 0x1ebd(%rip), %xmm2     # 0xb230
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x8(%rbx)
jmp 0x93bb
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0xa038
testb %al, %al
je 0x93c2
movq 0x10(%rbx), %r12
movq %r15, %rdi
callq 0xa04c
subq %rax, %r12
movq %r14, %rdi
callq 0xa04c
addq %r12, %rax
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ec6
movb $0x1, %bpl
jmp 0x93c2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x6be3(%rip), %rsi      # 0xffc0
movq %r12, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::locate_(StringRef const&, bool) const
auto SkipList::locate_(const StringRef &key, bool const complete_evaluation) const -> NodeLocator{
	// it is extremly dangerous to have key == nullptr here.
	if (key.empty()){
		std::logic_error exception("Key can not be nullptr in SkipList::_locate");
		throw exception;
	}

	NodeArrayC loc;

	// smart over-optimizations, such skip NULL lanes or
	// start from the middle of the list did not pay off.

	int cmp = 1;

	const Node *node = nullptr;
	const Node *prev = nullptr;

	height_type height = height_;
	while(height){
		node = prev ? prev : heads_[height - 1];

		while(node){
			const Pair & data = node->data;
			cmp = data.cmp(key);

			if (cmp >= 0)
				break;

			prev = node;
			node = node->next[height - 1];
		}


		if (complete_evaluation == false && cmp == 0)
			return { node, loc };

		loc[height - 1] = prev;

		--height;
	}

	return { cmp ? nullptr : node , loc };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x8(%rsp)
cmpq $0x0, (%rdx)
je 0x95fe
movl %ecx, %ebp
movq %rdx, %r14
movzbl (%rsi), %ebx
addq $0x8, %rsi
movq %rsi, 0x10(%rsp)
pushq $0x1
popq %rax
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rbx, %r13
subq $0x1, %r13
jb 0x95c3
decl %ebx
testq %r15, %r15
je 0x9583
movq %r15, %r12
jmp 0x958f
movq 0x10(%rsp), %rcx
leaq (%rcx,%rbx,8), %rcx
movq (%rcx), %r12
testq %r12, %r12
je 0x95a3
movq %r12, %rdi
movq %r14, %rsi
callq 0x7f24
testl %eax, %eax
js 0x95b6
testb %bpl, %bpl
jne 0x95ac
testl %eax, %eax
je 0x95cb
movq %r15, 0x18(%rsp,%rbx,8)
movq %r13, %rbx
jmp 0x9571
leaq (%r12,%rbx,8), %rcx
addq $0x8, %rcx
movq %r12, %r15
jmp 0x958c
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %r12
movq 0x8(%rsp), %rbx
movq %r12, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x18(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x2130
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c81(%rip), %rsi      # 0xb286
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x21c0
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2100
movq 0x69b9(%rip), %rsi      # 0xffe8
movq 0x69a2(%rip), %rdx      # 0xffd8
movq %r14, %rdi
callq 0x2220
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2258
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::_getRandomHeight()
auto SkipList::_getRandomHeight() -> height_type{
	// This gives slightly better performance,
	// than divide by 3 or multply by 0.33

	// We execute rand() inside the loop,
	// but performance is fast enought.

	height_type h = 1;
	while( h < height_ && rand_() )
		h++;

	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movb $0x1, %bl
leaq 0x6ae3(%rip), %r15      # 0x10148
cmpb (%r14), %bl
jae 0x967a
movq %r15, %rdi
callq 0x9bd8
testb %al, %al
je 0x967a
incb %bl
jmp 0x9665
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::removeAll()
bool SkipList::removeAll(){
	for(const Node *node = heads_[0]; node; ){
		const Node *copy = node;

		node = node->next[0];

		delete copy;
	}

	clear_();

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
pushq $0x10
popq %r14
testq %r15, %r15
je 0x973c
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0x9eb4
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
movq %r12, %r15
jmp 0x971b
movq %rbx, %rdi
callq 0x9694
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::get(StringRef const&) const
const Pair &SkipList::get(const StringRef &key) const{
	if (key.empty())
		return Pair::zero();

	const auto nl = locate_(key);

	return nl.node ? nl.node->data : Pair::zero();
}

// Assembly:
movq %rsi, %rdx
cmpq $0x0, (%rsi)
je 0x978d
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x9534
movq (%rbx), %rax
testq %rax, %rax
jne 0x9784
leaq 0x7d54(%rip), %rax      # 0x114d8
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
leaq 0x7d44(%rip), %rax      # 0x114d8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::printLane(unsigned char) const
void SkipList::printLane(height_type const lane) const{
	uint64_t i = 0;
	const Node *node;
	for(node = heads_[lane]; node; node = node->next[lane]){
		const Pair & data = node->data;
		data.print();

		if (++i > 10)
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
leaq 0x8(%rdi,%r14,8), %rax
pushq $0xa
popq %r15
movq (%rax), %rbx
testq %rbx, %rbx
je 0x990b
movq %rbx, %rdi
callq 0xa070
subq $0x1, %r15
jb 0x990b
leaq (%rbx,%r14,8), %rax
addq $0x8, %rax
jmp 0x98eb
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: bool hm3::SkipList::putT_<hm3::Pair>(hm3::Pair&&)
bool SkipList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	if (key.empty())
		return true;

	const auto nl = locate_(key);

	if (nl.node){
		// update in place. node MUST be not NULL...

		const Pair & olddata = nl.node->data;

		// check if the data in database is valid
		if (! newdata.valid(olddata) ){
			// newdata will be magically destroyed.
			return false;
		}

		dataSize_ = dataSize_
			- olddata.getBytes()
			+ newdata.getBytes();

		// copy assignment
		const_cast<Pair &>(olddata) = std::forward<UPAIR>(newdata);

		return true;
	}

	// create new node

	size_t const size = newdata.getBytes();
	height_type const height = _getRandomHeight();

	Node *newnode = new(height, true) Node(std::forward<UPAIR>(newdata));

	if (newnode == nullptr){
		// newdata will be magically destroyed.
		return false;
	}

	/* SEE REMARK ABOUT NEXT[] SIZE AT THE TOP */
	// newnode->height = height

	// place new node where it belongs

	for(height_type i = 0; i < height; ++i){
		if (nl.loc[i]){
			// we are at the middle
			const Node *node = nl.loc[i];

			newnode->next[i] = node->next[i];
			const_cast<Node *>(node)->next[i] = newnode;
		}else{
			newnode->next[i] = heads_[i];
			heads_[i] = newnode;
		}
	}

#ifdef DEBUG_PRINT_LANES
	printf("%3u Lanes-> ", height);
	for(height_type i = 0; i < height; ++i)
		printf("%p ", (void *) newnode->next[i]);
	printf("\n");
#endif

	/* SEE REMARK ABOUT NEXT[] SIZE AT THE TOP */
	// newnode->next[i] = NULL;

	dataSize_ += size;
	++dataCount_;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9f38
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x9a48
leaq 0x10(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x9534
movq (%r15), %r15
testq %r15, %r15
je 0x99c4
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0xa038
testb %al, %al
je 0x9a4b
movq 0x210(%rbx), %r12
movq %r15, %rdi
callq 0xa04c
subq %rax, %r12
movq %r14, %rdi
callq 0xa04c
addq %r12, %rax
movq %rax, 0x210(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ec6
jmp 0x9a48
movq %r14, %rdi
callq 0xa04c
movq %rax, %r15
movq %rbx, %rdi
callq 0x9654
movzbl %al, %r12d
pushq $0x10
popq %rdi
pushq $0x1
popq %rdx
movl %r12d, %esi
callq 0x9a60
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x9eba
shll $0x3, %r12d
xorl %eax, %eax
cmpq %rax, %r12
je 0x9a23
movq 0x18(%rsp,%rax), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq 0x8(%rcx,%rax), %rdx
movq %rdx, 0x8(%r13,%rax)
movq %r13, 0x8(%rcx,%rax)
addq $0x8, %rax
jmp 0x99fd
movdqu 0x208(%rbx), %xmm0
movq %r15, %xmm1
movdqa 0x17f8(%rip), %xmm2     # 0xb230
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x208(%rbx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::info[abi:cxx11]() const
std::string info() const{
		std::stringstream ss;

		ss	<< "Keys (estimated): "	<< list_.getCount(true)	<< '\n'
			<< "Size: "		<< list_.getBytes()	<< '\n'
		;

		return ss.str();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31a0
leaq 0x18(%rsp), %rdi
leaq 0x5557(%rip), %rsi      # 0xa1b7
callq 0x3290
movq %rax, %r15
movq (%r14), %rdi
callq 0x51d4
movq %r15, %rdi
movq %rax, %rsi
callq 0x3190
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3300
leaq 0x553d(%rip), %rsi      # 0xa1ca
movq %rax, %rdi
callq 0x3290
movq %rax, %r15
movq (%r14), %rdi
callq 0x51b4
movq %r15, %rdi
movq %rax, %rsi
callq 0x3190
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3300
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3400
leaq 0x8(%rsp), %rdi
callq 0x31e0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::get[abi:cxx11](StringRef const&) const
std::string get(const StringRef &key) const{
		const auto &p = list_.get(key);
		std::string s = p.getVal();
		std::cout << s << '\n';
		return s;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x5dd8
movq %r14, %rdi
callq 0x700e
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3b5e
movq 0xb2a3(%rip), %rdi      # 0xffd0
movq %rbx, %rsi
callq 0x3250
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3300
movq %rsp, %rdi
callq 0x6f68
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
jmp 0x4d63
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %rsp, %rdi
callq 0x6f68
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::getall[abi:cxx11](StringRef const&) const
std::vector<std::string> getall(const StringRef &key) const{
		std::vector<std::string> result;

		// reserve x2 because of hgetall
		result.reserve(maxResults_ * 2);

		const auto bit = list_.lowerBound(key);
		const auto eit = list_.end();

		size_t c = 0;
		for(auto it = bit; it != eit; ++it){
			result.push_back(it->getKey());
			result.push_back(es__(it->getVal()));

			if (++c >= maxResults_)
				break;
		}

		for(auto x : result)
			std::cout << x << '\n';

		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rsi
addq %rsi, %rsi
callq 0x5eee
movq (%r14), %rsi
leaq 0xb8(%rsp), %rdi
movq %r15, %rdx
callq 0x5f82
movq (%r14), %rsi
leaq 0x78(%rsp), %rdi
callq 0x51f4
leaq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x5f94
xorl %r12d, %r12d
leaq 0x38(%rsp), %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
leaq 0x78(%rsp), %rsi
callq 0x5208
testb %al, %al
je 0x4ea6
movq %r15, %rdi
callq 0x5212
movq %rax, %rdi
callq 0x6fec
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3b5e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x637e
movq %r13, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x5212
movq %rax, %rdi
callq 0x700e
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5fd8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x637e
movq %r13, %rdi
callq 0x3120
incq %r12
cmpq 0x10(%r14), %r12
jae 0x4ea6
movq %r15, %rdi
callq 0x5220
jmp 0x4e0b
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x525e
movq (%rbx), %r15
movq 0x8(%rbx), %r13
movq 0xb10f(%rip), %r12      # 0xffd0
pushq $0xa
popq %rbp
cmpq %r13, %r15
je 0x4ef7
movq %r14, %rdi
movq %r15, %rsi
callq 0x3360
movq %r12, %rdi
movq %r14, %rsi
callq 0x3250
movq %rax, %rdi
movl %ebp, %esi
callq 0x3300
movq %r14, %rdi
callq 0x3120
addq $0x20, %r15
jmp 0x4ec4
leaq 0x78(%rsp), %rdi
callq 0x525e
leaq 0xb8(%rsp), %rdi
callq 0x525e
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f42
movq %rax, %r14
jmp 0x4f71
jmp 0x4f2c
movq %rax, %r14
jmp 0x4f7e
jmp 0x4f33
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x3120
jmp 0x4f4e
movq %rax, %r14
jmp 0x4f67
jmp 0x4f4b
jmp 0x4f4b
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x525e
jmp 0x4f67
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x3120
leaq 0x78(%rsp), %rdi
callq 0x525e
leaq 0xb8(%rsp), %rdi
callq 0x525e
movq %rbx, %rdi
callq 0x4f8e
movq %r14, %rdi
callq 0x3460