LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_insert_node
static tommy_tree_node* tommy_tree_insert_node(tommy_compare_func* cmp, tommy_tree_node* root, tommy_tree_node** let)
{
	int c;

	if (!root)
		return *let;

	c = cmp((*let)->data, root->data);

	if (c < 0) {
		root->prev = tommy_tree_insert_node(cmp, root->prev, let);
		return tommy_tree_balance(root);
	}

	if (c > 0) {
		root->next = tommy_tree_insert_node(cmp, root->next, let);
		return tommy_tree_balance(root);
	}

	/* already present, set the return pointer */
	*let = root;

	return root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rax
testq %rsi, %rsi
je 0x1f98
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rax), %rdi
movq 0x10(%rsi), %rsi
callq *%r15
testl %eax, %eax
js 0x1f9d
je 0x1fbd
movq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x1f5e
movq %rax, (%rbx)
jmp 0x1fb0
movq %rax, %rbx
jmp 0x1fc0
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x1f5e
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x308d
movq %rbx, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_remove
void* tommy_tree_remove(tommy_tree* tree, void* data)
{
	tommy_tree_node* node = 0;

	tree->root = tommy_tree_remove_node(tree->cmp, tree->root, data, &node);

	if (!node)
		return 0;

	--tree->count;

	return node->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %r14
andq $0x0, (%r14)
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rdi
movq %r14, %rcx
callq 0x2007
movq %rax, (%rbx)
movq (%r14), %rax
testq %rax, %rax
je 0x1ffd
decl 0x8(%rbx)
movq 0x10(%rax), %rax
jmp 0x1fff
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_remove_node
static tommy_tree_node* tommy_tree_remove_node(tommy_compare_func* cmp, tommy_tree_node* root, void* data, tommy_tree_node** let)
{
	int c;

	if (!root)
		return 0;

	c = cmp(data, root->data);

	if (c < 0) {
		root->prev = tommy_tree_remove_node(cmp, root->prev, data, let);
		return tommy_tree_balance(root);
	}

	if (c > 0) {
		root->next = tommy_tree_remove_node(cmp, root->next, data, let);
		return tommy_tree_balance(root);
	}

	/* found */
	*let = root;

	return tommy_tree_move_right(root->prev, root->next);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2046
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %rsi
movq %rdx, %rdi
callq *%r12
testl %eax, %eax
js 0x2054
je 0x207d
movq (%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2007
movq %rax, (%rbx)
jmp 0x206a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2007
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x308d
movq %rbx, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x318a
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_search_node
static tommy_tree_node* tommy_tree_search_node(tommy_compare_func* cmp, tommy_tree_node* root, void* data)
{
	int c;

	if (!root)
		return 0;

	c = cmp(data, root->data);

	if (c < 0)
		return tommy_tree_search_node(cmp, root->prev, data);

	if (c > 0)
		return tommy_tree_search_node(cmp, root->next, data);

	return root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rbx, %rbx
je 0x20e4
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq *%r15
testl %eax, %eax
js 0x20db
jne 0x20df
jmp 0x20e4
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0x20c4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_foreach_node
static void tommy_tree_foreach_node(tommy_tree_node* root, tommy_foreach_func* func)
{
	tommy_tree_node* next;

	if (!root)
		return;

	tommy_tree_foreach_node(root->prev, func);

	/* make a copy in case func is free() */
	next = root->next;

	func(root->data);

	tommy_tree_foreach_node(next, func);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x216a
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2140
movq (%r14), %r15
movq 0x10(%r14), %rdi
callq *%rbx
movq %r15, %r14
jmp 0x214b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_foreach_arg_node
static void tommy_tree_foreach_arg_node(tommy_tree_node* root, tommy_foreach_arg_func* func, void* arg)
{
	tommy_tree_node* next;

	if (!root)
		return;

	tommy_tree_foreach_arg_node(root->prev, func, arg);

	/* make a copy in case func is free() */
	next = root->next;

	func(arg, root->data);

	tommy_tree_foreach_arg_node(next, func, arg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0x21ac
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2175
movq (%r15), %r12
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq *%r14
movq %r12, %r15
jmp 0x2186
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_insert
void tommy_trie_insert(tommy_trie* trie, tommy_trie_node* node, void* data, tommy_key_t key)
{
	tommy_trie_node** let_ptr;

	node->data = data;
	node->key = key;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	trie_bucket_insert(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	++trie->count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
movl %ecx, %eax
shrl $0x1b, %eax
leaq (%rdi,%rax,8), %r13
pushq $0x1b
popq %r15
movq (%r13), %r12
testq %r12, %r12
je 0x22aa
testb $0x1, %r12b
je 0x2233
movl %ebp, %eax
movl %r15d, %ecx
shrl %cl, %eax
andl $0x7, %eax
leaq (%r12,%rax,8), %r13
decq %r13
addl $-0x3, %r15d
jmp 0x2209
cmpl %ebp, 0x18(%r12)
jne 0x2252
movq 0x8(%r12), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x8(%r12)
andq $0x0, (%r14)
movq 0x8(%r14), %r13
jmp 0x22b2
movq 0x108(%rbx), %rdi
callq 0x198f
incl 0x104(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, (%r13)
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x227e
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x226e
movl 0x18(%r12), %esi
movl %r15d, %ecx
shrl %cl, %esi
movl %ebp, %edx
shrl %cl, %edx
andl $0x7, %esi
andl $0x7, %edx
leaq (%rax,%rsi,8), %r13
cmpl %edx, %esi
jne 0x22a0
addl $-0x3, %r15d
jmp 0x2252
movq %r12, (%r13)
movl %edx, %ecx
leaq (%rax,%rcx,8), %r13
movq %r14, 0x8(%r14)
andq $0x0, (%r14)
movq %r14, (%r13)
incl 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_remove
void* tommy_trie_remove(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* ret;
	tommy_trie_node** let_ptr;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, 0, key);

	if (!ret)
		return 0;

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ecx
movq %rdi, %rbx
movl %esi, %eax
shrl $0x1b, %eax
leaq (%rdi,%rax,8), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x2301
testq %rax, %rax
je 0x22f6
decl 0x100(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_remove_existing
void* tommy_trie_remove_existing(tommy_trie* trie, tommy_trie_node* node)
{
	tommy_trie_node* ret;
	tommy_key_t key = node->key;
	tommy_trie_node** let_ptr;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	/* the element removed must match the one passed */
	assert(ret == node);

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %ecx
movl %ecx, %eax
shrl $0x1b, %eax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x2301
cmpq %r14, %rax
jne 0x244a
decl 0x100(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d29(%rip), %rdi      # 0x417a
leaq 0x1d2e(%rip), %rsi      # 0x4186
leaq 0x1d35(%rip), %rcx      # 0x4194
movl $0x118, %edx            # imm = 0x118
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_init
void tommy_trie_inplace_init(tommy_trie_inplace* trie_inplace)
{
	tommy_uint_t i;

	for (i = 0; i < TOMMY_TRIE_INPLACE_BUCKET_MAX; ++i)
		trie_inplace->bucket[i] = 0;

	trie_inplace->count = 0;
}

// Assembly:
xorl %eax, %eax
cmpq $0x40, %rax
je 0x24cb
andq $0x0, (%rdi,%rax,8)
incq %rax
jmp 0x24bb
andl $0x0, 0x200(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_insert
void tommy_trie_inplace_insert(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node, void* data, tommy_key_t key)
{
	tommy_trie_inplace_node** let_ptr;
	tommy_uint_t i;

	node->data = data;
	node->key = key;
	/* clear the child pointers */
	for (i = 0; i < TOMMY_TRIE_INPLACE_TREE_MAX; ++i)
		node->map[i] = 0;

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	trie_inplace_bucket_insert(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

	++trie_inplace->count;
}

// Assembly:
movl %ecx, %eax
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
pushq $0x4
popq %rcx
cmpq $0x8, %rcx
je 0x24ef
andq $0x0, (%rsi,%rcx,8)
incq %rcx
jmp 0x24df
movl %eax, %ecx
shrl $0x1a, %ecx
leaq (%rdi,%rcx,8), %rdx
pushq $0x1a
popq %rcx
movq (%rdx), %r8
testq %r8, %r8
je 0x251d
cmpl %eax, 0x18(%r8)
je 0x2527
movl %eax, %edx
shrl %cl, %edx
andl $0x3, %edx
leaq (%r8,%rdx,8), %rdx
addq $0x20, %rdx
addl $-0x2, %ecx
jmp 0x24fb
movq %rsi, 0x8(%rsi)
andq $0x0, (%rsi)
jmp 0x253b
movq 0x8(%r8), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r8)
andq $0x0, (%rsi)
movq 0x8(%rsi), %rdx
movq %rsi, (%rdx)
incl 0x200(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_remove
void* tommy_trie_inplace_remove(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* ret;
	tommy_trie_inplace_node** let_ptr;

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	ret = trie_inplace_bucket_remove(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, 0, key);

	if (!ret)
		return 0;

	--trie_inplace->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
movl %esi, %eax
shrl $0x1a, %eax
leaq (%rdi,%rax,8), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x257b
testq %rax, %rax
je 0x2570
decl 0x200(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: trie_inplace_bucket_remove
static tommy_trie_inplace_node* trie_inplace_bucket_remove(tommy_uint_t shift, tommy_trie_inplace_node** let_ptr, tommy_trie_inplace_node* remove, tommy_key_t key)
{
	tommy_trie_inplace_node* node;
	int i;
	tommy_trie_inplace_node** leaf_let_ptr;
	tommy_trie_inplace_node* leaf;

	node = *let_ptr;
	while (node && node->key != key) {
		let_ptr = &node->map[(key >> shift) & TOMMY_TRIE_INPLACE_TREE_MASK];
		node = *let_ptr;
		shift -= TOMMY_TRIE_INPLACE_TREE_BIT;
	}

	if (!node)
		return 0;

	/* if the node to remove is not specified */
	if (!remove)
		remove = node; /* remove the first */

	tommy_trie_inplace_list_remove(let_ptr, remove);

	/* if not change in the node, nothing more to do */
	if (*let_ptr == node)
		return remove;

	/* if we have a substitute */
	if (*let_ptr != 0) {
		/* copy the child pointers to the new one */
		node = *let_ptr;
		for (i = 0; i < TOMMY_TRIE_INPLACE_TREE_MAX; ++i)
			node->map[i] = remove->map[i];

		return remove;
	}

	/* find a leaf */
	leaf_let_ptr = 0;
	leaf = remove;

	/* search backward, statistically we have more zeros than ones */
	i = TOMMY_TRIE_INPLACE_TREE_MAX - 1;
	while (i >= 0) {
		if (leaf->map[i]) {
			leaf_let_ptr = &leaf->map[i];
			leaf = *leaf_let_ptr;
			i = TOMMY_TRIE_INPLACE_TREE_MAX - 1;
			continue;
		}
		--i;
	}

	/* if it's itself a leaf */
	if (!leaf_let_ptr)
		return remove;

	/* remove the leaf */
	*leaf_let_ptr = 0;

	/* copy the child pointers */
	for (i = 0; i < TOMMY_TRIE_INPLACE_TREE_MAX; ++i)
		leaf->map[i] = remove->map[i];

	/* put it in place */
	*let_ptr = leaf;

	return remove;
}

// Assembly:
movq %rsi, %rax
pushq $0x1a
popq %rcx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x25a2
cmpl %edx, 0x18(%rsi)
je 0x25a5
movl %edx, %edi
shrl %cl, %edi
andl $0x3, %edi
leaq (%rsi,%rdi,8), %rdi
addq $0x20, %rdi
addl $-0x2, %ecx
jmp 0x2581
xorl %eax, %eax
retq
testq %rax, %rax
cmoveq %rsi, %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
testq %rcx, %rcx
movq %rcx, %r8
cmoveq %rsi, %r8
movq %rdx, 0x8(%r8)
cmpq %rax, %rsi
cmoveq %rdi, %rdx
movq %rcx, (%rdx)
movq (%rdi), %rcx
cmpq %rsi, %rcx
je 0x263c
testq %rcx, %rcx
je 0x25ee
pushq $0x4
popq %rdx
cmpq $0x8, %rdx
je 0x263c
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
jmp 0x25db
xorl %edx, %edx
pushq $0x3
popq %rsi
movq %rax, %rcx
leaq 0x20(%rcx), %r8
movl %esi, %r9d
testl %r9d, %r9d
js 0x261a
movl %r9d, %r10d
movq (%r8,%r10,8), %r11
decl %r9d
testq %r11, %r11
je 0x25fd
leaq (%r8,%r10,8), %rdx
movq %r11, %rcx
jmp 0x25f6
testq %rdx, %rdx
je 0x263c
andq $0x0, (%rdx)
pushq $0x4
popq %rdx
cmpq $0x8, %rdx
je 0x2639
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
jmp 0x2626
movq %rcx, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_remove_existing
void* tommy_trie_inplace_remove_existing(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node)
{
	tommy_trie_inplace_node* ret;
	tommy_key_t key = node->key;
	tommy_trie_inplace_node** let_ptr;

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	ret = trie_inplace_bucket_remove(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

	/* the element removed must match the one passed */
	assert(ret == node);

	--trie_inplace->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %edx
movl %edx, %eax
shrl $0x1a, %eax
leaq (%rdi,%rax,8), %rdi
callq 0x257b
cmpq %r14, %rax
jne 0x266f
decl 0x200(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b04(%rip), %rdi      # 0x417a
leaq 0x1b59(%rip), %rsi      # 0x41d6
leaq 0x1b63(%rip), %rcx      # 0x41e7
movl $0xf3, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_bucket
tommy_trie_inplace_node* tommy_trie_inplace_bucket(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* node;
	tommy_uint_t shift;

	node = trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];
	shift = TOMMY_TRIE_INPLACE_BUCKET_SHIFT;

	while (node && node->key != key) {
		node = node->map[(key >> shift) & TOMMY_TRIE_INPLACE_TREE_MASK];
		shift -= TOMMY_TRIE_INPLACE_TREE_BIT;
	}

	return node;
}

// Assembly:
movl %esi, %eax
shrl $0x1a, %eax
leaq (%rdi,%rax,8), %rax
pushq $0x1a
popq %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x26bb
cmpl %esi, 0x18(%rax)
je 0x26bb
movl %esi, %edx
shrl %cl, %edx
andl $0x3, %edx
leaq (%rax,%rdx,8), %rax
addq $0x20, %rax
addl $-0x2, %ecx
jmp 0x269a
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_init
void tommy_hashtable_init(tommy_hashtable* hashtable, tommy_count_t bucket_max)
{
	if (bucket_max < 16)
		bucket_max = 16;
	else
		bucket_max = tommy_roundup_pow2_u32(bucket_max);

	hashtable->bucket_max = bucket_max;
	hashtable->bucket_mask = hashtable->bucket_max - 1;

	/* initialize the vector using malloc()+memset() instead of calloc() */
	/* to ensure that all the memory in really allocated immediately */
	/* by the OS, and not deferred at later time. */
	/* this improves performance, because we start with a fully initialized hashtable. */
	hashtable->bucket = tommy_cast(tommy_hashtable_node**, tommy_malloc(hashtable->bucket_max * sizeof(tommy_hashtable_node*)));
	memset(hashtable->bucket, 0, hashtable->bucket_max * sizeof(tommy_hashtable_node*));

	hashtable->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, %esi
jae 0x26d5
pushq $0x10
popq %rax
jmp 0x26fb
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
movl %eax, 0x8(%rbx)
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
movl %eax, %esi
shlq $0x3, %rsi
pushq $0x1
popq %rdi
callq 0x1060
movq %rax, (%rbx)
andl $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_insert
void tommy_hashtable_insert(tommy_hashtable* hashtable, tommy_hashtable_node* node, void* data, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashtable->bucket_mask;

	tommy_list_insert_tail(&hashtable->bucket[pos], node, data);

	node->key = hash;

	++hashtable->count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0xc(%rdi), %edi
andl %ecx, %edi
shlq $0x3, %rdi
addq (%r15), %rdi
callq 0x274f
movl %ebx, 0x18(%r14)
incl 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommylist.h
// Function: tommy_list_insert_tail
tommy_inline void tommy_list_insert_tail(tommy_list* list, tommy_node* node, void* data)
{
	tommy_node* head = tommy_list_head(list);

	if (head)
		tommy_list_insert_tail_not_empty(head, node);
	else
		tommy_list_insert_first(list, node);

	node->data = data;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x276d
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rsi, 0x8(%rax)
andq $0x0, (%rsi)
movq 0x8(%rsi), %rdi
jmp 0x2775
movq %rsi, 0x8(%rsi)
andq $0x0, (%rsi)
movq %rsi, (%rdi)
movq %rdx, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_remove_existing
void* tommy_hashtable_remove_existing(tommy_hashtable* hashtable, tommy_hashtable_node* node)
{
	tommy_count_t pos = node->key & hashtable->bucket_mask;

	tommy_list_remove_existing(&hashtable->bucket[pos], node);

	--hashtable->count;

	return node->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %edi
andl 0x18(%rsi), %edi
shlq $0x3, %rdi
addq (%r14), %rdi
callq 0x27a9
decl 0x10(%r14)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_remove
void* tommy_hashtable_remove(tommy_hashtable* hashtable, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashtable->bucket_mask;
	tommy_hashtable_node* node = hashtable->bucket[pos];

	while (node) {
		/* we first check if the hash matches, as in the same bucket we may have multiples hash values */
		if (node->key == hash && cmp(cmp_arg, node->data) == 0) {
			tommy_list_remove_existing(&hashtable->bucket[pos], node);

			--hashtable->count;

			return node->data;
		}
		node = node->next;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0xc(%rdi), %r14d
andl %ecx, %r14d
shlq $0x3, %r14
movq (%rdi), %r15
addq %r14, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2826
cmpl %ebp, 0x18(%r15)
jne 0x27f3
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq *%r13
testl %eax, %eax
jne 0x27f3
addq (%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x27a9
decl 0x10(%rbx)
movq 0x10(%r15), %rax
jmp 0x2828
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_foreach
void tommy_hashtable_foreach(tommy_hashtable* hashtable, tommy_foreach_func* func)
{
	tommy_count_t bucket_max = hashtable->bucket_max;
	tommy_hashtable_node** bucket = hashtable->bucket;
	tommy_count_t pos;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashtable_node* node = bucket[pos];

		while (node) {
			void* data = node->data;
			node = node->next;
			func(data);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %r14d
movq (%rdi), %r15
xorl %r12d, %r12d
cmpq %r14, %r12
je 0x286e
movq (%r15,%r12,8), %rax
testq %rax, %rax
je 0x2869
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x2856
incq %r12
jmp 0x284d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_foreach_arg
void tommy_hashtable_foreach_arg(tommy_hashtable* hashtable, tommy_foreach_arg_func* func, void* arg)
{
	tommy_count_t bucket_max = hashtable->bucket_max;
	tommy_hashtable_node** bucket = hashtable->bucket;
	tommy_count_t pos;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashtable_node* node = bucket[pos];

		while (node) {
			void* data = node->data;
			node = node->next;
			func(arg, data);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rdi), %r15d
movq (%rdi), %r12
xorl %r13d, %r13d
cmpq %r15, %r13
je 0x28b8
movq (%r12,%r13,8), %rax
testq %rax, %rax
je 0x28b3
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x289c
incq %r13
jmp 0x2893
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_insert
void tommy_hashdyn_insert(tommy_hashdyn* hashdyn, tommy_hashdyn_node* node, void* data, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashdyn->bucket_mask;

	tommy_list_insert_tail(&hashdyn->bucket[pos], node, data);

	node->key = hash;

	++hashdyn->count;

	hashdyn_grow_step(hashdyn);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %edi
andl %ecx, %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
callq 0x274f
movl %ebp, 0x18(%r14)
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %ecx
incl %ecx
movl %ecx, 0x14(%rbx)
shrl %eax
cmpl %eax, %ecx
jae 0x2934
popq %rbx
popq %r14
popq %rbp
retq
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31ab
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_remove_existing
void* tommy_hashdyn_remove_existing(tommy_hashdyn* hashdyn, tommy_hashdyn_node* node)
{
	tommy_count_t pos = node->key & hashdyn->bucket_mask;

	tommy_list_remove_existing(&hashdyn->bucket[pos], node);

	--hashdyn->count;

	hashdyn_shrink_step(hashdyn);

	return node->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %edi
andl 0x18(%rsi), %edi
shlq $0x3, %rdi
addq (%r14), %rdi
callq 0x27a9
decl 0x14(%r14)
movq %r14, %rdi
callq 0x2979
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_remove
void* tommy_hashdyn_remove(tommy_hashdyn* hashdyn, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashdyn->bucket_mask;
	tommy_hashdyn_node* node = hashdyn->bucket[pos];

	while (node) {
		/* we first check if the hash matches, as in the same bucket we may have multiples hash values */
		if (node->key == hash && cmp(cmp_arg, node->data) == 0) {
			tommy_list_remove_existing(&hashdyn->bucket[pos], node);

			--hashdyn->count;

			hashdyn_shrink_step(hashdyn);

			return node->data;
		}
		node = node->next;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
andl %ecx, %r15d
shlq $0x3, %r15
movq (%rdi), %r14
addq %r15, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x29f6
cmpl %ebp, 0x18(%r14)
jne 0x29bb
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq *%r13
testl %eax, %eax
jne 0x29bb
addq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x27a9
decl 0x14(%rbx)
movq %rbx, %rdi
callq 0x2979
movq 0x10(%r14), %rax
jmp 0x29f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_foreach
void tommy_hashdyn_foreach(tommy_hashdyn* hashdyn, tommy_foreach_func* func)
{
	tommy_count_t bucket_max = hashdyn->bucket_max;
	tommy_hashdyn_node** bucket = hashdyn->bucket;
	tommy_count_t pos;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashdyn_node* node = bucket[pos];

		while (node) {
			void* data = node->data;
			node = node->next;
			func(data);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0xc(%rdi), %r14d
movq (%rdi), %r15
xorl %r12d, %r12d
cmpq %r14, %r12
je 0x2a3e
movq (%r15,%r12,8), %rax
testq %rax, %rax
je 0x2a39
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x2a26
incq %r12
jmp 0x2a1d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_foreach_arg
void tommy_hashdyn_foreach_arg(tommy_hashdyn* hashdyn, tommy_foreach_arg_func* func, void* arg)
{
	tommy_count_t bucket_max = hashdyn->bucket_max;
	tommy_hashdyn_node** bucket = hashdyn->bucket;
	tommy_count_t pos;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashdyn_node* node = bucket[pos];

		while (node) {
			void* data = node->data;
			node = node->next;
			func(arg, data);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0xc(%rdi), %r15d
movq (%rdi), %r12
xorl %r13d, %r13d
cmpq %r15, %r13
je 0x2a88
movq (%r12,%r13,8), %rax
testq %rax, %rax
je 0x2a83
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x2a6c
incq %r13
jmp 0x2a63
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_init
void tommy_hashlin_init(tommy_hashlin* hashlin)
{
	tommy_uint_t i;

	/* fixed initial size */
	hashlin->bucket_bit = TOMMY_HASHLIN_BIT;
	hashlin->bucket_max = 1 << hashlin->bucket_bit;
	hashlin->bucket_mask = hashlin->bucket_max - 1;
	hashlin->bucket[0] = tommy_cast(tommy_hashlin_node**, tommy_calloc(hashlin->bucket_max, sizeof(tommy_hashlin_node*)));
	for (i = 1; i < TOMMY_HASHLIN_BIT; ++i)
		hashlin->bucket[i] = hashlin->bucket[0];

	/* stable state */
	tommy_hashlin_stable(hashlin);

	hashlin->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x4000000006, %rax     # imm = 0x4000000006
movq %rax, 0x100(%rdi)
movl $0x3f, 0x108(%rdi)
pushq $0x40
popq %rdi
pushq $0x8
popq %rsi
callq 0x1060
movq %rax, (%rbx)
pushq $0x1
popq %rcx
cmpq $0x6, %rcx
je 0x2ae5
movq %rax, (%rbx,%rcx,8)
incq %rcx
jmp 0x2ad6
andl $0x0, 0x11c(%rbx)
movsd 0x161c(%rip), %xmm0     # 0x4110
movups %xmm0, 0x10c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_done
void tommy_hashlin_done(tommy_hashlin* hashlin)
{
	tommy_uint_t i;

	tommy_free(hashlin->bucket[0]);
	for (i = TOMMY_HASHLIN_BIT; i < hashlin->bucket_bit; ++i) {
		tommy_hashlin_node** segment = hashlin->bucket[i];
		tommy_free(&segment[((tommy_ptrdiff_t)1) << i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
pushq $0x6
popq %r14
pushq $0x1
popq %r15
movl 0x100(%rbx), %eax
cmpq %rax, %r14
jae 0x2b3b
movq %r15, %rdi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x2b15
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_insert
void tommy_hashlin_insert(tommy_hashlin* hashlin, tommy_hashlin_node* node, void* data, tommy_hash_t hash)
{
	tommy_list_insert_tail(tommy_hashlin_bucket_ref(hashlin, hash), node, data);

	node->key = hash;

	++hashlin->count;

	hashlin_grow_step(hashlin);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %esi
callq 0x2cbf
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x274f
movl %ebp, 0x18(%r15)
movl 0x118(%rbx), %ebp
movl 0x11c(%rbx), %eax
incl %ebp
movl %ebp, 0x118(%rbx)
cmpl $0x1, %eax
je 0x2bfa
movl 0x104(%rbx), %ecx
movl %ecx, %edx
shrl %edx
cmpl %edx, %ebp
jbe 0x2cb4
testl %eax, %eax
jne 0x2bf0
movl %ecx, 0x10c(%rbx)
movl 0x108(%rbx), %eax
movl %eax, 0x110(%rbx)
leaq (,%rcx,8), %r14
movq %r14, %rdi
callq 0x1080
subq %r14, %rax
movl 0x100(%rbx), %edx
leal 0x1(%rdx), %ecx
pushq $0x1
popq %rsi
shll %cl, %esi
movq %rax, (%rbx,%rdx,8)
movl %ecx, 0x100(%rbx)
movl %esi, 0x104(%rbx)
decl %esi
movl %esi, 0x108(%rbx)
andl $0x0, 0x114(%rbx)
movl $0x1, 0x11c(%rbx)
addl %ebp, %ebp
movl 0x10c(%rbx), %eax
movl 0x114(%rbx), %ecx
leal (%rcx,%rax), %edx
cmpl %ebp, %edx
jae 0x2cb4
movl %ecx, %esi
orl $0x1, %esi
bsrl %esi, %esi
movq (%rbx,%rsi,8), %rsi
movl %ecx, %edi
leaq (%rsi,%rdi,8), %rsi
movq %rsi, (%rsp)
movl %edx, %edi
orl $0x1, %edx
bsrl %edx, %edx
movq (%rbx,%rdx,8), %rdx
leaq (%rdx,%rdi,8), %rdi
movq %rdi, 0x8(%rsp)
movq (%rsi), %rdx
andq $0x0, (%rsi)
andq $0x0, (%rdi)
testq %rdx, %rdx
je 0x2c88
movq (%rdx), %rsi
xorl %edi, %edi
testl %eax, 0x18(%rdx)
setne %dil
movq (%rsp,%rdi,8), %rdi
movq (%rdi), %r8
testq %r8, %r8
je 0x2c78
movq 0x8(%r8), %rdi
movq %rdi, 0x8(%rdx)
movq %rdx, 0x8(%r8)
movq 0x8(%rdx), %rdi
jmp 0x2c7c
movq %rdx, 0x8(%rdx)
andq $0x0, (%rdx)
movq %rdx, (%rdi)
movq %rsi, %rdx
jmp 0x2c49
incl %ecx
movl %ecx, 0x114(%rbx)
cmpl %eax, %ecx
jne 0x2c08
andl $0x0, 0x11c(%rbx)
movq 0x104(%rbx), %rax
movq %rax, 0x10c(%rbx)
andl $0x0, 0x114(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_remove_existing
void* tommy_hashlin_remove_existing(tommy_hashlin* hashlin, tommy_hashlin_node* node)
{
	tommy_list_remove_existing(tommy_hashlin_bucket_ref(hashlin, node->key), node);

	--hashlin->count;

	hashlin_shrink_step(hashlin);

	return node->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %esi
callq 0x2cbf
movq %rax, %rdi
movq %rbx, %rsi
callq 0x27a9
decl 0x118(%r14)
movq %r14, %rdi
callq 0x2d20
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_remove
void* tommy_hashlin_remove(tommy_hashlin* hashlin, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_hashlin_node** let_ptr = tommy_hashlin_bucket_ref(hashlin, hash);
	tommy_hashlin_node* node = *let_ptr;

	while (node) {
		/* we first check if the hash matches, as in the same bucket we may have multiples hash values */
		if (node->key == hash && cmp(cmp_arg, node->data) == 0) {
			tommy_list_remove_existing(let_ptr, node);

			--hashlin->count;

			hashlin_shrink_step(hashlin);

			return node->data;
		}
		node = node->next;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, (%rsp)
movl %ecx, %esi
callq 0x2cbf
movq %rax, %rbx
xorl %r13d, %r13d
movq %rax, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x2e93
cmpl %ebp, 0x18(%r14)
jne 0x2e59
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq *%r12
testl %eax, %eax
jne 0x2e59
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27a9
movq (%rsp), %rdi
decl 0x118(%rdi)
callq 0x2d20
movq 0x10(%r14), %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_foreach
void tommy_hashlin_foreach(tommy_hashlin* hashlin, tommy_foreach_func* func)
{
	tommy_count_t bucket_max;
	tommy_count_t pos;

	/* number of valid buckets */
	bucket_max = hashlin->low_max + hashlin->split;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashlin_node* node = *tommy_hashlin_pos(hashlin, pos);

		while (node) {
			void* data = node->data;
			node = node->next;
			func(data);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x114(%rdi), %r15d
addl 0x10c(%rdi), %r15d
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x2ef3
movl %r12d, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq (%r14,%rax,8), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2eee
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x2edb
incq %r12
jmp 0x2ec5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_foreach_arg
void tommy_hashlin_foreach_arg(tommy_hashlin* hashlin, tommy_foreach_arg_func* func, void* arg)
{
	tommy_count_t bucket_max;
	tommy_count_t pos;

	/* number of valid buckets */
	bucket_max = hashlin->low_max + hashlin->split;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashlin_node* node = *tommy_hashlin_pos(hashlin, pos);

		while (node) {
			void* data = node->data;
			node = node->next;
			func(arg, data);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x114(%rdi), %r12d
addl 0x10c(%rdi), %r12d
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x2f54
movl %r13d, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq (%r15,%rax,8), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x2f4f
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x2f38
incq %r13
jmp 0x2f22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarray.h
// Function: tommy_array_ref
tommy_inline void** tommy_array_ref(tommy_array* array, tommy_count_t pos)
{
	tommy_uint_t bsr;

	assert(pos < array->count);

	/* get the highest bit set, in case of all 0, return 0 */
	bsr = tommy_ilog2_u32(pos | 1);

	return &array->bucket[bsr][pos];
}

// Assembly:
cmpl %esi, 0x108(%rdi)
jbe 0x2f91
movl %esi, %eax
orl $0x1, %esi
bsrl %esi, %ecx
shlq $0x3, %rax
addq (%rdi,%rcx,8), %rax
retq
pushq %rax
leaq 0x12a8(%rip), %rdi      # 0x4241
leaq 0x12b4(%rip), %rsi      # 0x4254
leaq 0x12bc(%rip), %rcx      # 0x4263
pushq $0x61
popq %rdx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommychain.h
// Function: tommy_chain_merge_degenerated
tommy_inline void tommy_chain_merge_degenerated(tommy_chain* first, tommy_chain* second, tommy_compare_func* cmp)
{
	/* identify the condition first <= second */
	if (cmp(first->tail->data, second->head->data) <= 0) {
		tommy_chain_concat(first->tail, second->head);
		first->tail = second->tail;
		return;
	}

	/* identify the condition second < first */
	/* here we must be strict on comparison to keep the sort stable */
	if (cmp(second->tail->data, first->head->data) < 0) {
		tommy_chain_concat(second->tail, first->head);
		first->head = second->head;
		return;
	}

	tommy_chain_merge(first, second, cmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
movq (%rsi), %rax
movq 0x10(%rax), %rsi
callq *%rdx
testl %eax, %eax
jle 0x3052
leaq 0x8(%r15), %r13
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq (%rbx), %rax
movq 0x10(%rax), %rsi
callq *%r14
testl %eax, %eax
js 0x3066
movq (%rbx), %rbp
movq (%r15), %rax
movq %rax, %r15
movq 0x10(%rbp), %rdi
movq 0x10(%r15), %rsi
callq *%r14
testl %eax, %eax
jg 0x301a
cmpq (%r12), %rbp
je 0x3045
movq (%rbp), %rbp
jmp 0x2fff
movq (%r15), %rax
cmpq (%rbx), %rbp
je 0x3030
movq 0x8(%rbp), %rcx
movq %r15, 0x8(%rbp)
movq %rcx, 0x8(%r15)
jmp 0x3037
movq %r15, 0x8(%rbp)
movq %rbx, %rcx
movq %r15, (%rcx)
movq %rbp, (%r15)
cmpq (%r13), %r15
jne 0x2ffc
jmp 0x307e
movq %rbp, 0x8(%r15)
movq %r15, (%rbp)
movq %r13, %r15
jmp 0x3077
movq (%r12), %rax
movq (%r15), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, (%rax)
addq $0x8, %r15
jmp 0x3077
movq (%r13), %rax
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, (%rax)
movq %rbx, %r12
movq (%r15), %rax
movq %rax, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_balance
static tommy_tree_node* tommy_tree_balance(tommy_tree_node* root)
{
	int delta = tommy_tree_delta(root);

	if (delta < -1) {
		if (tommy_tree_delta(root->next) > 0)
			root->next = tommy_tree_rotate_right(root->next);
		return tommy_tree_rotate_left(root);
	}

	if (delta > 1) {
		if (tommy_tree_delta(root->prev) < 0)
			root->prev = tommy_tree_rotate_left(root->prev);
		return tommy_tree_rotate_right(root);
	}

	/* recompute key */
	root->key = 0;

	if (root->prev && root->prev->key > root->key)
		root->key = root->prev->key;

	if (root->next && root->next->key > root->key)
		root->key = root->next->key;

	/* count itself */
	root->key += 1;

	return root;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x312f
cmpl $-0x2, %eax
jg 0x30c7
movq (%rbx), %r14
movq %r14, %rdi
callq 0x312f
testl %eax, %eax
jle 0x30b8
movq %r14, %rdi
callq 0x3150
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x316d
cmpl $0x2, %eax
jl 0x30f4
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x312f
testl %eax, %eax
jns 0x30e8
movq %r14, %rdi
callq 0x316d
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3150
andl $0x0, 0x18(%rbx)
movq 0x8(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x310f
movl 0x18(%rcx), %ecx
testl %ecx, %ecx
je 0x310f
movl %ecx, 0x18(%rbx)
movl %ecx, %eax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x311f
movl 0x18(%rcx), %ecx
cmpl %eax, %ecx
cmoval %ecx, %eax
incl %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_rotate_right
static tommy_tree_node* tommy_tree_rotate_right(tommy_tree_node* root)
{
	tommy_tree_node* prev = root->prev;

	root->prev = prev->next;

	prev->next = tommy_tree_balance(root);

	return tommy_tree_balance(prev);
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rbx
movq (%rbx), %rax
movq %rax, 0x8(%rdi)
callq 0x308d
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x308d
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_rotate_left
static tommy_tree_node* tommy_tree_rotate_left(tommy_tree_node* root)
{
	tommy_tree_node* next = root->next;

	root->next = next->prev;

	next->prev = tommy_tree_balance(root);

	return tommy_tree_balance(next);
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
callq 0x308d
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x308d
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_resize
static void tommy_hashdyn_resize(tommy_hashdyn* hashdyn, tommy_count_t new_bucket_bit)
{
	tommy_count_t bucket_bit;
	tommy_count_t bucket_max;
	tommy_count_t new_bucket_max;
	tommy_count_t new_bucket_mask;
	tommy_hashdyn_node** new_bucket;

	bucket_bit = hashdyn->bucket_bit;
	bucket_max = hashdyn->bucket_max;

	new_bucket_max = 1 << new_bucket_bit;
	new_bucket_mask = new_bucket_max - 1;

	/* allocate the new vector using malloc() and not calloc() */
	/* because data is fully initialized in the update process */
	new_bucket = tommy_cast(tommy_hashdyn_node**, tommy_malloc(new_bucket_max * sizeof(tommy_hashdyn_node*)));

	/* reinsert all the elements */
	if (new_bucket_bit > bucket_bit) {
		tommy_count_t i;

		/* grow */
		for (i = 0; i < bucket_max; ++i) {
			tommy_hashdyn_node* j;

			/* setup the new two buckets */
			new_bucket[i] = 0;
			new_bucket[i + bucket_max] = 0;

			/* reinsert the bucket */
			j = hashdyn->bucket[i];
			while (j) {
				tommy_hashdyn_node* j_next = j->next;
				tommy_count_t pos = j->key & new_bucket_mask;
				if (new_bucket[pos])
					tommy_list_insert_tail_not_empty(new_bucket[pos], j);
				else
					tommy_list_insert_first(&new_bucket[pos], j);
				j = j_next;
			}
		}
	} else {
		tommy_count_t i;

		/* shrink */
		for (i = 0; i < new_bucket_max; ++i) {
			/* setup the new bucket with the lower bucket*/
			new_bucket[i] = hashdyn->bucket[i];

			/* concat the upper bucket */
			tommy_list_concat(&new_bucket[i], &hashdyn->bucket[i + new_bucket_max]);
		}
	}

	tommy_free(hashdyn->bucket);

	/* setup */
	hashdyn->bucket_bit = new_bucket_bit;
	hashdyn->bucket_max = new_bucket_max;
	hashdyn->bucket_mask = new_bucket_mask;
	hashdyn->bucket = new_bucket;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x1
popq %r12
movl %ebp, %ecx
shll %cl, %r12d
movl 0x8(%rdi), %eax
movl %eax, (%rsp)
movl 0xc(%rdi), %r15d
leal -0x1(%r12), %r13d
leaq (,%r12,8), %rdi
callq 0x1080
movq %rax, %r14
movl %ebp, 0x4(%rsp)
cmpl %ebp, (%rsp)
jae 0x3252
xorl %eax, %eax
cmpq %r15, %rax
je 0x327f
andq $0x0, (%r14,%rax,8)
leal (%rax,%r15), %ecx
andq $0x0, (%r14,%rcx,8)
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rcx
testq %rcx, %rcx
je 0x324d
movq (%rcx), %rdx
movl 0x18(%rcx), %esi
andl %r13d, %esi
movq (%r14,%rsi,8), %rdi
testq %rdi, %rdi
je 0x3239
movq 0x8(%rdi), %rsi
movq %rsi, 0x8(%rcx)
movq %rcx, 0x8(%rdi)
andq $0x0, (%rcx)
movq 0x8(%rcx), %rsi
jmp 0x3245
leaq (%r14,%rsi,8), %rsi
movq %rcx, 0x8(%rcx)
andq $0x0, (%rcx)
movq %rcx, (%rsi)
movq %rdx, %rcx
jmp 0x320c
incq %rax
jmp 0x31ee
xorl %ebp, %ebp
movq %r14, %r15
cmpq %rbp, %r12
je 0x327f
movq (%rbx), %rax
movq (%rax,%rbp,8), %rcx
movq %rcx, (%r15)
leal (%r12,%rbp), %ecx
leaq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x32a8
incq %rbp
addq $0x8, %r15
jmp 0x3257
movq (%rbx), %rdi
callq 0x1030
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
movl %r13d, 0x10(%rbx)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/many-producers-many-consumers/main.cpp
// Function: main
int main() {
  // Producer and consumer thread pools.
  thread::pool::pool_t pool_of_consumers(5);
  thread::pool::pool_t pool_of_producers(5);

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

  // Array of producer workers.
  auto producers = new std::function<void()>[workers_to_spawn];
  // Filling the array with the producers.
  std::fill_n(producers, workers_to_spawn, std::bind(producer, &pool_of_consumers));

  // Scheduling the producers.
  pool_of_producers.schedule_bulk(producers, workers_to_spawn);

  // Waiting for the producers to complete.
  pool_of_producers.stop().await();
  
  // Waiting for the consumers to complete.
  while (count < workers_to_spawn * work_by_worker)
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

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

  // Deleting the producer array.
  delete[] producers;
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x548, %rsp            # imm = 0x548
leaq 0x2b0(%rsp), %r15
pushq $0x5
popq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x384e
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x384e
callq 0x3050
movq %rax, %r14
movl $0x7d08, %edi           # imm = 0x7D08
callq 0x3030
movq %rax, %rbx
movq $0x3e8, (%rax)          # imm = 0x3E8
leaq 0x8(%rax), %r12
movl $0x7d00, %edx           # imm = 0x7D00
movq %r12, %rdi
xorl %esi, %esi
callq 0x3140
leaq -0xb8(%rip), %rax       # 0x350b
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r15, 0x8(%rdx)
leaq 0x7d08(%rbx), %rsi
movq %r12, %rdi
callq 0x6939
leaq 0x18(%rsp), %r15
movl $0x3e8, %edx            # imm = 0x3E8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3910
movb $0x1, %al
xchgb %al, 0x290(%r15)
movq %r15, %rdi
callq 0x3924
leaq 0x8(%rsp), %r15
movq 0x9c10(%rip), %rax      # 0xd220
cmpq $0xf423f, %rax          # imm = 0xF423F
ja 0x362b
movq $0x64, 0x8(%rsp)
movq %r15, %rdi
callq 0x394f
jmp 0x3609
callq 0x3050
movq %rax, %r15
movq 0x997e(%rip), %rdi      # 0xcfb8
leaq 0x39ef(%rip), %rsi      # 0x7030
callq 0x3250
subq %r14, %r15
cvtsi2sd %r15, %xmm0
divsd 0x39b2(%rip), %xmm0     # 0x7008
movq %rax, %rdi
callq 0x3310
leaq 0x39db(%rip), %rsi      # 0x7040
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3110
movq (%rbx), %rax
movq %rax, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %r14
testq %rax, %rax
je 0x369e
movq %rbx, %r12
addq $-0x18, %r12
leaq (%r12,%r15), %rdi
callq 0x4158
addq $-0x20, %r15
jne 0x368f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33b0
leaq 0x18(%rsp), %rdi
callq 0x39a4
leaq 0x2b0(%rsp), %rdi
callq 0x39a4
xorl %eax, %eax
addq $0x548, %rsp            # imm = 0x548
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x36dc
movq %rax, %rbx
jmp 0x36e9
jmp 0x36dc
jmp 0x36dc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x39a4
leaq 0x2b0(%rsp), %rdi
callq 0x39a4
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/many-producers-many-consumers/./../../includes/blocking_concurrent_queue.hpp
// Function: bool moodycamel::BlockingConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::enqueue_bulk<std::function<void ()> const*>(std::function<void ()> const*, unsigned long)
inline bool enqueue_bulk(It itemFirst, size_t count)
	{
		if ((details::likely)(inner.enqueue_bulk(std::forward<It>(itemFirst), count))) {
			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x6ac4
movl %eax, %ebp
testb %al, %al
je 0x6abc
movq 0x270(%r14), %rdi
movq %rbx, %rsi
callq 0x49aa
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/many-producers-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::add_blocks_to_free_list(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::Block*)
inline void add_blocks_to_free_list(Block* block)
	{
		while (block != nullptr) {
			auto next = block->next;
			add_block_to_free_list(block);
			block = next;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x28, %rbx
testq %rsi, %rsi
je 0x6f76
movq 0x400(%rsi), %r14
movq %rbx, %rdi
callq 0x51a8
movq %r14, %rsi
jmp 0x6f5d
addq $0x8, %rsp
popq %rbx
popq %r14
retq