LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: void iterator_test<hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>>(char const*, hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>&)
static void iterator_test(const char *module, LIST &list){
	auto it = list.begin();
	auto et = list.end();

	iterator_test_deref(module, it, et, "Niki"	);
	iterator_test_deref(module, it, et, "22"	);
	iterator_test_deref(module, it, et, "Sofia"	);
	iterator_test_deref(module, it, et, "Linux"	);

	PRINTF_TEST("*it end()",	it == et				);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0xcab0
movq 0x98(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xcae0
jmp 0x93ad
movq 0xa0(%rsp), %rdi
leaq 0xdcd9(%rip), %rcx      # 0x17095
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf060
jmp 0x93cd
movq 0xa0(%rsp), %rdi
leaq 0xdccf(%rip), %rcx      # 0x170ab
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf060
jmp 0x93ed
movq 0xa0(%rsp), %rdi
leaq 0xdc8c(%rip), %rcx      # 0x17088
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf060
jmp 0x940d
movq 0xa0(%rsp), %rdi
leaq 0xdc83(%rip), %rcx      # 0x1709f
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf060
jmp 0x942d
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xe250
movb %al, 0xb(%rsp)
jmp 0x944e
movq (%rsp), %rsi
movb 0xb(%rsp), %dl
leaq 0xdbca(%rip), %rax      # 0x17027
leaq 0xdbc6(%rip), %rcx      # 0x1702a
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0xdb92(%rip), %rdi      # 0x17004
leaq 0xdcf8(%rip), %rdx      # 0x17171
xorl %eax, %eax
callq 0x2030
jmp 0x9482
leaq 0x18(%rsp), %rdi
callq 0xcc50
leaq 0x58(%rsp), %rdi
callq 0xcc50
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x94c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xcc50
leaq 0x58(%rsp), %rdi
callq 0xcc50
movq 0x10(%rsp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: void iterator_get_test<hm3::STLVectorList>(char const*, hm3::STLVectorList&)
static void iterator_get_test(const char *module, LIST &list){
	iterator_get_test_deref(module, list, "1",	"Niki"	);
	iterator_get_test_deref(module, list, "1 name",	"Niki"	);
	iterator_get_test_deref(module, list, "2",	"22"	);
	iterator_get_test_deref(module, list, "2 age",	"22"	);
	iterator_get_test_deref(module, list, "3",	"Sofia"	);
	iterator_get_test_deref(module, list, "3 city",	"Sofia"	);
	iterator_get_test_deref(module, list, "4",	"Linux"	);
	iterator_get_test_deref(module, list, "4 os",	"Linux"	);
	iterator_get_test_deref(module, list, "5",	nullptr	);
	iterator_get_test_deref(module, list, "6",	nullptr	);

	iterator_get_test_deref(module, list, "",	nullptr	);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf953(%rip), %rdx      # 0x17162
leaq 0xf87f(%rip), %rcx      # 0x17095
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf862(%rip), %rdx      # 0x1708e
leaq 0xf862(%rip), %rcx      # 0x17095
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf926(%rip), %rdx      # 0x1716f
leaq 0xf85b(%rip), %rcx      # 0x170ab
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf83f(%rip), %rdx      # 0x170a5
leaq 0xf83e(%rip), %rcx      # 0x170ab
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf904(%rip), %rdx      # 0x17187
leaq 0xf7fe(%rip), %rcx      # 0x17088
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf7e1(%rip), %rdx      # 0x17081
leaq 0xf7e1(%rip), %rcx      # 0x17088
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf8cc(%rip), %rdx      # 0x17189
leaq 0xf7db(%rip), %rcx      # 0x1709f
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf7c0(%rip), %rdx      # 0x1709a
leaq 0xf7be(%rip), %rcx      # 0x1709f
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf894(%rip), %rdx      # 0x1718b
xorl %eax, %eax
movl %eax, %ecx
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf87c(%rip), %rdx      # 0x1718d
xorl %eax, %eax
movl %eax, %ecx
callq 0xa8b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf99d(%rip), %rdx      # 0x172c8
xorl %eax, %eax
movl %eax, %ecx
callq 0xa8b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: void ref_test<hm3::STLVectorList>(char const*, hm3::STLVectorList&)
static void ref_test(const char *module, LIST &list){
	const char *key = "ref_test";

	const Pair p = Pair::tombstone(key);
	p.print();

	list.put(p);

	p.print();

	list.get(key).print();

	p.print();

	list.remove(key);

	p.print();

	PRINTF_TEST("ref test",		true					);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
leaq 0xf85f(%rip), %rax      # 0x171ba
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x98c0
movq 0x18(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xab50
movq 0x20(%rsp), %rdi
callq 0x150a0
movq 0x20(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0xa1f0
jmp 0x79a3
leaq 0x68(%rsp), %rdi
callq 0x150a0
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x98c0
jmp 0x79c8
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf8d0
movq %rax, 0x8(%rsp)
jmp 0x79de
movq 0x8(%rsp), %rdi
callq 0x150a0
leaq 0x68(%rsp), %rdi
callq 0x150a0
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x98c0
jmp 0x7a0c
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf990
jmp 0x7a1c
leaq 0x68(%rsp), %rdi
callq 0x150a0
movq 0x80(%rsp), %rsi
leaq 0xf5cf(%rip), %rdi      # 0x17004
leaq 0xf787(%rip), %rdx      # 0x171c3
leaq 0xf5e4(%rip), %rcx      # 0x17027
xorl %eax, %eax
callq 0x2030
jmp 0x7a4c
leaq 0x68(%rsp), %rdi
callq 0x14a60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x14a60
movq 0x50(%rsp), %rdi
callq 0x2220
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0xcaa0
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xcab0
movq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xcae0
jmp 0xc512
jmp 0xc514
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xcb10
movb %al, 0x17(%rsp)
jmp 0xc529
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xc56d
jmp 0xc533
movl $0x2, 0x20(%rsp)
jmp 0xc5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xc5df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xcc50
jmp 0xc5df
leaq 0x70(%rsp), %rdi
callq 0xcb40
movq %rax, 0x8(%rsp)
jmp 0xc57e
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x150a0
movq 0xb8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xb8(%rsp)
cmpq $0x0, %rax
jne 0xc5b6
movl $0x1, 0x20(%rsp)
jmp 0xc5c9
jmp 0xc5b8
leaq 0x70(%rsp), %rdi
callq 0xcb80
jmp 0xc5c4
jmp 0xc514
leaq 0x30(%rsp), %rdi
callq 0xcc50
leaq 0x70(%rsp), %rdi
callq 0xcc50
jmp 0xc5eb
leaq 0x70(%rsp), %rdi
callq 0xcc50
jmp 0xc5f3
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2220
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/hashlist_impl.h
// Function: hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::get(StringRef const&) const
const Pair &HashList<CONTAINER>::get(const StringRef &key) const{
	if (key.empty())
		return Pair::zero();

	const auto index = getBucketForKey_(key);

	return container_[index].get(key);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa220
testb $0x1, %al
jne 0xc407
jmp 0xc413
callq 0x9b60
movq %rax, 0x20(%rsp)
jmp 0xc446
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc8f0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0xca80
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x13490
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: nmmmnu[P]HM3/hm3/hashlist_impl.h
// Function: hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::remove(StringRef const&)
bool HashList<CONTAINER>::remove(const StringRef &key){
	if (key.empty())
		return true;

	const auto index = getBucketForKey_(key);

	return container_[index].remove(key);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa220
testb $0x1, %al
jne 0xc477
jmp 0xc47e
movb $0x1, 0x27(%rsp)
jmp 0xc4b2
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc8f0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0xc950
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x13620
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/hashlist_impl.h
// Function: hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::getCount(bool) const
auto HashList<CONTAINER>::getCount(bool const estimated) const noexcept -> size_type{
	size_type result = 0;

	for(const auto &list : container_){
		result += list.getCount(estimated);
	}

	return result;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcf50
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcf80
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcfb0
testb $0x1, %al
jne 0xc658
jmp 0xc68e
leaq 0x10(%rsp), %rdi
callq 0xcff0
movq %rax, (%rsp)
movq (%rsp), %rdi
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xb890
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xd0a0
jmp 0xc643
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/hashlist_impl.h
// Function: hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::getBytes() const
size_t HashList<CONTAINER>::getBytes() const noexcept{
	size_t result = 0;

	for(const auto &list : container_)
		result += list.getBytes();

	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcf50
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcf80
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcfb0
testb $0x1, %al
jne 0xc70f
jmp 0xc73e
leaq 0x18(%rsp), %rdi
callq 0xcff0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xb8d0
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd0a0
jmp 0xc6fa
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/hashlist_impl.h
// Function: bool hm3::HashList<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::putT_<hm3::Pair const&>(hm3::Pair const&)
bool HashList<CONTAINER>::putT_(UPAIR &&pair){
	if (pair == false)
		return true;

	const StringRef &key = pair.getKey();

	const auto index = getBucketForKey_(key);

	return container_[index].put(std::forward<UPAIR>(pair));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x9940
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc883
movb $0x1, 0x47(%rsp)
jmp 0xc8d7
movq 0x30(%rsp), %rdi
callq 0x14c40
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0xc8f0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0xc950
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0xb7c0
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcb40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x9940
testb $0x1, %al
jne 0xcbbe
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movq %rax, 0x40(%rsp)
jmp 0xcc46
movq 0x8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xeb50
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe9d0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xeee0
testb $0x1, %al
jne 0xcbff
jmp 0xcc34
leaq 0x20(%rsp), %rdi
callq 0xef20
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0xef30
movq %rax, %rdi
callq 0xef50
leaq 0x20(%rsp), %rdi
callq 0xef60
jmp 0xcbea
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0xce20
movq 0x20(%rsp), %rdi
movb $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0xce30
movq 0x78(%rsp), %rdi
callq 0xc9b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xce40
jmp 0xcd30
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcf50
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcf80
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcfb0
testb $0x1, %al
jne 0xcd6d
jmp 0xcde8
leaq 0x48(%rsp), %rdi
callq 0xcff0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movq 0x70(%rsp), %rax
movzbl (%rax), %edx
andl $0x1, %edx
leaq 0x28(%rsp), %rdi
callq 0xd030
jmp 0xcda5
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd000
jmp 0xcdb6
jmp 0xcdb8
leaq 0x48(%rsp), %rdi
callq 0xd0a0
jmp 0xcd58
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0xd1d0
movq 0x20(%rsp), %rdi
callq 0xd230
jmp 0xce15
movq 0x10(%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
callq 0xc9b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xd0c0
jmp 0xce0d
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2220
nop
// File: nmmmnu[P]HM3/hm3/multitableiterator/collectioniterator_impl.h
// Function: hm3::multitableiterator::CollectionIterator<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>>::operator==(hm3::multitableiterator::CollectionIterator<std::vector<hm3::SkipList, std::allocator<hm3::SkipList>>> const&) const
bool CollectionIterator<CONTAINER>::operator==(const CollectionIterator &other) const{
	if (it_.size() != other.it_.size())
		return false;

	// this seems to skip the loop faster
	if (ended_ || other.ended_)
		return true;

	for(size_type i = 0; i < it_.size(); ++i){
		if (it_[i] != other.it_[i])
			return false;
	}

	return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd3c0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd3c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0xe293
movb $0x0, 0x47(%rsp)
jmp 0xe32e
movq 0x18(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0xe2a9
movq 0x30(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0xe2b0
movb $0x1, 0x47(%rsp)
jmp 0xe32e
movq $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xd3c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xe329
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xe340
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xe340
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xe360
testb $0x1, %al
jne 0xe310
jmp 0xe317
movb $0x0, 0x47(%rsp)
jmp 0xe32e
jmp 0xe319
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xe2b9
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce30
movq $0x0, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xd3c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0xe569
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xe340
movq %rax, %rdi
callq 0xe5f0
movq %rax, 0x18(%rsp)
jmp 0xe465
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x9940
testb $0x1, %al
jne 0xe49f
jmp 0xe556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd1d0
jmp 0xe5e5
cmpq $0x0, 0x58(%rsp)
jne 0xe4d6
leaq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe640
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe660
jmp 0xe4c7
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0xe556
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xe6d0
movl %eax, 0x38(%rsp)
cmpl $0x0, 0x38(%rsp)
jge 0xe51c
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe640
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe660
jmp 0xe510
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0xe556
cmpl $0x0, 0x38(%rsp)
jne 0xe554
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe660
jmp 0xe534
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x14f30
cmpl $0x0, %eax
jle 0xe552
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0xe554
jmp 0xe556
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0xe422
cmpq $0x0, 0x58(%rsp)
je 0xe5a8
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rdi)
addq $0x28, %rdi
leaq 0x60(%rsp), %rsi
callq 0xe710
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x80(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0xe5cb
movq 0x28(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x20(%rax)
callq 0x9b60
movq %rax, 0x80(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd1d0
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2220
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xfc50
andb $0x1, %al
movb %al, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xf9ca
movb $0x1, 0x57(%rsp)
jmp 0xfa3e
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xfca0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15050
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rdi), %rax
subq %rcx, %rax
movq %rax, 0x18(%rdi)
callq 0x10290
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x102c0
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10370
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x10300
movq %rax, 0x8(%rsp)
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rdi
callq 0x14c40
movq 0x28(%rsp), %rdi
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0xfc50
andb $0x1, %al
movb %al, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
je 0xfb64
movq 0x28(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xfca0
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rdi
movq 0x60(%rsp), %rsi
xorl %edx, %edx
callq 0xfcc0
testb $0x1, %al
jne 0xfafc
movb $0x0, 0xa7(%rsp)
jmp 0xfc36
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x15050
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rdi
callq 0x15050
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq 0x90(%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0x14aa0
movb $0x1, 0xa7(%rsp)
jmp 0xfc36
movq 0x90(%rsp), %rdi
callq 0x15050
movq 0x28(%rsp), %rdi
addq 0x18(%rdi), %rax
movq %rax, 0x18(%rdi)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xa5b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0xfbd7
movq 0x28(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xfcf0
jmp 0xfbae
jmp 0xfc2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2070
movb $0x0, 0xa7(%rsp)
callq 0x21f0
jmp 0xfc36
movq 0x28(%rsp), %rdi
callq 0xa520
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0xfd20
movq 0x28(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rdx
movq 0x38(%rsp), %rsi
callq 0xfd60
movq %rax, 0x8(%rsp)
jmp 0xfc22
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xfc2e
movb $0x1, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x1, %esi
callq 0x11f50
testb $0x1, %al
jne 0x11b4c
movb $0x0, 0x27(%rsp)
jmp 0x11ba4
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11b9f
movq (%rsp), %rax
movq 0x18(%rax), %rcx
subq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
callq 0x21e0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
je 0x11c4a
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11c4a
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x21a0
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
leaq 0x28(%rsp), %rdi
callq 0x123e0
leaq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x12410
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x12420
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x11d6d
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14a60
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x11d3d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x11c10
movb $0x1, %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x12230
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x11e7a
movb $0x1, 0x37(%rsp)
jmp 0x11ecc
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x15050
movq %rax, %rdx
movq (%rsp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rdi
callq 0x14a60
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11ee0
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x18(%rax), %rdx
subq 0x8(%rsp), %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
callq 0x21e0
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11f50
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x11f78
movb $0x1, 0x47(%rsp)
jmp 0x1206b
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x11f95
cmpl $0x0, 0x34(%rsp)
jge 0x11f95
movb $0x1, 0x47(%rsp)
jmp 0x1206b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x124b0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x11fdf
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11c10
movb $0x1, 0x47(%rsp)
jmp 0x1206b
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x12080
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x1201b
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, 0x47(%rsp)
jmp 0x1206b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
shlq $0x3, %rsi
callq 0x2200
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x12046
movb $0x0, 0x47(%rsp)
jmp 0x1206b
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::calcNewCount_(unsigned long)
auto VectorList::calcNewCount_(size_type const count) -> size_type{
	size_type newsize = count / reallocCount_;

	if (count % reallocCount_)
		++newsize;

	return newsize * reallocCount_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
xorl %edx, %edx
divq (%rcx)
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
xorl %edx, %edx
divq (%rcx)
cmpq $0x0, %rdx
je 0x120c1
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
imulq (%rcx), %rax
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x14c40
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x12230
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x121be
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0xfcc0
testb $0x1, %al
jne 0x12164
movb $0x0, 0x67(%rsp)
jmp 0x1221b
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x15050
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x15050
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x14aa0
movb $0x1, 0x67(%rsp)
jmp 0x1221b
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x11b20
testb $0x1, %al
jne 0x121d8
movb $0x0, 0x67(%rsp)
jmp 0x1221b
movq 0x50(%rsp), %rdi
callq 0x15050
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x14a70
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x127e3
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x127e1
movq (%rsp), %rdi
callq 0x12ff0
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x2190
jmp 0x1279b
movq 0x8(%rsp), %rdi
callq 0x12700
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x128ea
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xebb0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x128ab
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x128f3
cmpl $0x0, 0x14(%rsp)
jle 0x128d8
testb $0x1, 0x2f(%rsp)
je 0x128c2
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x128cc
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x128f3
jmp 0x128da
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x12873
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x28(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x12a06
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xebb0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x129e0
cmpq $0x0, 0x28(%rsp)
je 0x12979
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1298a
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x15050
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x129d9
movq (%rsp), %rdi
callq 0x12ff0
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x2190
movb $0x1, 0x47(%rsp)
jmp 0x12a0b
cmpl $0x0, 0x14(%rsp)
jle 0x129e9
jmp 0x12a06
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x12929
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x1f(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x1f(%rsp), %ecx
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
jge 0x1328f
leaq 0xbec2(%rip), %rdi      # 0x1f148
callq 0x140d0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x13299
jmp 0x132a5
movb 0x1f(%rsp), %al
addb $0x1, %al
movb %al, 0x1f(%rsp)
jmp 0x13268
movb 0x1f(%rsp), %al
addq $0x28, %rsp
retq
nop
// File: nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::SkipList(unsigned char)
SkipList::SkipList(height_type height){
	if (height == 0 || height > MAX_HEIGHT)
		height = DEFAULT_HEIGHT;

	height_ = height;

	clear_();
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x0, %eax
je 0x132dd
movzbl 0xf(%rsp), %eax
cmpl $0x40, %eax
jle 0x132e2
movb $0x20, 0xf(%rsp)
movq (%rsp), %rdi
movb 0xf(%rsp), %al
movb %al, (%rdi)
callq 0x13300
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13cc0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x13470
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1346e
movq (%rsp), %rdi
callq 0x14030
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x2190
jmp 0x13428
movq 0x8(%rsp), %rdi
callq 0x13300
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x228(%rsp)
movq %rsi, 0x220(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x220(%rsp), %rdi
callq 0xa220
testb $0x1, %al
jne 0x134c7
jmp 0x134d6
callq 0x9b60
movq %rax, 0x230(%rsp)
jmp 0x1351a
movq 0x10(%rsp), %rsi
movq 0x220(%rsp), %rdx
leaq 0x18(%rsp), %rdi
xorl %ecx, %ecx
callq 0x13000
cmpq $0x0, 0x18(%rsp)
je 0x13503
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1350d
callq 0x9b60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rax
addq $0x238, %rsp            # imm = 0x238
retq
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::lowerBound(StringRef const&) const
SkipList::Iterator SkipList::lowerBound(const StringRef &key) const{
	if (key.empty())
		return end();

	const auto nl = locate_(key);

	if (nl.node)
		return Iterator(nl.node);

	const Node *prev = nl.loc[0];

	if (prev)
		return Iterator(prev->next[0]);
	else
		return Iterator(heads_[0]);
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x228(%rsp)
movq %rsi, 0x220(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x220(%rsp), %rdi
callq 0xa220
testb $0x1, %al
jne 0x13567
jmp 0x1357e
movq 0x8(%rsp), %rdi
callq 0xb980
movq %rax, 0x230(%rsp)
jmp 0x1360f
movq 0x8(%rsp), %rsi
movq 0x220(%rsp), %rdx
leaq 0x18(%rsp), %rdi
xorl %ecx, %ecx
callq 0x13000
cmpq $0x0, 0x18(%rsp)
je 0x135b3
movq 0x18(%rsp), %rsi
leaq 0x230(%rsp), %rdi
callq 0xba10
jmp 0x1360f
leaq 0x18(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13c90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x135ed
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x230(%rsp), %rdi
callq 0xba10
jmp 0x1360f
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb9e0
movq (%rax), %rsi
leaq 0x230(%rsp), %rdi
callq 0xba10
movq 0x230(%rsp), %rax
addq $0x238, %rsp            # imm = 0x238
retq
nop
// File: nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::remove(StringRef const&)
bool SkipList::remove(const StringRef &key){
	if (key.empty())
		return true;

	const auto nl = locate_(key, true);

	if (nl.node == nullptr)
		return true;

	for(height_type i = 0; i < height_; ++i){
		const Node *prev = nl.loc[i];

		if (prev){
			// check if lane go to this node...
			if (prev->next[i] == nl.node)
				const_cast<Node *>(prev)->next[i] = nl.node->next[i];
		}else{
			// must be first
			if (heads_[i] == nl.node)
				heads_[i] = nl.node->next[i];
		}
	}

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

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

	delete nl.node;

	return true;
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x248(%rsp)
movq %rsi, 0x240(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x240(%rsp), %rdi
callq 0xa220
testb $0x1, %al
jne 0x13657
jmp 0x13664
movb $0x1, 0x257(%rsp)
jmp 0x137dd
movq 0x18(%rsp), %rsi
movq 0x240(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movl $0x1, %ecx
callq 0x13000
cmpq $0x0, 0x38(%rsp)
jne 0x13695
movb $0x1, 0x257(%rsp)
jmp 0x137dd
movb $0x0, 0x37(%rsp)
movq 0x18(%rsp), %rcx
movzbl 0x37(%rsp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x1376d
leaq 0x38(%rsp), %rdi
addq $0x8, %rdi
movzbl 0x37(%rsp), %eax
movl %eax, %esi
callq 0x13c90
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1370a
movq 0x28(%rsp), %rax
movzbl 0x37(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rax
cmpq 0x38(%rsp), %rax
jne 0x13708
movq 0x38(%rsp), %rax
movzbl 0x37(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movzbl 0x37(%rsp), %ecx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x1375c
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movzbl 0x37(%rsp), %eax
movl %eax, %esi
callq 0x13cc0
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
jne 0x1375a
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movzbl 0x37(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movzbl 0x37(%rsp), %eax
movl %eax, %esi
callq 0x13cc0
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1375c
jmp 0x1375e
movb 0x37(%rsp), %al
addb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x1369a
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15050
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x210(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x210(%rax)
movq 0x208(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x208(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x137d5
movq 0x8(%rsp), %rdi
callq 0x14030
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x2190
movb $0x1, 0x257(%rsp)
movb 0x257(%rsp), %al
andb $0x1, %al
addq $0x258, %rsp            # imm = 0x258
retq
nop
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq $0x0, 0x10(%rsp)
addq $0x8, %rdi
movzbl 0x1f(%rsp), %eax
movl %eax, %esi
callq 0xb9e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x138ce
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x150a0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0xa, %rax
jbe 0x138b6
jmp 0x138ce
jmp 0x138b8
movq 0x8(%rsp), %rax
movzbl 0x1f(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x13886
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::Node::operator new(unsigned long, unsigned char, bool)
static void *operator new(size_t size, height_type const height, bool const nothrow = false) {
		size += (height - 1) * sizeof(Node *);

		if (nothrow)
			return ::operator new(size, std::nothrow);

		return ::operator new(size);
	}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x8(%rsp)
movb %cl, 0x7(%rsp)
andb $0x1, %al
movb %al, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
subl $0x1, %eax
cltq
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x6(%rsp)
je 0x13c3f
movq 0x8(%rsp), %rdi
movq 0xb38d(%rip), %rsi      # 0x1efc0
callq 0x2230
movq %rax, 0x10(%rsp)
jmp 0x13c4e
movq 0x8(%rsp), %rdi
callq 0x2180
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/main/db_net.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	std::cout
		<< "Usage:"	<< '\n'
		<< "\t"		<< cmd	<< " [lsm_path] - start server"		<< '\n'

		<< "\t\tPath names must be written without extention"		<< '\n'
		<< "\t\tExample 'directory/file.*'"				<< '\n'

		<< '\n';
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq 0x205d4(%rip), %rdi     # 0x23fd0
leaq 0x15678(%rip), %rsi     # 0x1907b
callq 0x3300
movq %rax, %rdi
movl $0xa, %esi
callq 0x3370
movq %rax, %rdi
leaq 0x15663(%rip), %rsi     # 0x19082
callq 0x3300
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x3300
movq %rax, %rdi
leaq 0x1564a(%rip), %rsi     # 0x19084
callq 0x3300
movq %rax, %rdi
movl $0xa, %esi
callq 0x3370
movq %rax, %rdi
leaq 0x15649(%rip), %rsi     # 0x1909f
callq 0x3300
movq %rax, %rdi
movl $0xa, %esi
callq 0x3370
movq %rax, %rdi
leaq 0x1565c(%rip), %rsi     # 0x190ce
callq 0x3300
movq %rax, %rdi
movl $0xa, %esi
callq 0x3370
movq %rax, %rdi
movl $0xa, %esi
callq 0x3370
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)