LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/utils/dumphex.cpp
// Function: dump_hex(int, void*, unsigned long)
void
dump_hex(int lvl, void *vp, size_t len)
{
	char linebuf[80];
	size_t i;
	int linebuf_dirty = 0;
	unsigned char *p = (unsigned char *)vp;

	memset(linebuf, ' ', sizeof(linebuf));
	linebuf[70] = '\0';

	for (i = 0; i < len; i++) {
		int x = i % 16;
		int ch = (unsigned)p[i];
		char hex[20];

		if (x >= 8)
			x = x * 3 + 1;
		else
			x = x * 3;
		snprintf(hex, sizeof(hex), "%02x", ch);
		linebuf[x] = hex[0];
		linebuf[x + 1] = hex[1];

		if (isprint(ch))
			linebuf[52 + (i % 16)] = ch;
		else
			linebuf[52 + (i % 16)] = '.';

		linebuf_dirty = 1;
		if (!((i + 1) % 16)) {
			fprintf(stderr, "%s\n", linebuf);
			memset(linebuf, ' ', sizeof(linebuf));
			linebuf[70] = '\0';
			linebuf_dirty = 0;
		}
	}
	if (linebuf_dirty == 1)
		fprintf(stderr, "%s\n", linebuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movaps 0x1387(%rip), %xmm0     # 0xa2d0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movb $0x0, 0x46(%rsp)
testq %rdx, %rdx
je 0x9025
movq %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
movl %r12d, %r15d
andl $0xf, %r15d
movzbl (%r14,%r12), %ebp
cmpq $0x8, %r15
leal (%r15,%r15,2), %r13d
sbbq $-0x1, %r13
movl $0x14, %esi
leaq 0x50(%rsp), %rdi
leaq 0x133f(%rip), %rdx      # 0xa2e0
movl %ebp, %ecx
xorl %eax, %eax
callq 0x4530
movzwl 0x50(%rsp), %eax
movw %ax, (%rsp,%r13)
movl %ebp, %edi
callq 0x45d0
movl $0x2e, %ecx
testl %eax, %eax
je 0x8fc6
movl %ebp, %ecx
movq %rsp, %rax
movb %cl, 0x34(%r15,%rax)
incq %r12
testb $0xf, %r12b
je 0x8fde
cmpq %r12, %rbx
jne 0x8f78
jmp 0x901f
movq 0x3ff3(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x1252(%rip), %rsi      # 0xa241
movq %rsp, %rdx
xorl %eax, %eax
callq 0x4480
movaps 0x12d0(%rip), %xmm0     # 0xa2d0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x0, 0x46(%rsp)
jmp 0x8fd7
testb $0xf, %r12b
jne 0x9034
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f9d(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x11fc(%rip), %rsi      # 0xa241
movq %rsp, %rdx
xorl %eax, %eax
callq 0x4480
jmp 0x9025
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/test-1.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tommy_allocator alloc;
	tommy_trie h;
	 tommy_allocator_init(&alloc, TOMMY_TRIE_BLOCK_SIZE, TOMMY_TRIE_BLOCK_SIZE);
	tommy_trie_init(&h, &alloc);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key;
		intcell_t *p;
		x = hash32(x);
		key = get_key(n, x);
		p = tommy_trie_search(&h, key);
		if (!p) {
			p = malloc(sizeof(intcell_t));
			p->key = key, p->cnt = 1;
			tommy_trie_insert(&h, &p->node, p, p->key);
			++z;
		} else z += ++p->cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", tommy_trie_count(&h), z);
	x = tommy_trie_count(&h);
	tommy_allocator_done(&alloc);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl %esi, %ebp
movl %edi, %ebx
movq %rsp, %r14
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1a65
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2777
xorl %r14d, %r14d
testl %ebx, %ebx
je 0x14df
movl %ebx, %r12d
shrl $0x2, %r12d
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
movl %ebp, %eax
shll $0xf, %eax
notl %eax
addl %ebp, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
xorl %eax, %ebp
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r13d
shrl $0x10, %r13d
xorl %eax, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x2abd
testq %rax, %rax
je 0x149c
movq 0x10(%rax), %rax
jmp 0x149e
xorl %eax, %eax
testq %rax, %rax
je 0x14ad
movl 0x4(%rax), %ecx
incl %ecx
movl %ecx, 0x4(%rax)
jmp 0x14d4
pushq $0x28
popq %rdi
callq 0x1090
movl %r13d, (%rax)
movl $0x1, 0x4(%rax)
leaq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x27a7
pushq $0x1
popq %rcx
addl %ecx, %r14d
decl %ebx
jne 0x1428
movq 0x5b12(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x128(%rsp), %edx
leaq 0x2b7e(%rip), %rsi      # 0x4075
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1080
movl 0x128(%rsp), %ebx
movq %rsp, %rdi
callq 0x1aa0
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhash.c
// Function: tommy_hash_u32
tommy_uint32_t tommy_hash_u32(tommy_uint32_t init_val, const void* void_key, tommy_size_t key_len)
{
	const unsigned char* key = tommy_cast(const unsigned char*, void_key);
	tommy_uint32_t a, b, c;

	a = b = c = 0xdeadbeef + ((tommy_uint32_t)key_len) + init_val;

	while (key_len > 12) {
		a += tommy_le_uint32_read(key + 0);
		b += tommy_le_uint32_read(key + 4);
		c += tommy_le_uint32_read(key + 8);

		tommy_mix(a, b, c);

		key_len -= 12;
		key += 12;
	}

	switch (key_len) {
	case 0 :
		return c; /* used only when called with a zero length */
	case 12 :
		c += tommy_le_uint32_read(key + 8);
		b += tommy_le_uint32_read(key + 4);
		a += tommy_le_uint32_read(key + 0);
		break;
	case 11 : c += ((tommy_uint32_t)key[10]) << 16;
	case 10 : c += ((tommy_uint32_t)key[9]) << 8;
	case 9 : c += key[8];
	case 8 :
		b += tommy_le_uint32_read(key + 4);
		a += tommy_le_uint32_read(key + 0);
		break;
	case 7 : b += ((tommy_uint32_t)key[6]) << 16;
	case 6 : b += ((tommy_uint32_t)key[5]) << 8;
	case 5 : b += key[4];
	case 4 :
		a += tommy_le_uint32_read(key + 0);
		break;
	case 3 : a += ((tommy_uint32_t)key[2]) << 16;
	case 2 : a += ((tommy_uint32_t)key[1]) << 8;
	case 1 : a += key[0];
	}

	tommy_final(a, b, c);

	return c;
}

// Assembly:
leal (%rdi,%rdx), %eax
addl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
cmpq $0xd, %rdx
jb 0x1716
movl %eax, %ecx
movl %eax, %edi
addl (%rsi), %edi
addl 0x4(%rsi), %ecx
addl 0x8(%rsi), %eax
movl %eax, %r8d
roll $0x4, %r8d
subl %eax, %edi
xorl %edi, %r8d
addl %ecx, %eax
subl %r8d, %ecx
movl %r8d, %r9d
roll $0x6, %r9d
xorl %ecx, %r9d
addl %eax, %r8d
movl %r9d, %r10d
roll $0x8, %r10d
subl %r9d, %eax
xorl %eax, %r10d
addl %r8d, %r9d
subl %r10d, %r8d
movl %r10d, %edi
roll $0x10, %edi
xorl %r8d, %edi
addl %r9d, %r10d
movl %edi, %ecx
roll $0x13, %ecx
subl %edi, %r9d
xorl %r9d, %ecx
addl %r10d, %edi
subl %ecx, %r10d
movl %ecx, %eax
roll $0x4, %eax
xorl %r10d, %eax
addl %edi, %ecx
addq $-0xc, %rdx
addq $0xc, %rsi
cmpq $0xc, %rdx
ja 0x16a6
jmp 0x171a
movl %eax, %edi
movl %eax, %ecx
leaq 0x2977(%rip), %r8       # 0x4098
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movzbl 0x2(%rsi), %edx
shll $0x10, %edx
addl %edx, %edi
movzbl 0x1(%rsi), %edx
shll $0x8, %edx
addl %edx, %edi
movzbl (%rsi), %edx
addl %edx, %edi
jmp 0x177f
movzbl 0xa(%rsi), %edx
shll $0x10, %edx
addl %edx, %eax
movzbl 0x9(%rsi), %edx
shll $0x8, %edx
addl %edx, %eax
movzbl 0x8(%rsi), %edx
addl %edx, %eax
jmp 0x1760
addl 0x8(%rsi), %eax
addl 0x4(%rsi), %ecx
jmp 0x177d
movzbl 0x6(%rsi), %edx
shll $0x10, %edx
addl %edx, %ecx
movzbl 0x5(%rsi), %edx
shll $0x8, %edx
addl %edx, %ecx
movzbl 0x4(%rsi), %edx
addl %edx, %ecx
addl (%rsi), %edi
xorl %ecx, %eax
movl %ecx, %edx
roll $0xe, %edx
subl %edx, %eax
xorl %eax, %edi
movl %eax, %edx
roll $0xb, %edx
subl %edx, %edi
movl %edi, %edx
roll $0x19, %edx
xorl %edi, %ecx
subl %edx, %ecx
xorl %ecx, %eax
movl %ecx, %edx
roll $0x10, %edx
subl %edx, %eax
xorl %eax, %edi
movl %eax, %edx
roll $0x4, %edx
subl %edx, %edi
xorl %edi, %ecx
roll $0xe, %edi
subl %edi, %ecx
xorl %ecx, %eax
roll $0x18, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyalloc.c
// Function: tommy_allocator_init
void tommy_allocator_init(tommy_allocator* alloc, tommy_size_t block_size, tommy_size_t align_size)
{
	/* setup the minimal alignment */
	if (align_size < sizeof(void*))
		align_size = sizeof(void*);

	/* ensure that the block_size keeps the alignment */
	if (block_size % align_size != 0)
		block_size += align_size - block_size % align_size;

	alloc->block_size = block_size;
	alloc->align_size = align_size;

	alloc->count = 0;
	alloc->free_block = 0;
	alloc->used_segment = 0;
}

// Assembly:
cmpq $0x9, %rdx
movl $0x8, %ecx
cmovaeq %rdx, %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
subq %rdx, %rax
testq %rdx, %rdx
cmoveq %rdx, %rax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_init
void tommy_array_init(tommy_array* array)
{
	tommy_uint_t i;

	/* fixed initial size */
	array->bucket_bit = TOMMY_ARRAY_BIT;
	array->bucket_max = 1 << array->bucket_bit;
	array->bucket[0] = tommy_cast(void**, tommy_calloc(array->bucket_max, sizeof(void*)));
	for (i = 1; i < TOMMY_ARRAY_BIT; ++i)
		array->bucket[i] = array->bucket[0];

	array->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x4000000006, %rax     # imm = 0x4000000006
movq %rax, 0x100(%rdi)
movl $0x40, %edi
movl $0x8, %esi
callq 0x1070
movq %rax, (%rbx)
xorl %ecx, %ecx
movdqa 0x254d(%rip), %xmm0     # 0x4100
movdqa 0x2555(%rip), %xmm1     # 0x4110
movdqa 0x255d(%rip), %xmm2     # 0x4120
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movq %rcx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm0, %xmm4
pxor %xmm1, %xmm4
movdqa %xmm2, %xmm5
pcmpgtd %xmm4, %xmm5
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pcmpeqd %xmm3, %xmm4
pand %xmm5, %xmm4
movd %xmm4, %edx
testb $0x1, %dl
je 0x1bfd
movq %rax, 0x8(%rbx,%rcx,8)
pextrw $0x4, %xmm4, %edx
testb $0x1, %dl
je 0x1c0c
movq %rax, 0x10(%rbx,%rcx,8)
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x1bc8
movl $0x0, 0x108(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_done
void tommy_array_done(tommy_array* array)
{
	tommy_uint_t i;

	tommy_free(array->bucket[0]);
	for (i = TOMMY_ARRAY_BIT; i < array->bucket_bit; ++i) {
		void** segment = array->bucket[i];
		tommy_free(&segment[((tommy_ptrdiff_t)1) << i]);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
cmpl $0x7, 0x100(%rbx)
jb 0x1c66
movl $0x6, %r14d
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x100(%rbx), %eax
cmpq %rax, %r14
jb 0x1c40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_grow
void tommy_array_grow(tommy_array* array, tommy_count_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		void** segment;

		/* allocate one more segment */
		segment = tommy_cast(void**, tommy_calloc(array->bucket_max, sizeof(void*)));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = &segment[-(tommy_ptrdiff_t)array->bucket_max];

		++array->bucket_bit;
		array->bucket_max = 1 << array->bucket_bit;
	}
}

// Assembly:
cmpl %esi, 0x108(%rdi)
jae 0x1cdf
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x108(%rdi)
movl 0x104(%rdi), %eax
cmpl %esi, %eax
jae 0x1cd5
movl 0x100(%rbx), %r14d
movl %eax, %r15d
movl $0x8, %esi
movq %r15, %rdi
callq 0x1070
shlq $0x3, %r15
subq %r15, %rax
movl %r14d, %ecx
movq %rax, (%rbx,%rcx,8)
incl %r14d
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
cmpl %ebp, %eax
jb 0x1c99
movl %r14d, 0x100(%rbx)
movl %eax, 0x104(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_init
void tommy_arrayof_init(tommy_arrayof* array, tommy_size_t element_size)
{
	tommy_uint_t i;

	/* fixed initial size */
	array->element_size = element_size;
	array->bucket_bit = TOMMY_ARRAYOF_BIT;
	array->bucket_max = 1 << array->bucket_bit;
	array->bucket[0] = tommy_calloc(array->bucket_max, array->element_size);
	for (i = 1; i < TOMMY_ARRAYOF_BIT; ++i)
		array->bucket[i] = array->bucket[0];

	array->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x100(%rdi)
movabsq $0x4000000006, %rax     # imm = 0x4000000006
movq %rax, 0x108(%rdi)
movl $0x40, %edi
callq 0x1070
movq %rax, (%rbx)
xorl %ecx, %ecx
movdqa 0x23e2(%rip), %xmm0     # 0x4100
movdqa 0x23ea(%rip), %xmm1     # 0x4110
movdqa 0x23f2(%rip), %xmm2     # 0x4120
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movq %rcx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm0, %xmm4
pxor %xmm1, %xmm4
movdqa %xmm2, %xmm5
pcmpgtd %xmm4, %xmm5
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pcmpeqd %xmm3, %xmm4
pand %xmm5, %xmm4
movd %xmm4, %edx
testb $0x1, %dl
je 0x1d68
movq %rax, 0x8(%rbx,%rcx,8)
pextrw $0x4, %xmm4, %edx
testb $0x1, %dl
je 0x1d77
movq %rax, 0x10(%rbx,%rcx,8)
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x1d33
movl $0x0, 0x110(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_done
void tommy_arrayof_done(tommy_arrayof* array)
{
	tommy_uint_t i;

	tommy_free(array->bucket[0]);
	for (i = TOMMY_ARRAYOF_BIT; i < array->bucket_bit; ++i) {
		unsigned char* segment = tommy_cast(unsigned char*, array->bucket[i]);
		tommy_free(segment + (((tommy_ptrdiff_t)1) << i) * array->element_size);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
cmpl $0x7, 0x108(%rbx)
jb 0x1dcf
movl $0x6, %r14d
movq 0x100(%rbx), %rdi
movl %r14d, %ecx
shlq %cl, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x108(%rbx), %eax
cmpq %rax, %r14
jb 0x1dab
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_grow
void tommy_arrayof_grow(tommy_arrayof* array, tommy_count_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		unsigned char* segment;

		/* allocate one more segment */
		segment = tommy_cast(unsigned char*, tommy_calloc(array->bucket_max, array->element_size));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = segment - (tommy_ptrdiff_t)array->bucket_max * array->element_size;

		++array->bucket_bit;
		array->bucket_max = 1 << array->bucket_bit;
	}
}

// Assembly:
cmpl %esi, 0x110(%rdi)
jae 0x1e4c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x110(%rdi)
movl 0x10c(%rdi), %eax
cmpl %esi, %eax
jae 0x1e44
movq 0x100(%rbx), %r15
movl 0x108(%rbx), %r14d
movl %eax, %r12d
movq %r12, %rdi
movq %r15, %rsi
callq 0x1070
imulq %r15, %r12
subq %r12, %rax
movl %r14d, %ecx
movq %rax, (%rbx,%rcx,8)
incl %r14d
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
cmpl %ebp, %eax
jb 0x1e0a
movl %r14d, 0x108(%rbx)
movl %eax, 0x10c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayblk.c
// Function: tommy_arrayblk_done
void tommy_arrayblk_done(tommy_arrayblk* array)
{
	tommy_count_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x1f37
xorl %r14d, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq (%rbx,%rax,8), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x108(%rbx), %eax
cmpq %rax, %r14
jb 0x1f13
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c22
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayblk.c
// Function: tommy_arrayblk_grow
void tommy_arrayblk_grow(tommy_arrayblk* array, tommy_count_t count)
{
	tommy_count_t block_max;
	tommy_count_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLK_SIZE - 1) / TOMMY_ARRAYBLK_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLK_SIZE, sizeof(void*)));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl %esi, 0x110(%rdi)
jae 0x1fbd
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x110(%rdi)
addl $0xfff, %ebx            # imm = 0xFFF
shrl $0xc, %ebx
movl 0x108(%rdi), %r15d
cmpl %r15d, %ebx
jbe 0x1fbd
movq %r14, %rdi
movl %ebx, %esi
callq 0x1c6e
movl 0x108(%r14), %r12d
cmpl %r12d, %r15d
cmoval %r15d, %r12d
subl %r15d, %ebx
movl $0x1000, %edi           # imm = 0x1000
movl $0x8, %esi
callq 0x1070
cmpq %r15, %r12
je 0x1fc9
movl %r15d, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
movq (%r14,%rcx,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
decl %ebx
jne 0x1f91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22a1(%rip), %rdi      # 0x4271
leaq 0x22ad(%rip), %rsi      # 0x4284
leaq 0x22b5(%rip), %rcx      # 0x4293
movl $0x61, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayblkof.c
// Function: tommy_arrayblkof_done
void tommy_arrayblkof_done(tommy_arrayblkof* array)
{
	tommy_count_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x20ed
xorl %r14d, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq (%rbx,%rax,8), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x108(%rbx), %eax
cmpq %rax, %r14
jb 0x20c9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c22
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyarrayblkof.c
// Function: tommy_arrayblkof_grow
void tommy_arrayblkof_grow(tommy_arrayblkof* array, tommy_count_t count)
{
	tommy_count_t block_max;
	tommy_count_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLKOF_SIZE - 1) / TOMMY_ARRAYBLKOF_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLKOF_SIZE, array->element_size));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl %esi, 0x118(%rdi)
jae 0x2179
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x118(%rdi)
addl $0xfff, %ebx            # imm = 0xFFF
shrl $0xc, %ebx
movl 0x108(%rdi), %r12d
cmpl %r12d, %ebx
jbe 0x2179
movq %r14, %rdi
movl %ebx, %esi
callq 0x1c6e
movq 0x110(%r14), %r15
movl 0x108(%r14), %r13d
cmpl %r13d, %r12d
cmoval %r12d, %r13d
subl %r12d, %ebx
movl $0x1000, %edi           # imm = 0x1000
movq %r15, %rsi
callq 0x1070
cmpq %r12, %r13
je 0x2183
movl %r12d, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
movq (%r14,%rcx,8), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
decl %ebx
jne 0x214f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x20e7(%rip), %rdi      # 0x4271
leaq 0x20f3(%rip), %rsi      # 0x4284
leaq 0x20fb(%rip), %rcx      # 0x4293
movl $0x61, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_insert
void* tommy_tree_insert(tommy_tree* tree, tommy_tree_node* node, void* data)
{
	tommy_tree_node* insert = node;

	insert->data = data;
	insert->prev = 0;
	insert->next = 0;
	insert->key = 0;

	tree->root = tommy_tree_insert_node(tree->cmp, tree->root, &insert);

	if (insert == node)
		++tree->count;

	return insert->data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x10(%rsi)
movl $0x0, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdi
movq %r15, %rdx
callq 0x2510
movq %rax, (%rbx)
movq (%r15), %rax
cmpq %r14, %rax
jne 0x2502
incl 0x8(%rbx)
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_insert_node
static tommy_tree_node* tommy_tree_insert_node(tommy_compare_func* cmp, tommy_tree_node* root, tommy_tree_node** let)
{
	int c;

	if (!root)
		return *let;

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

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

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

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

	return root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rax
testq %rsi, %rsi
je 0x254a
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rax), %rdi
movq 0x10(%rsi), %rsi
callq *%r15
testl %eax, %eax
js 0x254f
je 0x256f
movq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2510
movq %rax, (%rbx)
jmp 0x2562
movq %rax, %rbx
jmp 0x2572
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2510
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x37dd
movq %rbx, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_remove
void* tommy_tree_remove(tommy_tree* tree, void* data)
{
	tommy_tree_node* node = 0;

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

	if (!node)
		return 0;

	--tree->count;

	return node->data;
}

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

	if (!root)
		return 0;

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

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

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

	/* found */
	*let = root;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x25fb
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %rsi
movq %rdx, %rdi
callq *%r12
testl %eax, %eax
js 0x2609
je 0x2632
movq (%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x25bc
movq %rax, (%rbx)
jmp 0x261f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x25bc
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x37dd
movq %rbx, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x38fa
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_search_node
static tommy_tree_node* tommy_tree_search_node(tommy_compare_func* cmp, tommy_tree_node* root, void* data)
{
	int c;

	if (!root)
		return 0;

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

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

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

	return root;
}

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

	if (!root)
		return;

	tommy_tree_foreach_node(root->prev, func);

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

	func(root->data);

	tommy_tree_foreach_node(next, func);
}

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

	if (!root)
		return;

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

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

	func(arg, root->data);

	tommy_tree_foreach_arg_node(next, func, arg);
}

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

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

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

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

	++trie->count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
movl %ecx, %eax
shrl $0x1b, %eax
leaq (%rdi,%rax,8), %r14
movq (%r14), %r13
testq %r13, %r13
je 0x28ef
movl %ecx, %ebp
movl $0x1b, %r15d
testb $0x1, %r13b
je 0x2811
movq %r13, %rdx
movl %ebp, %eax
movl %r15d, %ecx
shrl %cl, %eax
andl $0x7, %eax
movq -0x1(%rdx,%rax,8), %r13
movq %rdx, %rcx
decq %rcx
testq %r13, %r13
je 0x28d6
addl $-0x3, %r15d
movq %r13, %rdx
testb $0x1, %r13b
jne 0x27e2
leaq (%rcx,%rax,8), %r14
cmpl %ebp, 0x18(%r13)
jne 0x2833
movq 0x8(%r13), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r13)
movq $0x0, (%rsi)
movq 0x8(%rsi), %r14
jmp 0x28fa
movq %rsi, (%rsp)
movq 0x108(%rbx), %rdi
callq 0x1ad5
movq %rax, %r12
incl 0x104(%rbx)
incq %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movl 0x18(%r13), %edx
movl %r15d, %ecx
shrl %cl, %edx
movl %ebp, %esi
shrl %cl, %esi
andl $0x7, %edx
andl $0x7, %esi
cmpl %esi, %edx
jne 0x28dc
addl $-0x3, %r15d
movl %edx, %r14d
movq 0x108(%rbx), %rdi
callq 0x1ad5
xorps %xmm0, %xmm0
incl 0x104(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, (%r12,%r14,8)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl 0x18(%r13), %edx
movl %r15d, %ecx
shrl %cl, %edx
andl $0x7, %edx
movl %ebp, %esi
shrl %cl, %esi
andl $0x7, %esi
addl $-0x3, %r15d
movq %rax, %r12
cmpl %esi, %edx
je 0x2887
jmp 0x28df
leaq (%rcx,%rax,8), %r14
jmp 0x28ef
movq %r12, %rax
movl %edx, %ecx
movq %r13, (%rax,%rcx,8)
movl %esi, %ecx
leaq (%rax,%rcx,8), %r14
movq (%rsp), %rsi
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
movq %rsi, (%r14)
incl 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_remove
void* tommy_trie_remove(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* ret;
	tommy_trie_node** let_ptr;

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

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

	if (!ret)
		return 0;

	--trie->count;

	return ret->data;
}

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

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

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

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

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %ecx
movl %ecx, %eax
shrl $0x1b, %eax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x2948
cmpq %r14, %rax
jne 0x2a9e
decl 0x100(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1705(%rip), %rdi      # 0x41aa
leaq 0x170a(%rip), %rsi      # 0x41b6
leaq 0x1711(%rip), %rcx      # 0x41c4
movl $0x118, %edx            # imm = 0x118
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_insert
void tommy_trie_inplace_insert(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node, void* data, tommy_key_t key)
{
	tommy_trie_inplace_node** let_ptr;
	tommy_uint_t i;

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

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

	trie_inplace_bucket_insert(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

	++trie_inplace->count;
}

// Assembly:
movl %ecx, %eax
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x30(%rsi)
shrl $0x1a, %ecx
movq (%rdi,%rcx,8), %r9
testq %r9, %r9
je 0x2b7c
movl $0x1a, %ecx
movq %r9, %rdx
cmpl %eax, 0x18(%r9)
je 0x2b8d
movl %eax, %r8d
shrl %cl, %r8d
andl $0x3, %r8d
addl $-0x2, %ecx
movq 0x20(%rdx,%r8,8), %r9
testq %r9, %r9
jne 0x2b52
addq $0x20, %rdx
leaq (%rdx,%r8,8), %rax
jmp 0x2b80
leaq (%rdi,%rcx,8), %rax
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
jmp 0x2ba4
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%rdx)
movq $0x0, (%rsi)
movq 0x8(%rsi), %rax
movq %rsi, (%rax)
incl 0x200(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_remove
void* tommy_trie_inplace_remove(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* ret;
	tommy_trie_inplace_node** let_ptr;

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

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

	if (!ret)
		return 0;

	--trie_inplace->count;

	return ret->data;
}

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

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

	if (!node)
		return 0;

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

	tommy_trie_inplace_list_remove(let_ptr, remove);

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

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

		return remove;
	}

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

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

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

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

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

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

	return remove;
}

// Assembly:
movq %rsi, %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2c6c
cmpl %edx, 0x18(%rsi)
je 0x2c1d
movl $0x1a, %ecx
movl %edx, %edi
shrl %cl, %edi
movq %rsi, %r8
andl $0x3, %edi
movq 0x20(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
je 0x2c6c
addl $-0x2, %ecx
cmpl %edx, 0x18(%rsi)
jne 0x2bf9
addq $0x20, %r8
leaq (%r8,%rdi,8), %rdi
testq %rax, %rax
cmoveq %rsi, %rax
movq (%rax), %rcx
testq %rcx, %rcx
movq %rcx, %rdx
cmoveq %rsi, %rdx
movq 0x8(%rax), %r8
movq %r8, 0x8(%rdx)
movq %rdi, %rdx
cmpq %rax, %rsi
je 0x2c45
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq (%rdi), %rcx
cmpq %rsi, %rcx
je 0x2c6b
testq %rcx, %rcx
je 0x2c6f
movl $0x4, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq $0x8, %rdx
jne 0x2c5a
retq
xorl %eax, %eax
retq
xorl %edx, %edx
movq %rax, %rcx
leaq 0x20(%rcx), %rsi
movl $0x3, %r8d
movl %r8d, %r8d
movq (%rsi,%r8,8), %r9
testq %r9, %r9
jne 0x2c92
addl $-0x1, %r8d
jb 0x2c7e
jmp 0x2c9b
leaq (%rsi,%r8,8), %rdx
movq %r9, %rcx
jmp 0x2c74
testq %rdx, %rdx
je 0x2c6b
movq $0x0, (%rdx)
movl $0x4, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq $0x8, %rdx
jne 0x2cac
movq %rcx, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_remove_existing
void* tommy_trie_inplace_remove_existing(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node)
{
	tommy_trie_inplace_node* ret;
	tommy_key_t key = node->key;
	tommy_trie_inplace_node** let_ptr;

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

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

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

	--trie_inplace->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %edx
movl %edx, %eax
shrl $0x1a, %eax
leaq (%rdi,%rax,8), %rdi
callq 0x2be4
cmpq %r14, %rax
jne 0x2cf3
decl 0x200(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14b0(%rip), %rdi      # 0x41aa
leaq 0x1505(%rip), %rsi      # 0x4206
leaq 0x150f(%rip), %rcx      # 0x4217
movl $0xf3, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_bucket
tommy_trie_inplace_node* tommy_trie_inplace_bucket(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* node;
	tommy_uint_t shift;

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

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

	return node;
}

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

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

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

	hashtable->count = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %eax
cmpl $0x10, %esi
jb 0x2d81
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
movl %eax, 0x8(%rbx)
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
movl %eax, %r14d
shlq $0x3, %r14
movq %r14, %rdi
callq 0x1090
movq %rax, (%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1060
movl $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0xc(%rdi), %eax
andl %ecx, %eax
movq (%rdi), %r9
movq (%r9,%rax,8), %r8
testq %r8, %r8
je 0x2dea
movq 0x8(%r8), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r8)
movq $0x0, (%rsi)
movq 0x8(%rsi), %rax
jmp 0x2df9
leaq (%r9,%rax,8), %rax
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
movq %rsi, (%rax)
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
incl 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0xc(%rdi), %ecx
andl 0x18(%rsi), %ecx
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %r8
movq (%rsi), %rax
movq 0x8(%rsi), %r9
testq %rax, %rax
movq %rax, %r10
cmoveq %r8, %r10
movq %r9, 0x8(%r10)
cmpq %rsi, %r8
je 0x2e34
movq 0x8(%rsi), %rcx
jmp 0x2e38
leaq (%rdx,%rcx,8), %rcx
movq %rax, (%rcx)
decl 0x10(%rdi)
movq 0x10(%rsi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_remove
void* tommy_hashtable_remove(tommy_hashtable* hashtable, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashtable->bucket_mask;
	tommy_hashtable_node* node = hashtable->bucket[pos];

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

			--hashtable->count;

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

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rdi), %r15d
andl %ecx, %r15d
movq (%rdi), %rax
movq (%rax,%r15,8), %r13
testq %r13, %r13
je 0x2e89
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpl %ebp, 0x18(%r13)
jne 0x2e80
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq *%r12
testl %eax, %eax
je 0x2e8d
movq (%r13), %r13
testq %r13, %r13
jne 0x2e6c
xorl %eax, %eax
jmp 0x2ec3
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq (%r13), %rax
movq 0x8(%r13), %rsi
testq %rax, %rax
movq %rax, %rdi
cmoveq %rdx, %rdi
movq %rsi, 0x8(%rdi)
cmpq %r13, %rdx
je 0x2eb5
movq 0x8(%r13), %rcx
jmp 0x2eb9
leaq (%rcx,%r15,8), %rcx
movq %rax, (%rcx)
decl 0x10(%rbx)
movq 0x10(%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhashtbl.c
// Function: tommy_hashtable_foreach
void tommy_hashtable_foreach(tommy_hashtable* hashtable, tommy_foreach_func* func)
{
	tommy_count_t bucket_max = hashtable->bucket_max;
	tommy_hashtable_node** bucket = hashtable->bucket;
	tommy_count_t pos;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %r15d
testq %r15, %r15
je 0x2f5f
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
testq %rax, %rax
je 0x2f57
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
testq %rbp, %rbp
jne 0x2f42
incq %r13
cmpq %r15, %r13
jne 0x2f39
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x10(%rdi), %eax
andl %ecx, %eax
movq (%rdi), %r9
movq (%r9,%rax,8), %r8
testq %r8, %r8
je 0x2fd2
movq 0x8(%r8), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r8)
movq $0x0, (%rsi)
movq 0x8(%rsi), %rax
jmp 0x2fe1
leaq (%r9,%rax,8), %rax
movq %rsi, 0x8(%rsi)
movq $0x0, (%rsi)
movq %rsi, (%rax)
movq %rdx, 0x10(%rsi)
movl %ecx, 0x18(%rsi)
movl 0xc(%rdi), %eax
movl 0x14(%rdi), %ecx
incl %ecx
movl %ecx, 0x14(%rdi)
shrl %eax
cmpl %eax, %ecx
jae 0x2ffd
retq
movl 0x8(%rdi), %esi
incl %esi
jmp 0x391b
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_remove_existing
void* tommy_hashdyn_remove_existing(tommy_hashdyn* hashdyn, tommy_hashdyn_node* node)
{
	tommy_count_t pos = node->key & hashdyn->bucket_mask;

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

	--hashdyn->count;

	hashdyn_shrink_step(hashdyn);

	return node->data;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl 0x10(%rdi), %ecx
andl 0x18(%rsi), %ecx
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %r8
testq %rax, %rax
movq %rax, %r9
cmoveq %rsi, %r9
movq %r8, 0x8(%r9)
cmpq %rbx, %rsi
je 0x3038
movq 0x8(%rbx), %rcx
jmp 0x303c
leaq (%rdx,%rcx,8), %rcx
movq %rax, (%rcx)
movl 0xc(%rdi), %eax
movl 0x14(%rdi), %ecx
decl %ecx
movl %ecx, 0x14(%rdi)
shrl $0x3, %eax
cmpl %eax, %ecx
ja 0x3060
movl 0x8(%rdi), %esi
cmpl $0x5, %esi
jb 0x3060
decl %esi
callq 0x391b
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_remove
void* tommy_hashdyn_remove(tommy_hashdyn* hashdyn, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_count_t pos = hash & hashdyn->bucket_mask;
	tommy_hashdyn_node* node = hashdyn->bucket[pos];

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

			--hashdyn->count;

			hashdyn_shrink_step(hashdyn);

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

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rdi), %r15d
andl %ecx, %r15d
movq (%rdi), %rax
movq (%rax,%r15,8), %r13
testq %r13, %r13
je 0x30ac
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpl %ebp, 0x18(%r13)
jne 0x30a3
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq *%r12
testl %eax, %eax
je 0x30b0
movq (%r13), %r13
testq %r13, %r13
jne 0x308f
xorl %eax, %eax
jmp 0x3107
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq (%r13), %rax
movq 0x8(%r13), %rsi
testq %rax, %rax
movq %rax, %rdi
cmoveq %rdx, %rdi
movq %rsi, 0x8(%rdi)
cmpq %r13, %rdx
je 0x30d8
movq 0x8(%r13), %rcx
jmp 0x30dc
leaq (%rcx,%r15,8), %rcx
movq %rax, (%rcx)
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %ecx
decl %ecx
movl %ecx, 0x14(%rbx)
shrl $0x3, %eax
cmpl %eax, %ecx
ja 0x3103
movl 0x8(%rbx), %esi
cmpl $0x5, %esi
jb 0x3103
decl %esi
movq %rbx, %rdi
callq 0x391b
movq 0x10(%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/./tommyhashdyn.c
// Function: tommy_hashdyn_foreach
void tommy_hashdyn_foreach(tommy_hashdyn* hashdyn, tommy_foreach_func* func)
{
	tommy_count_t bucket_max = hashdyn->bucket_max;
	tommy_hashdyn_node** bucket = hashdyn->bucket;
	tommy_count_t pos;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0xc(%rdi), %r14d
testq %r14, %r14
je 0x3153
movq %rsi, %rbx
movq (%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rax
testq %rax, %rax
je 0x314b
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
testq %r13, %r13
jne 0x313a
incq %r12
cmpq %r14, %r12
jne 0x3131
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq