LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: trie_inplace_bucket_insert
static void trie_inplace_bucket_insert(tommy_uint_t shift, tommy_trie_inplace_node** let_ptr, tommy_trie_inplace_node* insert, tommy_key_t key)
{
	tommy_trie_inplace_node* node;

	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 null, just insert the node */
	if (!node) {
		/* setup the node as a list */
		*let_ptr = tommy_trie_inplace_list_insert_first(insert);
	} else {
		/* if it's the same key, insert in the list */
		tommy_trie_inplace_list_insert_tail_not_empty(node, insert);
	}
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x42b4
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x1c(%rsp), %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x42be
jmp 0x42fe
movq 0x10(%rsp), %rax
addq $0x20, %rax
movl 0x1c(%rsp), %edx
movl 0x34(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x34(%rsp)
jmp 0x4293
cmpq $0x0, 0x10(%rsp)
jne 0x431d
movq 0x20(%rsp), %rdi
callq 0x6120
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x432c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x6150
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x1a, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
movl 0x14(%rsp), %ecx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x43c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4394
movq $0x0, 0x20(%rsp)
jmp 0x43b6
movq 0x18(%rsp), %rax
movl 0x200(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x200(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
shrl $0x1a, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl $0x1a, %edi
callq 0x43c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x465d
jmp 0x467c
leaq 0x2b02(%rip), %rdi      # 0x7166
leaq 0x2b57(%rip), %rsi      # 0x71c2
movl $0xf3, %edx
leaq 0x2b5c(%rip), %rcx      # 0x71d3
callq 0x1050
movq 0x20(%rsp), %rax
movl 0x200(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x200(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
shrl $0x1a, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movl $0x1a, -0x1c(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rsp)
movb %al, -0x1d(%rsp)
je 0x46e9
movq -0x18(%rsp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rsp), %eax
setne %al
movb %al, -0x1d(%rsp)
movb -0x1d(%rsp), %al
testb $0x1, %al
jne 0x46f3
jmp 0x4720
movq -0x18(%rsp), %rax
movl -0xc(%rsp), %edx
movl -0x1c(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rsp)
jmp 0x46c8
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jae 0x478e
movl $0x10, 0xc(%rsp)
jmp 0x479b
movl 0xc(%rsp), %edi
callq 0x4810
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1060
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
andl 0xc(%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x8(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4910
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x494b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x60d0
jmp 0x495a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6090
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
andl 0xc(%rcx), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x49d0
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommylist.h
// Function: tommy_list_remove_existing
tommy_inline void* tommy_list_remove_existing(tommy_list* list, tommy_node* node)
{
	tommy_node* head = tommy_list_head(list);

	/* remove from the "circular" prev list */
	if (node->next)
		node->next->prev = node->prev;
	else
		head->prev = node->prev; /* the last */

	/* remove from the "0 terminated" next list */
	if (head == node)
		*list = node->next; /* the new head, in case 0 */
	else
		node->prev->next = node->next;

	return node->data;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x30d0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4a0e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x4a1f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x4a3c
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x4a50
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
andl 0xc(%rcx), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4b16
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x4b07
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x4b07
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x10(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x49d0
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4b1f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4a9c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x4bb9
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4baa
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rsp), %rdi
callq *%rax
jmp 0x4b7b
jmp 0x4bac
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4b5f
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x4c55
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4c46
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
jmp 0x4c10
jmp 0x4c48
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4bf4
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_init
void tommy_hashdyn_init(tommy_hashdyn* hashdyn)
{
	/* fixed initial size */
	hashdyn->bucket_bit = TOMMY_HASHDYN_BIT;
	hashdyn->bucket_max = 1 << hashdyn->bucket_bit;
	hashdyn->bucket_mask = hashdyn->bucket_max - 1;
	hashdyn->bucket = tommy_cast(tommy_hashdyn_node**, tommy_calloc(hashdyn->bucket_max, sizeof(tommy_hashdyn_node*)));

	hashdyn->count = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x4, 0x8(%rax)
movq (%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1070
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
andl 0x10(%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x8(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4910
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq 0x20(%rsp), %rdi
callq 0x4dc0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
andl 0x10(%rcx), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x49d0
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rdi
callq 0x4e60
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
andl 0x10(%rcx), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4f63
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x4f51
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x4f51
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x10(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x49d0
movq 0x28(%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq 0x28(%rsp), %rdi
callq 0x4e60
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4f6c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4edc
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x5009
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4ffa
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rsp), %rdi
callq *%rax
jmp 0x4fcb
jmp 0x4ffc
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4faf
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x50a5
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5096
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
jmp 0x5060
jmp 0x5098
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5044
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x6, 0x100(%rax)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x104(%rax)
movq 0x10(%rsp), %rax
movl 0x104(%rax), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x108(%rax)
movq 0x10(%rsp), %rax
movl 0x104(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1070
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0xc(%rsp)
cmpl $0x6, 0xc(%rsp)
jae 0x51a3
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x517a
movq 0x10(%rsp), %rdi
callq 0x51d0
movq 0x10(%rsp), %rax
movl $0x0, 0x118(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommyhashlin.c
// Function: tommy_hashlin_stable
tommy_inline void tommy_hashlin_stable(tommy_hashlin* hashlin)
{
	hashlin->state = TOMMY_HASHLIN_STATE_STABLE;

	/* setup low_mask/max/split to allow tommy_hashlin_bucket_ref() */
	/* and tommy_hashlin_foreach() to work regardless we are in stable state */
	hashlin->low_max = hashlin->bucket_max;
	hashlin->low_mask = hashlin->bucket_mask;
	hashlin->split = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x11c(%rax)
movq -0x8(%rsp), %rax
movl 0x104(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x10c(%rax)
movq -0x8(%rsp), %rax
movl 0x108(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x110(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x114(%rax)
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movl $0x6, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x100(%rcx), %eax
jae 0x528b
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x523e
addq $0x18, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x5300
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4910
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl 0x118(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x118(%rax)
movq 0x20(%rsp), %rdi
callq 0x5360
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x5300
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x49d0
movq 0x10(%rsp), %rax
movl 0x118(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x118(%rax)
movq 0x10(%rsp), %rdi
callq 0x5660
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x5300
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x591b
movq (%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x590e
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq (%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x590e
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x49d0
movq 0x28(%rsp), %rax
movl 0x118(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x118(%rax)
movq 0x28(%rsp), %rdi
callq 0x5660
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x5924
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x58a6
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x10c(%rax), %eax
movq 0x20(%rsp), %rcx
addl 0x114(%rcx), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x59be
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x59d0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x59af
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rdi
callq *%rax
jmp 0x5980
jmp 0x59b1
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5960
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x10c(%rax), %eax
movq 0x30(%rsp), %rcx
addl 0x114(%rcx), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x5aaa
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x59d0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5a9b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
jmp 0x5a65
jmp 0x5a9d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5a45
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jg 0x5bd0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x5c50
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5c2f
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x5c1c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x5c50
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x5c2f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x5c80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommychain.h
// Function: tommy_chain_merge
tommy_inline void tommy_chain_merge(tommy_chain* first, tommy_chain* second, tommy_compare_func* cmp)
{
	tommy_node* first_i = first->head;
	tommy_node* second_i = second->head;

	/* merge */
	while (1) {
		if (cmp(first_i->data, second_i->data) > 0) {
			tommy_node* next = second_i->next;
			if (first_i == first->head) {
				tommy_chain_concat(second_i, first_i);
				first->head = second_i;
			} else {
				tommy_chain_splice(first_i->prev, first_i, second_i, second_i);
			}
			if (second_i == second->tail)
				break;
			second_i = next;
		} else {
			if (first_i == first->tail) {
				tommy_chain_concat(first_i, second_i);
				first->tail = second->tail;
				break;
			}
			first_i = first_i->next;
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x5d40
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x5d05
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5c50
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
jmp 0x5d22
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x5d90
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5d34
jmp 0x5d85
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x5d80
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5d73
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x5c50
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5d85
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x5cad
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommychain.h
// Function: tommy_chain_splice
tommy_inline void tommy_chain_splice(tommy_node* first_before, tommy_node* first_after, tommy_node* second_head, tommy_node* second_tail)
{
	/* set the prev list */
	first_after->prev = second_tail;
	second_head->prev = first_before;

	/* set the next list */
	first_before->next = second_head;
	second_tail->next = first_after;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5f20
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jge 0x5e3c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x5f20
cmpl $0x0, %eax
jle 0x5e28
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x5f90
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x5fe0
movq %rax, 0x10(%rsp)
jmp 0x5f11
cmpl $0x1, 0x4(%rsp)
jle 0x5e84
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x5f20
cmpl $0x0, %eax
jge 0x5e70
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x5fe0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x5f90
movq %rax, 0x10(%rsp)
jmp 0x5f11
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5ec6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jbe 0x5ec6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x5ef9
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jbe 0x5ef9
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x5de0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x5de0
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_move_right
static tommy_tree_node* tommy_tree_move_right(tommy_tree_node* root, tommy_tree_node* node)
{
	if (!root)
		return node;

	root->next = tommy_tree_move_right(root->next, node);

	return tommy_tree_balance(root);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6050
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x607b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
callq 0x6030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x5de0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommylist.h
// Function: tommy_list_insert_tail_not_empty
tommy_inline void tommy_list_insert_tail_not_empty(tommy_node* head, tommy_node* node)
{
	/* insert in the "circular" prev list */
	node->prev = head->prev;
	head->prev = node;

	/* insert in the "0 terminated" next list */
	node->next = 0;
	node->prev->next = node;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_list_remove
tommy_inline void tommy_trie_inplace_list_remove(tommy_trie_inplace_node** let_ptr, tommy_trie_inplace_node* node)
{
	tommy_trie_inplace_node* head = *let_ptr;

	/* remove from the "circular" prev list */
	if (node->next)
		node->next->prev = node->prev;
	else
		head->prev = node->prev; /* the last */

	/* remove from the "0 terminated" next list */
	if (head == node)
		*let_ptr = node->next; /* the new first */
	else
		node->prev->next = node->next;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x61d9
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x61eb
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jne 0x6209
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x621d
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
retq
nop
// File: attractivechaos[P]udb2/tommyds/./tommylist.h
// Function: tommy_list_concat
tommy_inline void tommy_list_concat(tommy_list* first, tommy_list* second)
{
	tommy_node* first_head;
	tommy_node* first_tail;
	tommy_node* second_head;

	/* if the second is empty, nothing to do */
	second_head = tommy_list_head(second);
	if (second_head == 0)
		return;

	/* if the first is empty, copy the second */
	first_head = tommy_list_head(first);
	if (first_head == 0) {
		*first = *second;
		return;
	}

	/* tail of the first list */
	first_tail = first_head->prev;

	/* set the "circular" prev list */
	first_head->prev = second_head->prev;
	second_head->prev = first_tail;

	/* set the "0 terminated" next list */
	first_tail->next = second_head;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x30d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x6435
jmp 0x6496
movq 0x20(%rsp), %rdi
callq 0x30d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x645e
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x6496
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17380
movzbl %al, %edi
andl $0x1, %edi
callq 0x39b0
testb $0x1, %al
jne 0x1734a
jmp 0x1736c
movq -0x28(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x9820
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x9840
movb $0x1, -0x1(%rbp)
jmp 0x17370
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17d75
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd5e0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x17d48
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb_stat.c
// Function: prstat
static void prstat(MDB_stat *ms)
{
#if 0
	printf("  Page size: %u\n", ms->ms_psize);
#endif
	printf("  Tree depth: %u\n", ms->ms_depth);
	printf("  Branch pages: %"Z"u\n", ms->ms_branch_pages);
	printf("  Leaf pages: %"Z"u\n", ms->ms_leaf_pages);
	printf("  Overflow pages: %"Z"u\n", ms->ms_overflow_pages);
	printf("  Entries: %"Z"u\n", ms->ms_entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x1422f(%rip), %rdi     # 0x17339
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1422b(%rip), %rdi     # 0x1734b
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x1422a(%rip), %rdi     # 0x17360
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x14227(%rip), %rdi     # 0x17373
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x14228(%rip), %rdi     # 0x1738a
movb $0x0, %al
callq 0x2120
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb.c
// Function: mdb_dcmp
int
mdb_dcmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)
{
	MDB_cmp_func *dcmp = txn->mt_dbxs[dbi].md_dcmp;
#if UINT_MAX < SIZE_MAX
	if (dcmp == mdb_cmp_int && a->mv_size == sizeof(size_t))
		dcmp = mdb_cmp_clong;
#endif
	return dcmp(a, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x38(%rip), %rax        # 0x3290
cmpq %rax, -0x28(%rbp)
jne 0x3273
movq -0x18(%rbp), %rax
cmpq $0x8, (%rax)
jne 0x3273
leaq 0x71(%rip), %rax        # 0x32e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jvanns[P]verbatim/sub/lmdb/libraries/liblmdb/mdb.c
// Function: mdb_env_sync
int
mdb_env_sync(MDB_env *env, int force)
{
	int rc = 0;
	if (env->me_flags & MDB_RDONLY)
		return EACCES;
	if (force || !F_ISSET(env->me_flags, MDB_NOSYNC)) {
		if (env->me_flags & MDB_WRITEMAP) {
			int flags = ((env->me_flags & MDB_MAPASYNC) && !force)
				? MS_ASYNC : MS_SYNC;
			if (MDB_MSYNC(env->me_map, env->me_mapsize, flags))
				rc = ErrCode();
#ifdef _WIN32
			else if (flags == MS_SYNC && MDB_FDATASYNC(env->me_fd))
				rc = ErrCode();
#endif
		} else {
#ifdef BROKEN_FDATASYNC
			if (env->me_flags & MDB_FSYNCONLY) {
				if (fsync(env->me_fd))
					rc = ErrCode();
			} else
#endif
			if (MDB_FDATASYNC(env->me_fd))
				rc = ErrCode();
		}
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x20000, %eax          # imm = 0x20000
cmpl $0x0, %eax
je 0x3373
movl $0xd, -0x4(%rbp)
jmp 0x3456
cmpl $0x0, -0x14(%rbp)
jne 0x3390
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x10000, %eax          # imm = 0x10000
je 0x3450
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x3403
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x100000, %ecx         # imm = 0x100000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x33c4
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %dl
movl $0x4, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x20f0
cmpl $0x0, %eax
je 0x3401
callq 0x2050
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x344e
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
je 0x3430
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x22d0
cmpl $0x0, %eax
je 0x342e
callq 0x2050
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x344c
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
je 0x344a
callq 0x2050
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x344c
jmp 0x344e
jmp 0x3450
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop