LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: amadvance[P]tommyds/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->index;
	tommy_trie_node** let_ptr;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_BUCKET_SHIFT < TOMMY_TRIE_BUCKET_MAX);

	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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x1b, %rax
cmpq $0x20, %rax
jae 0x70cc
jmp 0x70eb
leaq 0x347d(%rip), %rdi      # 0xa550
leaq 0x34ad(%rip), %rsi      # 0xa587
movl $0x11a, %edx            # imm = 0x11A
leaq 0x3535(%rip), %rcx      # 0xa61b
callq 0x1080
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x1b, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x1b, %esi
callq 0x6e30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x712c
jmp 0x714b
leaq 0x352a(%rip), %rdi      # 0xa65d
leaq 0x344d(%rip), %rsi      # 0xa587
movl $0x121, %edx            # imm = 0x121
leaq 0x34d5(%rip), %rcx      # 0xa61b
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: amadvance[P]tommyds/tommyds/tommytrie.c
// Function: tommy_trie_bucket
tommy_trie_node* tommy_trie_bucket(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* node;
	void* ptr;
	tommy_uint_t type;
	tommy_uint_t shift;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_BUCKET_SHIFT < TOMMY_TRIE_BUCKET_MAX);

	ptr = trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	shift = TOMMY_TRIE_BUCKET_SHIFT;

recurse:
	if (!ptr)
		return 0;

	type = trie_get_type(ptr);

	switch (type) {
	case TOMMY_TRIE_TYPE_NODE :
		node = tommy_cast(tommy_trie_node*, ptr);
		if (node->index != key)
			return 0;
		return node;
	default :
	case TOMMY_TRIE_TYPE_TREE :
		ptr = trie_get_tree(ptr)->map[(key >> shift) & TOMMY_TRIE_TREE_MASK];
		shift -= TOMMY_TRIE_TREE_BIT;
		goto recurse;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x1b, %rax
cmpq $0x20, %rax
jae 0x7190
jmp 0x71af
leaq 0x33b9(%rip), %rdi      # 0xa550
leaq 0x33e9(%rip), %rsi      # 0xa587
movl $0x130, %edx            # imm = 0x130
leaq 0x34bf(%rip), %rcx      # 0xa669
callq 0x1080
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x1b, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl $0x1b, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x71db
movq $0x0, -0x8(%rbp)
jmp 0x7255
movl -0x28(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x71fa
jmp 0x71f0
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x7226
jmp 0x7224
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x721a
movq $0x0, -0x8(%rbp)
jmp 0x7255
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7255
jmp 0x7226
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq -0x18(%rbp), %rdx
movl -0x30(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x7, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x30(%rbp)
jmp 0x71ca
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: amadvance[P]tommyds/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;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT < TOMMY_TRIE_INPLACE_BUCKET_MAX);

	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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x1a, %rax
cmpq $0x40, %rax
jae 0x7328
jmp 0x7347
leaq 0x3378(%rip), %rdi      # 0xa6a7
leaq 0x33b8(%rip), %rsi      # 0xa6ee
movl $0x85, %edx
leaq 0x33c3(%rip), %rcx      # 0xa705
callq 0x1080
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jae 0x7387
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7366
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x1a, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1a, %edi
callq 0x73d0
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x200(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: amadvance[P]tommyds/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;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT < TOMMY_TRIE_INPLACE_BUCKET_MAX);

	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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x1a, %rax
cmpq $0x40, %rax
jae 0x74b0
jmp 0x74cf
leaq 0x31f0(%rip), %rdi      # 0xa6a7
leaq 0x3230(%rip), %rsi      # 0xa6ee
movl $0xe0, %edx
leaq 0x32a0(%rip), %rcx      # 0xa76a
callq 0x1080
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x1a, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7540
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7511
movq $0x0, -0x8(%rbp)
jmp 0x7533
movq -0x10(%rbp), %rax
movq 0x200(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x200(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/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;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT < TOMMY_TRIE_INPLACE_BUCKET_MAX);

	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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x1a, %rax
cmpq $0x40, %rax
jae 0x775c
jmp 0x777b
leaq 0x2f44(%rip), %rdi      # 0xa6a7
leaq 0x2f84(%rip), %rsi      # 0xa6ee
movl $0xf5, %edx
leaq 0x3037(%rip), %rcx      # 0xa7ad
callq 0x1080
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x1a, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1a, %edi
callq 0x7540
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x77b8
jmp 0x77d7
leaq 0x2e9e(%rip), %rdi      # 0xa65d
leaq 0x2f28(%rip), %rsi      # 0xa6ee
movl $0xfc, %edx
leaq 0x2fdb(%rip), %rcx      # 0xa7ad
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x200(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/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;

	/* ensure that the element is not too big */
	assert(key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT < TOMMY_TRIE_INPLACE_BUCKET_MAX);

	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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1a, %rax
cmpq $0x40, %rax
jae 0x7820
jmp 0x783f
leaq 0x2e80(%rip), %rdi      # 0xa6a7
leaq 0x2ec0(%rip), %rsi      # 0xa6ee
movl $0x109, %edx            # imm = 0x109
leaq 0x2fcd(%rip), %rcx      # 0xa807
callq 0x1080
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x1a, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x1a, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x7878
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x7881
jmp 0x78aa
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x3, %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x785a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashtbl.c
// Function: tommy_hashtable_init
void tommy_hashtable_init(tommy_hashtable* hashtable, tommy_size_t bucket_max)
{
	if (bucket_max < 16)
		bucket_max = 16;
	else
		bucket_max = tommy_roundup_pow2(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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
jae 0x7921
movq $0x10, -0x10(%rbp)
jmp 0x792e
movq -0x10(%rbp), %rdi
callq 0x79a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1090
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommytypes.h
// Function: tommy_roundup_pow2_u64
tommy_inline tommy_uint64_t tommy_roundup_pow2_u64(tommy_uint64_t value)
{
	--value;
	value |= value >> 1;
	value |= value >> 2;
	value |= value >> 4;
	value |= value >> 8;
	value |= value >> 16;
	value |= value >> 32;
	++value;

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/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_size_t pos = hash & hashtable->bucket_mask;

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

	node->index = hash;

	++hashtable->count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7ac0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashtbl.c
// Function: tommy_hashtable_remove_existing
void* tommy_hashtable_remove_existing(tommy_hashtable* hashtable, tommy_hashtable_node* node)
{
	tommy_size_t pos = node->index & hashtable->bucket_mask;

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

	--hashtable->count;

	return node->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7b80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/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_size_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->index == 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x7cbd
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x7cb0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x7cb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x7b80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7cc5
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x7c4b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: amadvance[P]tommyds/tommyds/tommyhashtbl.c
// Function: tommy_hashtable_foreach
void tommy_hashtable_foreach(tommy_hashtable* hashtable, tommy_foreach_func* func)
{
	tommy_size_t bucket_max = hashtable->bucket_max;
	tommy_hashtable_node** bucket = hashtable->bucket;
	tommy_size_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7d53
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7d43
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rdi
callq *%rax
jmp 0x7d19
jmp 0x7d45
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7cff
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashtbl.c
// Function: tommy_hashtable_foreach_arg
void tommy_hashtable_foreach_arg(tommy_hashtable* hashtable, tommy_foreach_arg_func* func, void* arg)
{
	tommy_size_t bucket_max = hashtable->bucket_max;
	tommy_hashtable_node** bucket = hashtable->bucket;
	tommy_size_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7deb
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x7ddb
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
jmp 0x7dad
jmp 0x7ddd
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7d93
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/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_size_t pos = hash & hashdyn->bucket_mask;

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

	node->index = hash;

	++hashdyn->count;

	hashdyn_grow_step(hashdyn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7ac0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x7f80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashdyn.c
// Function: tommy_hashdyn_remove_existing
void* tommy_hashdyn_remove_existing(tommy_hashdyn* hashdyn, tommy_hashdyn_node* node)
{
	tommy_size_t pos = node->index & hashdyn->bucket_mask;

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

	--hashdyn->count;

	hashdyn_shrink_step(hashdyn);

	return node->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7b80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x8040
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/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_size_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->index == 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
andq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x8146
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x8139
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x8139
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x7b80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x8040
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x814e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x80cb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashdyn.c
// Function: tommy_hashdyn_foreach
void tommy_hashdyn_foreach(tommy_hashdyn* hashdyn, tommy_foreach_func* func)
{
	tommy_size_t bucket_max = hashdyn->bucket_max;
	tommy_hashdyn_node** bucket = hashdyn->bucket;
	tommy_size_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x81e3
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x81d3
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rdi
callq *%rax
jmp 0x81a9
jmp 0x81d5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x818f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashdyn.c
// Function: tommy_hashdyn_foreach_arg
void tommy_hashdyn_foreach_arg(tommy_hashdyn* hashdyn, tommy_foreach_arg_func* func, void* arg)
{
	tommy_size_t bucket_max = hashdyn->bucket_max;
	tommy_hashdyn_node** bucket = hashdyn->bucket;
	tommy_size_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x827b
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x826b
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
jmp 0x823d
jmp 0x826d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8223
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movl $0x6, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x230(%rcx), %eax
jae 0x8475
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x842f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/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->index = hash;

	++hashlin->count;

	hashlin_grow_step(hashlin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x84f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7ac0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x228(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rdi
callq 0x8560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/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->index), node);

	--hashlin->count;

	hashlin_shrink_step(hashlin);

	return node->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x84f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7b80
movq -0x8(%rbp), %rax
movq 0x228(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rdi
callq 0x8850
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommyhashlin.c
// Function: tommy_hashlin_foreach
void tommy_hashlin_foreach(tommy_hashlin* hashlin, tommy_foreach_func* func)
{
	tommy_size_t bucket_max;
	tommy_size_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x220(%rcx), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8baa
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8bb0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8b9a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdi
callq *%rax
jmp 0x8b70
jmp 0x8b9c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8b52
addq $0x30, %rsp
popq %rbp
retq
// File: amadvance[P]tommyds/tommyds/tommyhashlin.c
// Function: tommy_hashlin_foreach_arg
void tommy_hashlin_foreach_arg(tommy_hashlin* hashlin, tommy_foreach_arg_func* func, void* arg)
{
	tommy_size_t bucket_max;
	tommy_size_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x220(%rcx), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x8c82
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8bb0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8c72
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
jmp 0x8c44
jmp 0x8c74
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8c26
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/tommyds/tommytree.c
// Function: tommy_tree_balance
static tommy_tree_node* tommy_tree_balance(tommy_tree_node* root)
{
	tommy_ssize_t 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->index = 0;

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

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

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

	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90e0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jge 0x8ffa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x90e0
cmpq $0x0, %rax
jle 0x8fe8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x91a0
movq %rax, -0x8(%rbp)
jmp 0x90c9
cmpq $0x1, -0x18(%rbp)
jle 0x903e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x90e0
cmpq $0x0, %rax
jge 0x902c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x91a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x9150
movq %rax, -0x8(%rbp)
jmp 0x90c9
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x907f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x907f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x90b1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x90b1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smilingthax[P]cttrie/test_cttrie.cpp
// Function: main
int main(int argc,char **argv)
{
  const char *str=(argc>1) ? argv[1] : "abc";

  printf("%d\n",
    TRIE2(lc_stringview,str) return -1;
    CASE("abc") return 0;
    CASE("bcd") return 1;
    ENDTRIE
  );

  TRIE(str)
    printf("E\n");
  CASE("Rosten")
    printf("6\n");
  CASE("Raben")
    printf("0\n");
  CASE("Rasen")
    printf("1\n");
  CASE("Rasten")
    printf("2\n");
  CASE("Raster")
    printf("3\n");
  CASE("Rastender")
    printf("4\n");
  CASE("Raban")
    printf("5\n");
  ENDTRIE;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl $0x0, -0x2c(%rbp)
movl %edi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
cmpl $0x1, -0x30(%rbp)
jle 0x1199
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x11a9
leaq 0x7e64(%rip), %rax      # 0x9004
movq %rax, -0x98(%rbp)
jmp 0x11a9
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8400
leaq -0x53(%rbp), %rdi
callq 0x1370
leaq -0x57(%rbp), %rdi
callq 0x1380
leaq -0x50(%rbp), %rdi
leaq -0x51(%rbp), %rsi
leaq -0x52(%rbp), %rdx
leaq -0x55(%rbp), %rcx
leaq -0x56(%rbp), %r8
leaq -0x59(%rbp), %r9
callq 0x1320
movl %eax, %esi
leaq 0x7e0f(%rip), %rdi      # 0x9008
movb $0x0, %al
callq 0x1030
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x8430
leaq -0x73(%rbp), %rdi
callq 0x1490
leaq -0x77(%rbp), %rdi
callq 0x14a0
leaq -0x7b(%rbp), %rdi
callq 0x14b0
leaq -0x7f(%rbp), %rdi
callq 0x14c0
leaq -0x83(%rbp), %rdi
callq 0x14d0
leaq -0x87(%rbp), %rdi
callq 0x14e0
leaq -0x8b(%rbp), %rdi
callq 0x14f0
leaq -0x70(%rbp), %rdi
leaq -0x71(%rbp), %rsi
leaq -0x72(%rbp), %rdx
leaq -0x75(%rbp), %rcx
leaq -0x76(%rbp), %r8
leaq -0x79(%rbp), %r9
leaq -0x7a(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x7d(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x7e(%rbp), %r13
leaq -0x81(%rbp), %r12
leaq -0x82(%rbp), %r15
leaq -0x85(%rbp), %r14
leaq -0x86(%rbp), %rbx
leaq -0x89(%rbp), %r11
leaq -0x8a(%rbp), %r10
leaq -0x8d(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, (%rsp)
movq -0xa8(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0xa0(%rbp), %rax
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x1390
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: ASG-ICT[P]SPEC2017-Trace/trace.cpp
// Function: next_record(_IO_FILE*)
int next_record(FILE *fp)
{
    uint64_t trace_buf;
    uint64_t temp;
    uint64_t duration;
    unsigned long long       tmp;
    unsigned int seq_no,r_w;
        unsigned long paddr;
        unsigned long long timer;

    //uint64_t seq_num;
    uint64_t invalid_count = 0;
    while (1) {
        if (fread(&trace_buf, 6, 1, fp) == 0){ 
		printf("read hmtt trace end or error\n");
		return -1;
	}
	tmp = trace_buf;
        seq_no = (unsigned int) ((tmp >> 40) & 0xffU);
        timer  = (unsigned long long)((tmp >> 32) & 0xffULL);
        r_w    = (unsigned int)((tmp >> 31) & 0x1U);
        paddr   = (unsigned long)(tmp & 0x7fffffffUL);
        paddr   = (unsigned long)(paddr << 6);
	record.paddr = paddr;
	record.rw = r_w;
	duration = timer;

        if (record.paddr == 0 && duration == 0) {
            invalid_count++;
            continue;
        }
        else {
            duration += invalid_count * 256;
            invalid_count = 0;
        }
        duration_all += duration;
        record.tm = duration_all;
        break;
    }

//    record.paddr = record.paddr << 6;
    if (record.paddr >= (2ULL << 30)) {
        record.paddr += (2ULL << 30);
    }
//    printf(" seq_no = %d ,r_w = %d, paddr = %lx  \n", seq_no, r_w, paddr);
    //record.vaddr = record.paddr;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
movl $0x1, %edx
callq 0x1190
cmpq $0x0, %rax
jne 0x17eb
leaq 0x395c(%rip), %rdi      # 0x5134
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18e2
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x6916(%rip)      # 0x8160
movl -0x38(%rbp), %eax
movl %eax, 0x68fd(%rip)      # 0x8150
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x68fd(%rip)      # 0x8160
jne 0x187d
cmpq $0x0, -0x28(%rbp)
jne 0x187d
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x17b4
movq -0x50(%rbp), %rax
shlq $0x8, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq 0xeeeee0(%rip), %rax    # 0xef0780
movq %rax, 0xeeeed9(%rip)    # 0xef0780
movq 0xeeeed2(%rip), %rax    # 0xef0780
movq %rax, 0x68a3(%rip)      # 0x8158
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, 0x689f(%rip)      # 0x8160
jb 0x18db
movabsq $0x80000000, %rax       # imm = 0x80000000
addq 0x688c(%rip), %rax      # 0x8160
movq %rax, 0x6885(%rip)      # 0x8160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ASG-ICT[P]SPEC2017-Trace/trace.cpp
// Function: next_tag(_IO_FILE*)
int next_tag(FILE *fp)
{
    int res = fread(tag, sizeof(char), KERNEL_TAG_SIZE, fp);
    if (res == 0) {
        fprintf(stderr, "start kt_begin");
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xeeee65(%rip), %rdi    # 0xef0768
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x1190
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1940
movq 0x66b2(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x3822(%rip), %rsi      # 0x5152
movb $0x0, %al
callq 0x1170
movl $0x0, -0x4(%rbp)
jmp 0x1947
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: ASG-ICT[P]SPEC2017-Trace/trace.cpp
// Function: read_kernel_trace()
char* read_kernel_trace(){

	if(kernel_trace_offset >= KT_BUFFER_SIZE)
	{
		fread(kernel_trace_buffer, 1, KT_BUFFER_SIZE, ktfp) ;//read again
		kernel_trace_offset = 0;
	}
	else{
		kernel_trace_offset += 13;
	}
	return kernel_trace_buffer + kernel_trace_offset; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xeee519(%rip), %rax    # 0xef0674
cmpq $0xd00000, %rax         # imm = 0xD00000
jb 0x218c
movq 0xeee5f6(%rip), %rcx    # 0xef0760
leaq 0x1ee49f(%rip), %rdi    # 0x1f0610
movl $0x1, %esi
movl $0xd00000, %edx         # imm = 0xD00000
callq 0x1190
movl $0x0, 0xeee4ea(%rip)    # 0xef0674
jmp 0x219b
movl 0xeee4e2(%rip), %eax    # 0xef0674
addl $0xd, %eax
movl %eax, 0xeee4d9(%rip)    # 0xef0674
movslq 0xeee4d2(%rip), %rcx    # 0xef0674
leaq 0x1ee467(%rip), %rax    # 0x1f0610
addq %rcx, %rax
popq %rbp
retq
nop
// File: ASG-ICT[P]SPEC2017-Trace/trace.cpp
// Function: trace_finish()
void trace_finish()
{
    printf(" set_pte_cnt = %llu,free_pte_cnt = %llu, set_pte_tag_cnt = %llu,free_pte_tag_cnt = %llu, dump_set_pte_cnt = %llu,dump_free_pte_cnt = %llu\n", set_pte_cnt,free_pte_cnt, set_pte_tag_cnt,  free_pte_tag_cnt, dump_set_pte_cnt, dump_free_pte_cnt);
    printf("ALL_nonpte = %llu\n",nonpte);
    printf("total trace = %llu,  trace_id = %llu ,tag_cnt = %llu, tagp = %lu \n",total_trace, trace_id,tag_cnt, tagp);
    printf("free pte_num = %llu\n",free_pte_num);
    printf("miss_free_pte = %llu,  miss_set_pte = %llu\n",miss_free_pte, miss_set_pte); 
    printf("skip_set_pt_pmd = %llu\n",skip_set_pt_pmd);
    printf("topmc tag [%d]\n",topmc_tag);
    int i;

#ifndef VADDR 
    for(i = 0 ; i < pid_len ; i++){
	printf("pid = %lu , trace_num = %llu\n", pidindex[i], pid_trace_num[i]);
    }
#endif

    delete next_page_map;
    delete prev_page_map;
    delete ppn2vpn;
//    delete vpn2ppn;
    delete ppn2pid;
    fclose(tracefp);
    fclose(ktfp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xeedd11(%rip), %rsi    # 0xef0790
movq 0xeedd12(%rip), %rdx    # 0xef0798
movq 0xeedd13(%rip), %rcx    # 0xef07a0
movq 0xeedd14(%rip), %r8     # 0xef07a8
movq 0xeedd15(%rip), %r9     # 0xef07b0
movq 0xeedd16(%rip), %rax    # 0xef07b8
leaq 0x2a6e(%rip), %rdi      # 0x5517
movq %rax, (%rsp)
movb $0x0, %al
callq 0x1050
movq 0xeedd3d(%rip), %rsi    # 0xef07f8
leaq 0x2ae0(%rip), %rdi      # 0x55a2
movb $0x0, %al
callq 0x1050
movq 0xeedd20(%rip), %rsi    # 0xef07f0
movq 0x5671(%rip), %rdx      # 0x8148
movq 0xeedd2a(%rip), %rcx    # 0xef0808
movl 0xeedc8b(%rip), %r8d    # 0xef0770
leaq 0x2ac9(%rip), %rdi      # 0x55b5
movb $0x0, %al
callq 0x1050
movq 0xeedc8e(%rip), %rsi    # 0xef0788
leaq 0x2af7(%rip), %rdi      # 0x55f8
movb $0x0, %al
callq 0x1050
movq 0xeedd79(%rip), %rsi    # 0xef0888
movq 0xeedd7a(%rip), %rdx    # 0xef0890
leaq 0x2af0(%rip), %rdi      # 0x560d
movb $0x0, %al
callq 0x1050
movq 0xeedd35(%rip), %rsi    # 0xef0860
leaq 0x25a6(%rip), %rdi      # 0x50d8
movb $0x0, %al
callq 0x1050
movl 0xeedd31(%rip), %esi    # 0xef0870
leaq 0x2af3(%rip), %rdi      # 0x5639
movb $0x0, %al
callq 0x1050
movq 0xeedcbc(%rip), %rax    # 0xef0810
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2b6c
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x1110
movq 0xeedca5(%rip), %rax    # 0xef0818
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2b8b
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x1110
movq 0xeedc3e(%rip), %rax    # 0xef07d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2baa
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x1110
movq 0xeedc27(%rip), %rax    # 0xef07d8
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2bc9
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x1110
movq 0xeedbf8(%rip), %rdi    # 0xef07c8
callq 0x10f0
movq 0xeedb84(%rip), %rdi    # 0xef0760
callq 0x10f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Rjerk[P]ratabase/Logger.cpp
// Function: logging::getTimeStr[abi:cxx11]()
std::string getTimeStr()
{
    std::time_t t;
    std::time(&t);
    std::string str = std::ctime(&t);
    str.erase(str.size()-1);
    return str;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21e0
movq 0x10(%rsp), %rdi
movb $0x0, 0x47(%rsp)
callq 0x20d0
movq %rax, 0x20(%rsp)
leaq 0x46(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x22f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x2260
jmp 0x284e
leaq 0x46(%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
callq 0x2160
movq 0x18(%rsp), %rdi
movq %rax, %rsi
decq %rsi
movq $-0x1, %rdx
callq 0x2060
jmp 0x287b
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x28c7
jmp 0x28bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x46(%rsp), %rdi
callq 0x2220
jmp 0x28d1
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2140
jmp 0x28d1
movq 0x18(%rsp), %rdi
callq 0x2140
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: Rjerk[P]ratabase/Logger.cpp
// Function: logging::Logger::Logger(char const*, int, char const*, logging::Logger::LogLevel)
Logger::Logger(const char* filename, int line, const char* func_name, LogLevel level)
{
    setLevel(level);
    sstream_ << "[";
    sstream_ << level_string[level];
    sstream_ << "]";
    sstream_ << getTimeStr() << " ";
    sstream_ << filename << " ";
    sstream_ << "(" << line << ") ";
    sstream_ << func_name << " ";
    sstream_ << ": ";
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq %rcx, 0x78(%rsp)
movl %r8d, 0x74(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
callq 0x2170
movl 0x74(%rsp), %edi
callq 0x2ad0
jmp 0x292d
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
leaq 0x178b(%rip), %rsi      # 0x40c8
callq 0x2200
jmp 0x2944
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movl 0x74(%rsp), %eax
movl %eax, %ecx
leaq 0x4846(%rip), %rax      # 0x71a0
movq (%rax,%rcx,8), %rsi
callq 0x2200
jmp 0x2965
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1755(%rip), %rsi      # 0x40ca
callq 0x2200
jmp 0x297c
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x27f0
jmp 0x2996
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x21d0
movq %rax, 0x20(%rsp)
jmp 0x29ac
movq 0x20(%rsp), %rdi
leaq 0x1717(%rip), %rsi      # 0x40cf
callq 0x2200
jmp 0x29bf
leaq 0x40(%rsp), %rdi
callq 0x2140
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movq 0x88(%rsp), %rsi
callq 0x2200
movq %rax, 0x18(%rsp)
jmp 0x29e6
movq 0x18(%rsp), %rdi
leaq 0x16dd(%rip), %rsi      # 0x40cf
callq 0x2200
jmp 0x29f9
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
leaq 0x16c3(%rip), %rsi      # 0x40cc
callq 0x2200
movq %rax, 0x10(%rsp)
jmp 0x2a15
movq 0x10(%rsp), %rdi
movl 0x84(%rsp), %esi
callq 0x22c0
movq %rax, 0x8(%rsp)
jmp 0x2a2d
movq 0x8(%rsp), %rdi
leaq 0x1695(%rip), %rsi      # 0x40ce
callq 0x2200
jmp 0x2a40
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movq 0x78(%rsp), %rsi
callq 0x2200
movq %rax, (%rsp)
jmp 0x2a59
movq (%rsp), %rdi
leaq 0x166b(%rip), %rsi      # 0x40cf
callq 0x2200
jmp 0x2a6b
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
leaq 0x18f8(%rip), %rsi      # 0x4373
callq 0x2200
jmp 0x2a82
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x2ab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2140
movq 0x30(%rsp), %rdi
callq 0x2180
movq 0x68(%rsp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: Rjerk[P]ratabase/Logger.cpp
// Function: logging::Logger::~Logger()
Logger::~Logger()
{
    if (output_callback_) {
        std::string str = sstream_.str();
        sstream_.flush();
        output_callback_(std::move(str));
    }
    if (level_limit_ == Fatal) {
        sstream_.flush();
        ::abort();
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4696(%rip), %rdi      # 0x71f0
callq 0x3000
testb $0x1, %al
jne 0x2b68
jmp 0x2c08
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x21f0
jmp 0x2b79
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x2150
jmp 0x2b89
leaq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x40(%rsp), %rsi
callq 0x2130
movq (%rsp), %rsi
leaq 0x4649(%rip), %rdi      # 0x71f0
callq 0x3030
jmp 0x2bae
leaq 0x10(%rsp), %rdi
callq 0x2140
leaq 0x40(%rsp), %rdi
callq 0x2140
jmp 0x2c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x2c35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x2bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2140
leaq 0x40(%rsp), %rdi
callq 0x2140
jmp 0x2c35
cmpl $0x5, 0x45d9(%rip)      # 0x71e8
jne 0x2c26
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x2150
jmp 0x2c21
callq 0x2110
movq 0x8(%rsp), %rdi
callq 0x2180
addq $0x68, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x38(%rsp), %rdi
callq 0x2250
nopl (%rax)