LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: test_alloc
void test_alloc(void)
{
	const unsigned size = 10 * TOMMY_SIZE;
	unsigned i;
	tommy_allocator alloc;
	void** PTR;

	PTR = malloc(size * sizeof(void*));

	/* ensure at least pointer alignment */
	tommy_allocator_init(&alloc, sizeof(void*), 1);
	if (alloc.align_size < sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	/* ensure correct alignment */
	tommy_allocator_init(&alloc, sizeof(void*) - 1, sizeof(void*));
	if (alloc.block_size != sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	/* check big blocks */
	tommy_allocator_init(&alloc, 128000, 64);
	if (tommy_allocator_alloc(&alloc) == 0)
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */
	tommy_allocator_done(&alloc);

	tommy_allocator_init(&alloc, 64, 64);

	START("alloc");
	for(i=0;i<size;++i) {
		PTR[i] = tommy_allocator_alloc(&alloc);
	}
	STOP();

	START("free");
	for(i=0;i<size;++i) {
		tommy_allocator_free(&alloc, PTR[i]);
	}
	STOP();

	tommy_allocator_done(&alloc);

	free(PTR);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl $0x4c4b400, %edi        # imm = 0x4C4B400
callq 0x10b0
movq %rax, %rbx
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x35a6
cmpq $0x7, 0x18(%r14)
jbe 0x1674
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x35dd
pushq $0x7
popq %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x35a6
cmpq $0x8, 0x10(%r14)
jne 0x1674
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x35dd
pushq $0x40
popq %rdx
movl $0x1f400, %esi          # imm = 0x1F400
movq %r14, %rdi
callq 0x35a6
movq %r14, %rdi
callq 0x360d
testq %rax, %rax
je 0x1674
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x35dd
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x35a6
leaq 0x4b98(%rip), %rdi      # 0x6196
callq 0x127d
xorl %r15d, %r15d
cmpq $0x989680, %r15         # imm = 0x989680
je 0x1620
movq %r14, %rdi
callq 0x360d
movq %rax, (%rbx,%r15,8)
incq %r15
jmp 0x1606
callq 0x12cf
leaq 0x4b70(%rip), %rdi      # 0x619c
callq 0x127d
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
cmpq $0x989680, %r15         # imm = 0x989680
je 0x1653
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x36a5
incq %r15
jmp 0x1639
callq 0x12cf
leaq 0x8(%rsp), %rdi
callq 0x35dd
movq %rbx, %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: test_array
void test_array(void)
{
	tommy_array array;
	tommy_uintptr_t i;
	const unsigned size = 50 * TOMMY_SIZE;

	tommy_array_init(&array);

	/* no op */
	tommy_array_grow(&array, 0);

	START("array init");
	for(i=0;i<size;++i) {
		tommy_array_grow(&array, i + 1);
		if (tommy_array_get(&array, i) != 0)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	START("array set");
	for(i=0;i<size;++i) {
		tommy_array_set(&array, i, (void*)i);
	}
	STOP();

	START("array get");
	for(i=0;i<size;++i) {
		if (tommy_array_get(&array, i) != (void*)i)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	if (tommy_array_memory_usage(&array) < size * sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */

	tommy_array_done(&array);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x36bd
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3744
leaq 0x43ec(%rip), %rdi      # 0x6209
callq 0x127d
movl $0x2faf080, %r12d       # imm = 0x2FAF080
subq $0x1, %r12
jb 0x1e52
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3744
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1eeb
movq %r15, %r14
testq %rax, %rax
je 0x1e28
jmp 0x1eba
callq 0x12cf
leaq 0x43b6(%rip), %rdi      # 0x6214
callq 0x127d
xorl %ebx, %ebx
movq %rsp, %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x1e84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3163
movq %rbx, (%rax)
incq %rbx
jmp 0x1e68
callq 0x12cf
leaq 0x438e(%rip), %rdi      # 0x621e
callq 0x127d
xorl %ebx, %ebx
movq %rsp, %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x1ebf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1eeb
leaq 0x1(%rbx), %rcx
cmpq %rbx, %rax
movq %rcx, %rbx
je 0x1e9a
callq 0x1040
callq 0x12cf
movq %rsp, %rdi
callq 0x37b6
cmpq $0x17d783ff, %rax       # imm = 0x17D783FF
jbe 0x1eba
movq %rsp, %rdi
callq 0x3700
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: test_arrayof
void test_arrayof(void)
{
	tommy_arrayof arrayof;
	unsigned i;
	const unsigned size = 50 * TOMMY_SIZE;

	tommy_arrayof_init(&arrayof, sizeof(unsigned));

	/* no op */
	tommy_arrayof_grow(&arrayof, 0);

	START("arrayof init");
	for(i=0;i<size;++i) {
		tommy_arrayof_grow(&arrayof, i + 1);
		unsigned* ref = tommy_arrayof_ref(&arrayof, i);
		if (*ref != 0)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	START("arrayof set");
	for(i=0;i<size;++i) {
		unsigned* ref = tommy_arrayof_ref(&arrayof, i);
		*ref = i;
	}
	STOP();

	START("arrayof get");
	for(i=0;i<size;++i) {
		unsigned* ref = tommy_arrayof_ref(&arrayof, i);
		if (*ref != i)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	if (tommy_arrayof_memory_usage(&arrayof) < size * sizeof(unsigned))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */

	tommy_arrayof_done(&arrayof);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x37c2
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x384a
leaq 0x4300(%rip), %rdi      # 0x6228
callq 0x127d
movl $0x2faf080, %r12d       # imm = 0x2FAF080
subq $0x1, %r12
jb 0x1f5d
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x384a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ffc
cmpl $0x0, (%rax)
movq %r15, %r14
je 0x1f33
jmp 0x1fc7
callq 0x12cf
leaq 0x42cc(%rip), %rdi      # 0x6235
callq 0x127d
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x1f90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ffc
movl %ebx, (%rax)
incq %rbx
jmp 0x1f75
callq 0x12cf
leaq 0x42a5(%rip), %rdi      # 0x6241
callq 0x127d
pushq $-0x1
popq %rbx
leaq 0x8(%rsp), %r14
cmpq $0x2faf07f, %rbx        # imm = 0x2FAF07F
je 0x1fcc
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ffc
movl (%rax), %eax
cmpq %rax, %rbx
je 0x1fa9
callq 0x1040
callq 0x12cf
leaq 0x8(%rsp), %rdi
callq 0x38bf
cmpq $0xbebc1ff, %rax        # imm = 0xBEBC1FF
jbe 0x1fc7
leaq 0x8(%rsp), %rdi
callq 0x3809
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/./tommyds/tommyarrayof.h
// Function: tommy_arrayof_ref
tommy_inline void* tommy_arrayof_ref(tommy_arrayof* array, tommy_size_t pos)
{
	unsigned char* ptr;
	tommy_uint_t bsr;

	assert(pos < array->count);

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

	ptr = tommy_cast(unsigned char*, array->bucket[bsr]);

	return ptr + pos * array->element_size;
}

// Assembly:
cmpq %rsi, 0x210(%rdi)
jbe 0x2023
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
imulq 0x200(%rdi), %rsi
shll $0x3, %eax
addq (%rdi,%rax), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x42e2(%rip), %rdi      # 0x630d
leaq 0x4339(%rip), %rsi      # 0x636b
leaq 0x434b(%rip), %rcx      # 0x6384
pushq $0x60
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: test_arrayblk
void test_arrayblk(void)
{
	tommy_arrayblk arrayblk;
	tommy_uintptr_t i;
	const unsigned size = 50 * TOMMY_SIZE;

	tommy_arrayblk_init(&arrayblk);

	/* no op */
	tommy_arrayblk_grow(&arrayblk, 0);

	START("arrayblk init");
	for(i=0;i<size;++i) {
		tommy_arrayblk_grow(&arrayblk, i + 1);
		if (tommy_arrayblk_get(&arrayblk, i) != 0)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	START("arrayblk set");
	for(i=0;i<size;++i) {
		tommy_arrayblk_set(&arrayblk, i, (void*)i);
	}
	STOP();

	START("arrayblk get");
	for(i=0;i<size;++i) {
		if (tommy_arrayblk_get(&arrayblk, i) != (void*)i)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	if (tommy_arrayblk_memory_usage(&arrayblk) < size * sizeof(void*))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */

	tommy_arrayblk_done(&arrayblk);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x38cf
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3927
leaq 0x41dd(%rip), %rdi      # 0x624d
callq 0x127d
movl $0x2faf080, %r12d       # imm = 0x2FAF080
subq $0x1, %r12
jb 0x20a5
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3927
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2146
movq %r15, %r14
testq %rax, %rax
je 0x207b
jmp 0x2111
callq 0x12cf
leaq 0x41aa(%rip), %rdi      # 0x625b
callq 0x127d
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x20d9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31a4
movq %rbx, (%rax)
incq %rbx
jmp 0x20bd
callq 0x12cf
leaq 0x4183(%rip), %rdi      # 0x6268
callq 0x127d
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x2116
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2146
leaq 0x1(%rbx), %rcx
cmpq %rbx, %rax
movq %rcx, %rbx
je 0x20f1
callq 0x1040
callq 0x12cf
leaq 0x8(%rsp), %rdi
callq 0x399e
cmpq $0x17d783ff, %rax       # imm = 0x17D783FF
jbe 0x2111
leaq 0x8(%rsp), %rdi
callq 0x38e2
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/check.c
// Function: test_arrayblkof
void test_arrayblkof(void)
{
	tommy_arrayblkof arrayblkof;
	unsigned i;
	const unsigned size = 50 * TOMMY_SIZE;

	tommy_arrayblkof_init(&arrayblkof, sizeof(unsigned));

	/* no op */
	tommy_arrayblkof_grow(&arrayblkof, 0);

	START("arrayblkof init");
	for(i=0;i<size;++i) {
		tommy_arrayblkof_grow(&arrayblkof, i + 1);
		unsigned* ref = tommy_arrayblkof_ref(&arrayblkof, i);
		if (*ref != 0)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	START("arrayblkof set");
	for(i=0;i<size;++i) {
		unsigned* ref = tommy_arrayblkof_ref(&arrayblkof, i);
		*ref = i;
	}
	STOP();

	START("arrayblkof get");
	for(i=0;i<size;++i) {
		unsigned* ref = tommy_arrayblkof_ref(&arrayblkof, i);
		if (*ref != i)
			/* LCOV_EXCL_START */
			abort();
			/* LCOV_EXCL_STOP */
	}
	STOP();

	if (tommy_arrayblkof_memory_usage(&arrayblkof) < size * sizeof(unsigned))
		/* LCOV_EXCL_START */
		abort();
		/* LCOV_EXCL_STOP */

	tommy_arrayblkof_done(&arrayblkof);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsp, %rbx
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x39b5
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a15
leaq 0x40f4(%rip), %rdi      # 0x6275
callq 0x127d
movl $0x2faf080, %r12d       # imm = 0x2FAF080
subq $0x1, %r12
jb 0x21b6
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x224d
cmpl $0x0, (%rax)
movq %r15, %r14
je 0x218c
jmp 0x221c
callq 0x12cf
leaq 0x40c3(%rip), %rdi      # 0x6285
callq 0x127d
xorl %ebx, %ebx
movq %rsp, %r14
cmpq $0x2faf080, %rbx        # imm = 0x2FAF080
je 0x21e7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x224d
movl %ebx, (%rax)
incq %rbx
jmp 0x21cc
callq 0x12cf
leaq 0x40a1(%rip), %rdi      # 0x6294
callq 0x127d
pushq $-0x1
popq %rbx
movq %rsp, %r14
cmpq $0x2faf07f, %rbx        # imm = 0x2FAF07F
je 0x2221
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x224d
movl (%rax), %eax
cmpq %rax, %rbx
je 0x21fe
callq 0x1040
callq 0x12cf
movq %rsp, %rdi
callq 0x3a8d
cmpq $0xbebc1ff, %rax        # imm = 0xBEBC1FF
jbe 0x221c
movq %rsp, %rdi
callq 0x39db
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/./tommyds/tommyarrayblkof.h
// Function: tommy_arrayblkof_ref
tommy_inline void* tommy_arrayblkof_ref(tommy_arrayblkof* array, tommy_size_t pos)
{
	unsigned char* base;

	assert(pos < array->count);

	base = tommy_cast(unsigned char*, tommy_array_get(&array->block, pos / TOMMY_ARRAYBLKOF_SIZE));

	return base + (pos % TOMMY_ARRAYBLKOF_SIZE) * array->element_size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x220(%rdi)
jbe 0x2282
movq %rsi, %rbx
movq %rdi, %r14
shrq $0xc, %rsi
callq 0x1eeb
andl $0xfff, %ebx            # imm = 0xFFF
imulq 0x218(%r14), %rbx
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4084(%rip), %rdi      # 0x630d
leaq 0x417f(%rip), %rsi      # 0x640f
leaq 0x4194(%rip), %rcx      # 0x642b
pushq $0x5d
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/./tommyds/tommyarray.h
// Function: tommy_array_ref
tommy_inline void** tommy_array_ref(tommy_array* array, tommy_size_t pos)
{
	tommy_uint_t bsr;

	assert(pos < array->count);

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

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

// Assembly:
cmpq %rsi, 0x208(%rdi)
jbe 0x3186
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
shlq $0x3, %rsi
addq (%rdi,%rax), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x317f(%rip), %rdi      # 0x630d
leaq 0x318b(%rip), %rsi      # 0x6320
leaq 0x319b(%rip), %rcx      # 0x6337
pushq $0x5c
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/./tommyds/tommyarrayblk.h
// Function: tommy_arrayblk_ref
tommy_inline void** tommy_arrayblk_ref(tommy_arrayblk* array, tommy_size_t pos)
{
	void** ptr;

	assert(pos < array->count);

	ptr = tommy_cast(void**, tommy_array_get(&array->block, pos / TOMMY_ARRAYBLK_SIZE));

	return &ptr[pos % TOMMY_ARRAYBLK_SIZE];
}

// Assembly:
pushq %rbx
cmpq %rsi, 0x218(%rdi)
jbe 0x31c6
movq %rsi, %rbx
shrq $0xc, %rsi
callq 0x1eeb
andl $0xfff, %ebx            # imm = 0xFFF
leaq (%rax,%rbx,8), %rax
popq %rbx
retq
leaq 0x3140(%rip), %rdi      # 0x630d
leaq 0x31e7(%rip), %rsi      # 0x63bb
leaq 0x31fa(%rip), %rcx      # 0x63d5
pushq $0x5b
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
pushq $0x6
popq %r14
pushq $0x1
popq %r15
movl 0x210(%rbx), %eax
cmpq %rax, %r14
jae 0x373e
movq %r15, %rdi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x3718
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarray.c
// Function: tommy_array_grow
void tommy_array_grow(tommy_array* array, tommy_size_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 = (tommy_size_t)1 << array->bucket_bit;
	}
}

// Assembly:
cmpq %rsi, 0x208(%rdi)
jae 0x37b5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x208(%rdi)
movq 0x200(%rdi), %r12
pushq $0x8
popq %r15
pushq $0x1
popq %r13
cmpq %rbx, %r12
jae 0x37ac
movq %r12, %rdi
movq %r15, %rsi
callq 0x10a0
shlq $0x3, %r12
subq %r12, %rax
movl 0x210(%r14), %ecx
movq %rax, (%r14,%rcx,8)
incl %ecx
movl %ecx, 0x210(%r14)
movq %r13, %r12
shlq %cl, %r12
movq %r12, 0x200(%r14)
jmp 0x3772
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarrayof.c
// Function: tommy_arrayof_grow
void tommy_arrayof_grow(tommy_arrayof* array, tommy_size_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 = (tommy_size_t)1 << array->bucket_bit;
	}
}

// Assembly:
cmpq %rsi, 0x210(%rdi)
jae 0x38be
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x210(%rdi)
movq 0x208(%rdi), %r15
pushq $0x1
popq %r13
cmpq %rbx, %r15
jae 0x38b5
movq 0x200(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a0
imulq %r12, %r15
subq %r15, %rax
movl 0x218(%r14), %ecx
movq %rax, (%r14,%rcx,8)
incl %ecx
movl %ecx, 0x218(%r14)
movq %r13, %r15
shlq %cl, %r15
movq %r15, 0x208(%r14)
jmp 0x3874
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarrayblk.c
// Function: tommy_arrayblk_done
void tommy_arrayblk_done(tommy_arrayblk* array)
{
	tommy_size_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
xorl %r14d, %r14d
cmpq 0x208(%rbx), %r14
jae 0x390d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x391c
movq %rax, %rdi
callq 0x1030
incq %r14
jmp 0x38ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3700
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarrayblk.c
// Function: tommy_arrayblk_grow
void tommy_arrayblk_grow(tommy_arrayblk* array, tommy_size_t count)
{
	tommy_size_t block_max;
	tommy_size_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:
cmpq %rsi, 0x218(%rdi)
jae 0x399d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x218(%rdi)
addq $0xfff, %rbx            # imm = 0xFFF
shrq $0xc, %rbx
movq 0x208(%rdi), %r15
cmpq %rbx, %r15
jae 0x3994
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3744
pushq $0x8
popq %r12
cmpq %r15, %rbx
je 0x3994
movl $0x1000, %edi           # imm = 0x1000
movq %r12, %rsi
callq 0x10a0
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e58
movq %r13, (%rax)
incq %r15
jmp 0x396c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarrayblkof.c
// Function: tommy_arrayblkof_done
void tommy_arrayblkof_done(tommy_arrayblkof* array)
{
	tommy_size_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
xorl %r14d, %r14d
cmpq 0x208(%rbx), %r14
jae 0x3a06
movq %rbx, %rdi
movq %r14, %rsi
callq 0x391c
movq %rax, %rdi
callq 0x1030
incq %r14
jmp 0x39e5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3700
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyarrayblkof.c
// Function: tommy_arrayblkof_grow
void tommy_arrayblkof_grow(tommy_arrayblkof* array, tommy_size_t count)
{
	tommy_size_t block_max;
	tommy_size_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:
cmpq %rsi, 0x220(%rdi)
jae 0x3a8c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x220(%rdi)
addq $0xfff, %rbx            # imm = 0xFFF
shrq $0xc, %rbx
movq 0x208(%rdi), %r15
cmpq %rbx, %r15
jae 0x3a81
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3744
cmpq %r15, %rbx
je 0x3a81
movq 0x218(%r14), %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x10a0
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e58
movq %r12, (%rax)
incq %r15
jmp 0x3a55
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/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->index = 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)
andq $0x0, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
movq %r15, %rdx
callq 0x3bf9
movq %rax, (%rbx)
movq (%r15), %rax
cmpq %r14, %rax
jne 0x3beb
incq 0x10(%rbx)
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/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;

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

	node->data = data;
	node->index = 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 %rcx, %rax
shrq $0x20, %rax
jne 0x3f80
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rcx, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %r13
pushq $0x1b
popq %rbp
movq (%r13), %r12
testq %r12, %r12
je 0x3f5e
testb $0x1, %r12b
je 0x3ee2
movq %r15, %rax
movl %ebp, %ecx
shrq %cl, %rax
andl $0x7, %eax
leaq (%r12,%rax,8), %r13
decq %r13
addl $-0x3, %ebp
jmp 0x3eb8
cmpq %r15, 0x18(%r12)
jne 0x3f01
movq 0x8(%r12), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x8(%r12)
andq $0x0, (%r14)
movq 0x8(%r14), %r13
jmp 0x3f66
movq 0x110(%rbx), %rdi
callq 0x360d
incq 0x108(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, (%r13)
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x3f2e
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x3f1e
movq 0x18(%r12), %rsi
movl %ebp, %ecx
shrq %cl, %rsi
movq %r15, %rdx
shrq %cl, %rdx
movl %esi, %ecx
xorl %edx, %ecx
andl $0x7, %esi
leaq (%rax,%rsi,8), %r13
testb $0x7, %cl
jne 0x3f53
addl $-0x3, %ebp
jmp 0x3f01
movq %r12, (%r13)
andl $0x7, %edx
leaq (%rax,%rdx,8), %r13
movq %r14, 0x8(%r14)
andq $0x0, (%r14)
movq %r14, (%r13)
incq 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25d9(%rip), %rdi      # 0x6560
leaq 0x2609(%rip), %rsi      # 0x6597
leaq 0x2616(%rip), %rcx      # 0x65ab
movl $0x9e, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/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;

	/* 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, 0, key);

	if (!ret)
		return 0;

	--trie->count;

	return ret->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x3fe2
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x4001
testq %rax, %rax
je 0x3fd7
decq 0x100(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2577(%rip), %rdi      # 0x6560
leaq 0x25a7(%rip), %rsi      # 0x6597
leaq 0x2601(%rip), %rcx      # 0x65f8
movl $0x105, %edx            # imm = 0x105
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x18(%rsi), %rcx
movq %rcx, %rax
shrq $0x20, %rax
jne 0x415c
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x4001
cmpq %r14, %rax
jne 0x417b
decq 0x100(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x23fd(%rip), %rdi      # 0x6560
leaq 0x242d(%rip), %rsi      # 0x6597
leaq 0x24ba(%rip), %rcx      # 0x662b
movl $0x11a, %edx            # imm = 0x11A
callq 0x1090
leaq 0x24eb(%rip), %rdi      # 0x666d
leaq 0x240e(%rip), %rsi      # 0x6597
leaq 0x249b(%rip), %rcx      # 0x662b
movl $0x121, %edx            # imm = 0x121
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x41e2
movq %rsi, %rax
shrq $0x1b, %rax
leaq (%rdi,%rax,8), %rdx
pushq $0x1b
popq %rcx
xorl %eax, %eax
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x41e0
testb $0x1, %dl
je 0x41d6
movq %rsi, %rdi
shrq %cl, %rdi
andl $0x7, %edi
leaq (%rdx,%rdi,8), %rdx
decq %rdx
addl $-0x3, %ecx
jmp 0x41b4
xorl %eax, %eax
cmpq %rsi, 0x18(%rdx)
cmoveq %rdx, %rax
popq %rcx
retq
leaq 0x2377(%rip), %rdi      # 0x6560
leaq 0x23a7(%rip), %rsi      # 0x6597
leaq 0x2482(%rip), %rcx      # 0x6679
movl $0x130, %edx            # imm = 0x130
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rcx, %rax
shrq $0x20, %rcx
jne 0x42b7
movq %rdx, 0x10(%rsi)
movq %rax, 0x38(%rsi)
pushq $0x3
popq %rcx
cmpq $0x7, %rcx
je 0x425b
andq $0x0, (%rsi,%rcx,8)
incq %rcx
jmp 0x424b
movq %rax, %rcx
shrq $0x1a, %rcx
leaq (%rdi,%rcx,8), %rdx
pushq $0x1a
popq %rcx
movq (%rdx), %r8
testq %r8, %r8
je 0x428d
cmpq %rax, 0x38(%r8)
je 0x4297
movq %rax, %rdx
shrq %cl, %rdx
andl $0x3, %edx
leaq (%r8,%rdx,8), %rdx
addq $0x18, %rdx
addl $-0x2, %ecx
jmp 0x4269
movq %rsi, 0x8(%rsi)
andq $0x0, (%rsi)
jmp 0x42ab
movq 0x8(%r8), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r8)
andq $0x0, (%rsi)
movq 0x8(%rsi), %rdx
movq %rsi, (%rdx)
incq 0x200(%rdi)
popq %rax
retq
leaq 0x23f9(%rip), %rdi      # 0x66b7
leaq 0x2439(%rip), %rsi      # 0x66fe
leaq 0x2449(%rip), %rcx      # 0x6715
movl $0x85, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x4319
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x1a, %rax
leaq (%rdi,%rax,8), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x4338
testq %rax, %rax
je 0x430e
decq 0x200(%rbx)
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2397(%rip), %rdi      # 0x66b7
leaq 0x23d7(%rip), %rsi      # 0x66fe
leaq 0x244c(%rip), %rcx      # 0x677a
movl $0xe0, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x38(%rsi), %rdx
movq %rdx, %rax
shrq $0x20, %rax
jne 0x443c
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x1a, %rax
leaq (%rdi,%rax,8), %rdi
callq 0x4338
cmpq %r14, %rax
jne 0x445b
decq 0x200(%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2274(%rip), %rdi      # 0x66b7
leaq 0x22b4(%rip), %rsi      # 0x66fe
leaq 0x236c(%rip), %rcx      # 0x67bd
movl $0xf5, %edx
callq 0x1090
leaq 0x220b(%rip), %rdi      # 0x666d
leaq 0x2295(%rip), %rsi      # 0x66fe
leaq 0x234d(%rip), %rcx      # 0x67bd
movl $0xfc, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsi, %rax
shrq $0x20, %rax
jne 0x44b8
movq %rsi, %rax
shrq $0x1a, %rax
leaq (%rdi,%rax,8), %rax
pushq $0x1a
popq %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x44b6
cmpq %rsi, 0x38(%rax)
je 0x44b6
movq %rsi, %rdx
shrq %cl, %rdx
andl $0x3, %edx
leaq (%rax,%rdx,8), %rax
addq $0x18, %rax
addl $-0x2, %ecx
jmp 0x4492
popq %rcx
retq
leaq 0x21f8(%rip), %rdi      # 0x66b7
leaq 0x2238(%rip), %rsi      # 0x66fe
leaq 0x234a(%rip), %rcx      # 0x6817
movl $0x109, %edx            # imm = 0x109
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpq $0x10, %rsi
jae 0x44f2
pushq $0x10
popq %rsi
jmp 0x4533
decq %rsi
movq %rsi, %rax
shrq %rax
orq %rsi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x20, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
leaq -0x1(%rsi), %rax
movq %rax, 0x10(%rbx)
shlq $0x3, %rsi
pushq $0x1
popq %rdi
callq 0x10a0
movq %rax, (%rbx)
andq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
andq %rcx, %rdi
shlq $0x3, %rdi
addq (%r15), %rdi
callq 0x458c
movq %rbx, 0x18(%r14)
incq 0x18(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
andq 0x18(%rsi), %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
callq 0x45e8
decq 0x18(%r14)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
andq %rcx, %r14
shlq $0x3, %r14
movq (%rdi), %r15
addq %r14, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4666
cmpq %r12, 0x18(%r15)
jne 0x4633
movq 0x10(%r15), %rsi
movq %r13, %rdi
callq *%rbp
testl %eax, %eax
jne 0x4633
addq (%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x45e8
decq 0x18(%rbx)
movq 0x10(%r15), %rax
jmp 0x4668
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x46ae
movq (%r14,%r12,8), %rax
testq %rax, %rax
je 0x46a9
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x4696
incq %r12
jmp 0x468d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x46f8
movq (%r15,%r13,8), %rax
testq %rax, %rax
je 0x46f3
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x46dc
incq %r13
jmp 0x46d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyhashdyn.c
// Function: tommy_hashdyn_init
void tommy_hashdyn_init(tommy_hashdyn* hashdyn)
{
	/* fixed initial size */
	hashdyn->bucket_bit = TOMMY_HASHDYN_BIT;
	hashdyn->bucket_max = (tommy_size_t)1 << hashdyn->bucket_bit;
	hashdyn->bucket_mask = hashdyn->bucket_max - 1;
	hashdyn->bucket = tommy_cast(tommy_hashdyn_node**, tommy_calloc(hashdyn->bucket_max, sizeof(tommy_hashdyn_node*)));

	hashdyn->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x4, 0x20(%rdi)
movq $0x10, 0x8(%rdi)
movq $0xf, 0x10(%rdi)
pushq $0x10
popq %rdi
pushq $0x8
popq %rsi
callq 0x10a0
movq %rax, (%rbx)
andq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
andq %rcx, %rdi
shlq $0x3, %rdi
addq (%rbx), %rdi
callq 0x458c
movq %r14, 0x18(%r15)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
incq %rcx
movq %rcx, 0x18(%rbx)
shrq %rax
cmpq %rax, %rcx
jae 0x4792
popq %rbx
popq %r14
popq %r15
retq
movl 0x20(%rbx), %esi
incl %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x50a6
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
andq 0x18(%rsi), %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
callq 0x45e8
decq 0x18(%r14)
movq %r14, %rdi
callq 0x47da
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
andq %rcx, %r15
shlq $0x3, %r15
movq (%rdi), %r14
addq %r15, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x485b
cmpq %r12, 0x18(%r14)
jne 0x4820
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq *%rbp
testl %eax, %eax
jne 0x4820
addq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x45e8
decq 0x18(%rbx)
movq %rbx, %rdi
callq 0x47da
movq 0x10(%r14), %rax
jmp 0x485d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x48a3
movq (%r14,%r12,8), %rax
testq %rax, %rax
je 0x489e
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x488b
incq %r12
jmp 0x4882
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x48ed
movq (%r15,%r13,8), %rax
testq %rax, %rax
je 0x48e8
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x48d1
incq %r13
jmp 0x48c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
pushq $0x6
popq %r14
pushq $0x1
popq %r15
movl 0x230(%rbx), %eax
cmpq %rax, %r14
jae 0x49b8
movq %r15, %rdi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x4992
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x4b60
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x458c
movq %r14, 0x18(%r12)
movq 0x228(%rbx), %r15
incq %r15
movq %r15, 0x228(%rbx)
movl 0x234(%rbx), %eax
cmpl $0x1, %eax
je 0x4a86
movq 0x200(%rbx), %r14
movq %r14, %rcx
shrq %rcx
cmpq %rcx, %r15
jbe 0x4b54
testl %eax, %eax
jne 0x4a7c
movq %r14, 0x210(%rbx)
movq 0x208(%rbx), %rax
movq %rax, 0x218(%rbx)
shlq $0x3, %r14
movq %r14, %rdi
callq 0x10b0
subq %r14, %rax
movl 0x230(%rbx), %edx
leal 0x1(%rdx), %ecx
pushq $0x1
popq %rsi
shlq %cl, %rsi
movq %rax, (%rbx,%rdx,8)
movl %ecx, 0x230(%rbx)
movq %rsi, 0x200(%rbx)
decq %rsi
movq %rsi, 0x208(%rbx)
andq $0x0, 0x220(%rbx)
movl $0x1, 0x234(%rbx)
addq %r15, %r15
movq 0x210(%rbx), %rax
movq 0x220(%rbx), %rcx
leaq (%rcx,%rax), %rdx
cmpq %r15, %rdx
jae 0x4b54
movq %rcx, %rsi
orq $0x1, %rsi
bsrq %rsi, %rsi
shll $0x3, %esi
movq (%rbx,%rsi), %rsi
leaq (%rsi,%rcx,8), %rsi
movq %rsi, (%rsp)
movq %rdx, %rdi
orq $0x1, %rdi
bsrq %rdi, %rdi
shll $0x3, %edi
movq (%rbx,%rdi), %rdi
leaq (%rdi,%rdx,8), %rdi
movq %rdi, 0x8(%rsp)
movq (%rsi), %rdx
andq $0x0, (%rsi)
andq $0x0, (%rdi)
testq %rdx, %rdx
je 0x4b24
movq (%rdx), %rsi
xorl %edi, %edi
testq %rax, 0x18(%rdx)
setne %dil
movq (%rsp,%rdi,8), %rdi
movq (%rdi), %r8
testq %r8, %r8
je 0x4b14
movq 0x8(%r8), %rdi
movq %rdi, 0x8(%rdx)
movq %rdx, 0x8(%r8)
movq 0x8(%rdx), %rdi
jmp 0x4b18
movq %rdx, 0x8(%rdx)
andq $0x0, (%rdx)
movq %rdx, (%rdi)
movq %rsi, %rdx
jmp 0x4ae4
incq %rcx
movq %rcx, 0x220(%rbx)
cmpq %rax, %rcx
jne 0x4a97
andl $0x0, 0x234(%rbx)
movups 0x200(%rbx), %xmm0
movups %xmm0, 0x210(%rbx)
andq $0x0, 0x220(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x4b60
movq %rax, %rdi
movq %rbx, %rsi
callq 0x45e8
decq 0x228(%r14)
movq %r14, %rdi
callq 0x4bcd
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq